一、如何终止线程

终止线程就是要让 run 方法尽快执行结束

1. 手动创建标志位

可以通过在代码中手动创建标志位的方式，来作为 run 方法的执行结束条件；

    public static void main(String[] args) throws InterruptedException {boolean flag = true;Thread t = new Thread(new Runnable() {@Overridepublic void run() {while (flag){System.out.println("线程执行中 ");}}});t.start();Thread.sleep(100);flag = false;}

如果将标志位定义在方法内部，这样编译器会报错，原因涉及到一个语法规则：匿名内部类的变量捕获， 匿名内部类可以使用方法中定义的变量，但这个变量必须是 final 的或者是 "事实" final 的；

所以要将标志位定义在类中，即属性，那这样又为什么不报错了呢？这又涉及到内部类 访问外部类的成员问题，内部类可以直接访问外部类的成员，不会受到变量捕获的影响；

public class Demo3 {private static boolean flag = true;public static void main(String[] args) throws InterruptedException {Thread t = new Thread(new Runnable() {@Overridepublic void run() {while (flag) {try {Thread.sleep(1);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println("线程执行中 ");}}});t.start();Thread.sleep(10);flag = false;}
}

可以看出上述方法确实终止了线程 t，但是如果，但如果线程 t 在 sleep 时，主线程再修改变量，那么 线程 t 就不能及时响应了；例如如下代码：

    public static void main(String[] args) throws InterruptedException {Thread t = new Thread(new Runnable() {@Overridepublic void run() {while (flag) {System.out.println("t线程执行中 " + System.currentTimeMillis());try {Thread.sleep(2000);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println("t线程执行结束 " + System.currentTimeMillis());}}});t.start();Thread.sleep(100);flag = false;System.out.println("主线程通知 t线程 执行结束" + System.currentTimeMillis());}

可以看出主线程修改了标志位之后，在休眠状态下的 t 线程没有立即结束； 

2. 使用 Thread 类提供的方法

使用 Thread.currentThread().isInterrupted() 方法作为内部标志位，使用 t.interrupt() 方法终止线程；

    public static void main(String[] args) throws InterruptedException {Thread t = new Thread(new Runnable() {@Overridepublic void run() {while (!Thread.currentThread().isInterrupted()) {System.out.println("t线程正在执行 ");}}});t.start();Thread.sleep(1);t.interrupt();}

 上述代码中，t 线程执行了 1 ms之后自动结束了；

那如果主线程调用 t.interrupt() 方法的时候 t 线程正在 sleep 呢？看看下面这个例子：

    public static void main(String[] args) throws InterruptedException {Thread t = new Thread(new Runnable() {@Overridepublic void run() {while (!Thread.currentThread().isInterrupted()) {System.out.println("t线程正在执行 ");try {Thread.sleep(2000);} catch (InterruptedException e) {throw new RuntimeException(e);}}}});t.start();Thread.sleep(100);t.interrupt();}

 可以看到，t 线程直接抛出了一个 InterruptedException，同时对应到 使用 sleep 方法必须进行手动的处理异常，防止了在 sleep 的时候，调用 interrupt 方法而没有及时感知；

二、线程等待

线程等待就是让一个线程等待另一个线程执行结束，再继续执行；实现线程等待的方式有 join 和wait，sleep也算一种吧；

1. join

join 在哪个线程内调用，哪个线程就阻塞等待，默认死等待，不释放锁资源，也可以设置一个最长的等待时间；通过影响线程结束的先后顺序实现线程等待，join 是 Thread 类提供的方法，；

    public static void main(String[] args) throws InterruptedException {Thread t = new Thread(new Runnable() {@Overridepublic void run() {for (int i = 0; i < 5; i++) {System.out.println("线程执行中 i = " + i);}}});t.start();System.out.println("开始等待");t.join();System.out.println("等待结束");}

但如果 t 线程要执行很久，也可以通过设置最长等待时间再继续执行主线程；例如，通过 t.join(1000); 设置最多等待 1 秒，但当这个时间到了，t 线程不一定执行完了，而是主线程该执行了；

2. wait

wait 让指定的线程进入阻塞状态，wait 方法也可以指定超时时间，与 wait 相对应的方法是 notify，notify用来唤醒处在 wait 等待中的线程；wait 与 notify 是 Object 类的方法，在使用时都必须放在 synchronized 块中；wait 方法执行要做的事：1）释放锁资源；2）让线程进入阻塞状态；3）当线程被重新唤醒时，重新获取到锁；

wait 结束等待的条件：1）其他线程调用该锁对象的 notify 方法（前提是，使用 synchronized加上锁）；2）wait 等待时间超时(如果 wait 方法指定了超时时间)；3）其他线程调用该等待线程的 interrupted方法，导致 wait 抛出InterruptedException 异常

public static void main(String[] args) throws InterruptedException {Object object = new Object();Thread t = new Thread(new Runnable() {@Overridepublic void run() {synchronized (object) {for (int i = 0; i < 5; i++) {System.out.println("线程执行中 i = " + i);}object.notify();}}});t.start();System.out.println("开始等待");synchronized (object) {object.wait();}System.out.println("等待结束");}

使用 wait / notify 不会出现 "线程饿死" 问题；

线程饿死：一个线程释放锁的时候，又去竞争锁，由于该线程已经在 cpu 上执行，故没有调度的过程，进而更容易拿到锁，反复进行此操作，后续线程就无法拿到锁，就会出现 "线程饿死" 问题；使用 wait 时，该线程会释放锁，并进入阻塞，不会参与后续的锁竞争；

三、线程安全 

public class Demo4 {public static int count = 0;public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(() -> {for (int i = 0; i < 10000; i++) {count++;}});Thread t2 = new Thread(() -> {for (int i = 0; i < 10000; i++) {count++;}});t1.start();t2.start();t1.join();t2.join();System.out.println(count);}
}

针对上述代码，执行多次的结果是不一样的，这就是线程安全问题； 

产生线程安全问题的原因：

1. 操作系统中，线程的调度方式是随机的（抢占式执行）；

此种情况是操作系统内核决定的，是无法避免的；

2. 两个或多个线程对同一个变量进行修改，并且修改操作不是原子的；

为了避免线程不安全问题，可以尽量减少多个线程对同一个变量的修改，但是有时候就是需要对同一个变量修改，这时候就需要保证修改操作是原子的，那就要使用到 synchronized 来加锁了；

synchronized 在使用时，要搭配一个代码块和一个对象，进入代码块中就会加锁，出了代码块就会解锁，在已经加锁的状态下，另一个线程尝试对该代码块中同一个对象加锁，就会产生 "锁竞争/ 锁冲突"，后一个线程就会阻塞等待，直到前一个线程释放锁为止；

现使用 synchronized 对上述代码进行修改，由于是 count++ 操作是非原子的，故要对 count++ 操作进行加锁；（也可以使用 Integer 的原子类 AtomicInteger 实现原子操作）

public class Demo4 {public static int count = 0;public static final Object o = new Object();public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(() -> {for (int i = 0; i < 10000; i++) {synchronized (o) {count++;}}});Thread t2 = new Thread(() -> {for (int i = 0; i < 10000; i++) {synchronized (o) {count++;}}});t1.start();t2.start();t1.join();t2.join();System.out.println(count);}
}

上述代码中是针对同一个对象 o 进行加锁，若是针对不同的对象加锁，则不会有锁竞争，仍然是并发；

当 synchronized 修饰成员方法时，相当于对 this 对象进行加锁，当 synchronized 修饰类方法时，相当于对 类对象 进行加锁；

可重入锁的概念：指一个线程连续针对一把锁加锁两次不会出现死锁，满足该要求就是可重入锁；

死锁问题：

1）一个线程针对同一把锁，连续加锁两次如果是不可重入锁，就会产生死锁；

第一次加锁会成功，第二次加锁就需要等待第一次加的锁释放，但此时第二次加锁的操作在第一次锁的代码块中，第一次加锁要释放，就又得第二次加锁成功，这样就产生了死锁；但如果能让锁记录是哪个线程对它加的锁，并记录加了几层，这样后续再加锁的时候，判断加锁线程是否为持有锁的线程，如果是，则直接加锁成功，此时就可以避免死锁；

    public static void main(String[] args) {synchronized (o1){synchronized (o2){System.out.println("加锁成功");}}}

 

由于 synchronized 是 可重入锁，故此时不会产生死锁； 

2）两个线程两把锁，例如有 t1，t2 线程，o1，o2 对象，t1 已经对 o1 加锁，t2 已经对 o2 加锁，此时 t1 又尝试对 o2 加锁，t2 尝试对 o1 加锁；（此时一定会产生死锁）；

    public static void main(String[] args) {Thread t1 = new Thread(() -> {synchronized (o1){System.out.println("t1 对 o1 加锁成功");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}synchronized (o2){System.out.println("t1 对 o2 加锁成功");}}});Thread t2 = new Thread(() -> {synchronized (o2){System.out.println("t2 对 o2 加锁成功");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}synchronized (o1){System.out.println("t2 对 o1 加锁成功");}}});t1.start();t2.start();}

可以看到并没有打印 "t1 对 o2 加锁成功" 和 "t2 对 o1 加锁成功"，此时已经产生死锁了；

3）多个线程，对应多把锁，更容易产生死锁；

3. 内存可见性问题 

public class Demo5 {public static int flag = 0;public static void main(String[] args) {Thread t1 = new Thread(() -> {while (flag == 0){}System.out.println("t1 线程执行结束");});Thread t2 = new Thread(() -> {System.out.println("请输入 flag: ");Scanner in = new Scanner(System.in);flag = in.nextInt();});t1.start();t2.start();}
}

可以看到在上述代码中， 当 flag 为 0 时，t1 线程会循环执行；t2 线程可以让用户输入一个数来改变 flag 的值，按理来说用户输入非 0，t1 线程应该会终止循环，并打印 "t1 线程执行结束"，然后 t1 线程结束，但运行结果并非这样，这就是内存可见性引起的问题；

t1 线程判断循环的条件 while(flag == 0) 具体操作为：1）load 读取内存中 flag 的值到 cpu 寄存器中；2）使用寄存器中的值和 0 进行比较；

由于这个循环体内没有任何操作（编译器可以检测到），所以这个循环的执行速度是非常快的，所以 编译器为了提高效率，会将读内存优化为读寄存器：编译器只在第一次循环时，才读了内存，并将读到的结果放入寄存器中，后续会直接从寄存器中取值，这样后续 t2 线程修改了 flag 的值（内存中的值），t1 线程并没有感知到，这时 t1 线程自然就不会退出循环了，因为它还用的是寄存器中的值，这时候就要 使用到 volatile 关键字，告诉编译器不要优化，此时会强制读取内存；

public static volatile int flag = 0;

在 flag 定义时使用 volatile 关键字，再次执行程序：

 注意 volatile 只保证内存可见性，不保证原子性，如果两个线程同时对 同一个带有 volatile 修饰的变量进行修改，此时仍会产生线程安全问题；

4. 指令重排序问题

指令重排序也是编译器优化的一种方式：调整原有代码的执行顺序，保证逻辑不变的前提下，提高程序的效率；点这里查看指令重排序的线程安全问题