006Java多线程002线程的创建及基本知识

部分内容来自以下博客：

https://www.cnblogs.com/dolphin0520/p/3913517.html

https://www.cnblogs.com/trust-freedom/p/6606594.html

https://www.cnblogs.com/sunddenly/p/4106562.html

1 创建线程

1.1 Thread类和Runnable接口

Thread类实现了Runnable接口，实现了Runnable接口里的run()方法。

事实上，查看Thread类的实现源代码会发现Thread类是实现了Runnable接口的。

在Java中，这两种方式都可以用来创建线程去执行子任务，具体选择哪一种方式要看自己的需求。直接继承Thread类的话，可能比实现Runnable接口看起来更加简洁，但是由于Java只允许单继承，所以如果自定义类需要继承其他类，则只能选择实现Runnable接口。

不论哪种方式创建线程，都必须重写run()方法，在run()方法中定义需要执行的任务。

创建好了自己的线程类之后，就可以创建线程对象了，然后通过start()方法去启动线程。注意，不是调用run()方法启动线程，run()方法中只是定义需要执行的任务，如果调用run()方法，即相当于在主线程中执行run()方法，跟普通的方法调用没有任何区别，此时并不会创建一个新的线程来执行定义的任务。

1.2 举例

在Java中创建线程有两种方法：

1）创建继承了Thread类的对象。

public class Demo {
    public static void main(String[] args) {
        Thread t1 = new DemoThread("线程一");
        Thread t2 = new DemoThread("线程二");
        t1.start();
        t2.start();
    }
}

class DemoThread extends Thread {
    public DemoThread(String name) {
        this.setName(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 100000; i++) {
            System.out.println(Thread.currentThread().getName() + " >>> " + i);
        }
    }
}

2）创建传入一个实现了Runnable接口的类的Thread对象。

public class Demo {
    public static void main(String[] args) {
        DemoThread dt = new DemoThread();
        Thread t1 = new Thread(dt, "线程一");
        Thread t2 = new Thread(dt, "线程二");
        t1.start();
        t2.start();
    }
}

class DemoThread implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100000; i++) {
            System.out.println(Thread.currentThread().getName() + " >>> " + i);
        }
    }
}

2 常用属性和方法

2.1 属性

priority：线程的优先级。最低为1，最高为10，默认为5。优先级高的线程获取CPU时间片的概率高。

threadStatus：线程的状态。常见的状态有NEW、RUNNABLE、BLOCKED、WAITING。

2.2 构造方法

Thread()：使用这种方式创建的线程，需要重写Thread类里的run()方法。

Thread(Runnable target)：使用这种方式创建的线程，需要实现Runnable接口里的run()方法。

2.3 静态方法

Thread.currentThread()：获取当前运行的线程。

2.4 常用方法

void run()：线程执行任务的主要代码。如果没有实现Runnable接口里的run()方法，则需要重写Thread类里的run()方法。

void start()：启动线程的方法，虚拟机会调用线程的run()方法。只用调用了start()方法，才会启动一个新的线程执行定义的任务。

void sleep(long millis)：本地方法，让当前线程休眠指定时间。sleep()方法不会释放占用的锁。

void join()：相当于void join(0)，传入0代表一直等待到结束。

void join(long millis)：执行指定的线程一段时间，直到执行时间达到传入的时间长度或者线程执行完毕。

void interrupt()：设置线程的中断状态为true，不会停止线程。

boolean interrupted()：返回当前线程的中断状态，然后将中断状态设置为false。

void yield()：让当前正在运行的线程让出它的时间片，给其他线程抢占的机会，可用于优化忙等待。

3 优先级

3.1 优先级及设置

线程的优先级是为了在多线程环境中便于系统对线程的调度，优先级越高先执行机会越大，并不是一定先执行。

线程的优先级可以理解为线程抢占CPU时间片的概率，并不能保证优先级高的线程一定会先执行。

不同的系统有不同的线程优先级的取值范围，同一个优先级在不同的系统里的值可能是不同的。

一个线程的优先级设置遵从以下原则：

线程创建时，子继承父的优先级。

线程创建后，可通过调用setPriority()方法改变优先级。

线程的优先级是1-10之间的正整数，线程优先级最高为10，最低为1，默认为5。

1- MIN_PRIORITY

10-MAX_PRIORITY

5-NORM_PRIORITY

3.2 调度策略

线程调度器选择优先级最高的线程运行。但是，如果发生以下情况，就会终止线程的运行：

线程体中调用了yield()方法，让出了对CPU的占用权。

线程体中调用了sleep()方法，使线程进入睡眠状态。

线程由于I/O操作而受阻塞。

另一个更高优先级的线程出现。

在支持时间片的系统中，该线程的时间片用完。

4 生命周期

线程的生命周期：一个线程从创建到消亡的过程。

如下图，表示线程生命周期中的各个状态：

4.1 新建状态（New）

当线程对象创建后，即进入了新建状态。

4.2 就绪状态（Ready）

当调用线程对象的start()方法，线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了start()此线程立即就会执行。

当调用线程的yield()方法时，线程从运行状态转换为就绪状态，但接下来CPU调度就绪状态中的哪个线程具有一定的随机性。

4.3 运行状态（Running）

当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。

注：就绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中。

4.4 阻塞状态（Blocked）

处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同，阻塞状态又可以分为三种。

等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态。

同步阻塞：线程在获取synchronized同步锁失败（因为锁被其它线程所占用），它会进入同步阻塞状态。

其他阻塞：通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、I/O处理完毕时，线程重新转入就绪状态。

4.5 死亡状态（Dead）

线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

5 状态

Java线程在运行的生命周期中可能处于六种不同的状态，在给定的一个时刻，线程只能处于其中的一个状态。

Java线程的各个状态改变如图：

5.1 初始状态（New）

线程刚被构建，但是还没有调用start()方法。

线程刚创建时具有的状态。

public static void main(String[] args) {
    Thread thread = new Thread();
    System.out.println(thread.getState());
}

5.2 运行状态（RUNNABLE）

Java系统系统中将操作系统中的就绪和运行两种状态笼统地称为“运行中”。

线程正在运行，线程获取CPU的时间片。

public static void main(String[] args) {
    Thread thread = new Thread();
    thread.start();
    System.out.println(thread.getState());
}

5.3 阻塞状态（BLOCKED）

表示线程阻塞于锁。

线程进入阻塞状态。假如有两个都是同步安全的线程，当一个线程处于RUNNABLE状态时，则另一个线程处于BLOCKED状态。

public static void main(String[] args) {
    Thread t1 = new Thread() {
        public void run() {
            synchronized (Object.class) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    };
    Thread t2 = new Thread() {
        public void run() {
            synchronized (Object.class) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    };
    t1.start();
    t2.start();
    try {
        Thread.sleep(100);
    } catch (Exception e) {
        e.printStackTrace();
    }
    System.out.println(t2.getState());
}

5.4 等待状态（WAITTING）

表示线程进入等待状态，进入该状态表示当前线程做出一些特定动作（通知或者中断）。

程序处于等待状态，调用wait()、join()、await()、lock()等方法，都会使线程处于WAITTING状态，需要注意的是这些方法必须是无参数的。

public static void main(String[] args) {
    Thread t = new Thread() {
        public void run() {
            synchronized (Object.class) {
                try {
                    join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    };
    t.start();
    try {
        Thread.sleep(100);
    } catch (Exception e) {
        e.printStackTrace();
    }
    System.out.println(t.getState());
}

5.5 超时等待状态（TIME_WAITTING）

该状态不同于等待状态，它可以在指定的时间后自行返回。

程序处于限时等待状态，调用wait()、join()、await()、lock()、sleep()等方法，都会使线程处于TIMED_WAITING状态，需要注意的是这些方法必须加入参数。

public static void main(String[] args) {
    Thread t = new Thread() {
        public void run() {
            synchronized (Object.class) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    };
    t.start();
    try {
        Thread.sleep(100);
    } catch (Exception e) {
        e.printStackTrace();
    }
    System.out.println(t.getState());
}

5.6 终止状态（TERMINATED）

表示当前线程已经执行完毕。

6 中断机制

6.1 说明

一个线程不应该由其他线程来强制中断或停止，而是应该由线程自己自行停止，所以Java使用中断机制用于停止线程。

每个线程对象中都有一个标识，用于标识线程是否被中断。该标识位为true表示中断，该标识为false表示未中断，通过调用线程对象的interrupt()方法将线程的标识位设为true。

如果线程处于正常活动状态，那么会将线程的中断标志设置位true，被设置中断标志的线程将继续正常运行，不受影响。

如果线程处于被阻塞状态（例如处于sleep、wait、join等状态），在别的线程中调用当前线程对象的interrupt()方法，那么当前线程立即被阻塞状态，并抛出一个InterruptedException异常。

6.2 使用中断停止线程

6.2.1 三种方式

在需要中断的线程中不断监听中断状态，一旦发生中断就执行中断处理业务逻辑。

三种识别中断的方式：

1）通过一个volatile变量实现。

2）通过AtomicBoolean实现。

3）通过Thread类自带方法实现。

6.2.2 通过一个volatile变量实现

public static volatile boolean isStop = false;
public static void main(String[] args) {
    new Thread(()->{
        while (true) {
            if (isStop) {
                System.out.println(Thread.currentThread().getName() + "结束");
                break;
            }
            System.out.println(Thread.currentThread().getName() + "运行");
        }
    }, "t1").start();
    try { Thread.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
    new Thread(()->{
        isStop = true;
    }, "t2").start();
}

6.2.3 通过AtomicBoolean实现

public static AtomicBoolean atomicBoolean = new AtomicBoolean(false);
public static void main(String[] args) {
    new Thread(()->{
        while (true) {
            if (atomicBoolean.get()) {
                System.out.println(Thread.currentThread().getName() + "结束");
                break;
            }
            System.out.println(Thread.currentThread().getName() + "运行");
        }
    }, "t1").start();
    try { Thread.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
    new Thread(()->{
        atomicBoolean.set(true);
    }, "t2").start();
}

6.2.4 通过Thread类自带方法实现

public static void main(String[] args) {
    Thread t1 = new Thread(()->{
        while (true) {
            if (Thread.currentThread().isInterrupted()) {
                System.out.println(Thread.currentThread().getName() + "结束");
                break;
            }
            System.out.println(Thread.currentThread().getName() + "运行");
        }
    }, "t1");
    t1.start();
    try { Thread.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
    new Thread(()->{
        t1.interrupt();
    }, "t2").start();
}