Java并发与并行，线程与进程，创建多线程的程序——Thread类的子类，实现Runnable接口，Thread类的常用方法，匿名内部类方式实现线程的创建。

1、并发与并行，线程与进程

并发：指两个或多个时间在同一个时间段内发生（交替执行）
并行：指两个或多个事件在同一时刻发生（同时发生）（同时执行）
进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程，一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序
简而言之：一个程序运行后至少有一个进程，一个进程可以包含多个线程。
多线程的好处：效率高，多个线程之间互不影响。
线程调度：
1、分时调度：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间。
2、抢占式调度：优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个（线程随机性），java使用的为抢占式调度。

2、主线程

主线程：执行主（main）方法的线程

单线程程序：java程序中只有一个线程，执行方法从main方法开始，从上到下依次执行。
缺点：出现异常之后下面的代码就不再执行。

3、创建多线程的程序——Thread类的子类

创建多线程程序的第一种方式：创建Thread类的子类
java.lang.Thread类：是描述线程的类，我们想要实现多线程程序，就必须继承Thread类

实现步骤：
1、创建一个Thread类的子类
2、在Thread类的子类中重写Thread类中的run方法，设置线程任务（开启线程要做什么）
3、创建Thread类的子类对象
4、调用Thread类中的方法start方法，开启新的线程，执行run方法
void start() 使该线程开始执行，java虚拟机调用该线程的run方法
结果是两个线程并发地运行，当前线程（main线程）和另一个线程（执行其run方法）。
多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动。
java程序属于抢占式调度，哪个线程优先级高，哪个线程优先执行，同一个优先级，随机选择执行。
代码演示：
Thread类子类：

public class MyThread extends Thread {
    
     //1、创建子类
    @Override
    public void run() {
    
     //重写run方法
        for (int i = 0; i < 20; i++) {
    
    
            System.out.println("run" + i);
        }
    }
}

主实现类：

public class Demo01Thread {
    
    
    public static void main(String[] args) {
    
    
        //3、创建Thread的子类对象
        MyThread thread = new MyThread();
        //4、调用Thread类中的方法start方法，开启新的线程，执行run方法
        thread.start();
        for (int i = 0; i < 20; i++) {
    
    
            System.out.println("main" + i);
        }
    }

}

4、Thread类的常用方法

获取线程的名称：
1、使用Thread类中的方法getName()
String getName() 返回该线程的名称
2、可以先获取到当前正在执行的线程，再使用线程中的方法getName()，获取线程的名称
Thread子类：

public class MyThread extends Thread{
    
    
    @Override
    public void run() {
    
    
        //获取线程的名称
//        String name = getName(); // Thread-0，Thread-1......
//        System.out.println(name);

//        Thread t = Thread.currentThread();
//        System.out.println(t);//Thread[Thread-1,5,main]

        //链式编程
        System.out.println(Thread.currentThread().getName());

    }
}

主类：

/*
    线程的名称：
        主线程：main
        新线程：Thread-0，Thread-1......
 */
public class Demo01GetThreadName {
    
    
    public static void main(String[] args) {
    
    
        //创建Thread子类对象
        MyThread mt = new MyThread();
        //调用start方法，开启新线程，执行run方法
        mt.start(); // Thread-0
        
        new MyThread().start(); //Thread-1

        //链式编程
        System.out.println(Thread.currentThread().getName()); //main
    }
}

5、设置线程名称的方法

设置线程名称：（了解）
1、设置Thread类中的setName(名字) 方法
void setName(String name)改变线程名称，使之与参数name相同
2、创建一个带参数的构造方法，参数传递线程的名称，调用父类的带参构造方法，把线程名称传递给父类，让父类（Thread）给字线程起一个名字
Thread(String name)分配新的Thread对象。

6、Thread类的sleep方法

public static void sleep(long millis)：使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
毫秒数结束之后，线程继续执行。

public class Demo03Sleep {
    
    
    public static void main(String[] args) {
    
    
        //模拟秒表
        for (int i = 1; i <= 60; i++) {
    
    
            System.out.println(i);

            //使用Thread的sleep方法让程序睡眠1秒钟
            try {
    
    
                Thread.sleep(1000);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
        }
    }
}

7、创建多线程程序的第二种方式——实现Runnable接口

创建多线程程序的第二种方式：实现Runnable接口
java.lang.Runnable
Runnable接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个成为run的无参数方法。
java.lang.Thread类的构造方法
Thread(Runnable target) 分配新的Thread对象
Thread(Runnable target, String name) 分配新的Thread对象

实现步骤：
1、创建一个Runnable接口的实现类
2、在实现类中重写Runnable接口的run方法，设置线程任务
3、创建一个Runnable接口的实现类对象
4、创建Thread类对象，构造方法中传递Runnable接口的实现对象
5、调用Thread类中的start方法，开启新的线程执行run方法
继承类：

//1、创建一个Runnable接口的实现类。
public class RunnableImpl implements Runnable{
    
    
    //2、在实现类中重写Runnable接口的run方法，设置线程任务
    @Override
    public void run() {
    
    
        for (int i = 0; i < 20; i++) {
    
    
            System.out.println(Thread.currentThread().getName() + i);
        }
    }
}

实现类：

/*
    创建多线程程序的第二种方式：实现Runnable接口
 */
public class Demo04Runnable {
    
    
    public static void main(String[] args) {
    
    
        //3、创建一个Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        //4、创建Thread类对象，构造方法中传递Runnable接口的实现对象
        Thread t = new Thread(run);

        //5、调用Thread类中的start方法，开启新的线程执行run方法
        t.start();
        for (int i = 0; i < 20; i++) {
    
    
            System.out.println(Thread.currentThread().getName() + i);
        }
    }
}

8、Thread类和Runnable接口的区别

实现Runnable接口创建多线程程序的好处：
1、避免了单继承的局限性-一个类只能继承一个类，类继承了Thread类就不能继承其他的类，实现了Runnable接口还可以继承其他的类，实现其他的接口
2、增强了程序的扩展性，降低了程序的耦合性（解耦）-实现Runnable接口的方式，把设置线程任务和开启新线程进行了分离（解耦），实现类中，重写了run方法，用来设置线程任务。创建Thread类对象调用start方法用来开启新线程。

9、匿名内部类方式实现线程的创建

匿名内部类方式实现线程的创建

匿名：没有名字
内部类：写在其他类内部的类

匿名内部类作用：简化代码
把子类继承父类，重写父类的方法，子类对象合一步完成
把实现类实现类接口，重写接口中的方法，创建实现类对象合成一步完成
匿名内部类的最终产物：子类/实现类对象/，而这个类没有名字

格式：new 父类/接口( ){
    
    
	重复父类/接口中的方法
	};

public class Demo05InnerClassThread {
    
    
    public static void main(String[] args) {
    
    
        //线程的父类是Thread
        new Thread(){
    
    
            @Override
            public void run() {
    
    
                for (int i = 0; i < 20; i++) {
    
    
                    System.out.println(Thread.currentThread().getName() + "--->程序员");
                }
            }
        }.start();

        //线程的接口Runnable
        //Runnable r = new RunnableImpl(); 多态
        Runnable r = new Runnable(){
    
    
            @Override
            public void run() {
    
    
                for (int i = 0; i < 20; i++) {
    
    
                    System.out.println(Thread.currentThread().getName() + "--->程序猿");
                }
            }
        };
        new Thread(r).start();

        //简化接口的方式
        new Thread(new Runnable(){
    
    
            @Override
            public void run() {
    
    
                for (int i = 0; i < 20; i++) {
    
    
                    System.out.println(Thread.currentThread().getName() + "--->打工人");
                }
            }
        }).start();
    }
}