一、如何终止线程

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

1. 手动创建标志位

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

    public static void main(String[] args) throws InterruptedException {
        boolean flag = true;
        Thread t = new Thread(new Runnable() {
            @Override
            public 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() {
            @Override
            public 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() {
            @Override
            public 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() {
            @Override
            public 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() {
            @Override
            public 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() {
            @Override
            public 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 与 notify

wait 让指定的线程进入阻塞状态，wait 方法也可以指定超时时间，其他线程调用该等待线程的 interrupted 方法时，会导致 wait 抛出 InterruptedException 异常

wait 方法执行要做的事：1）释放锁资源；2）让线程进入阻塞状态；3）当线程被重新唤醒时，重新获取到锁；

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

notify 用来唤醒处在 wait 等待中的线程，并使它们重新获取该对象的对象锁；

如果有多个线程等待，则由线程调度器随机挑选出⼀个 wait 状态的线程。(并不会 "先来后到")；在在执行 notify() 方法之后，当前线程不会立刻就释放该对象的锁，而要等到执行 notify() 方法的线程将当前 synchronized 代码块执行完，才会释放对象锁；   

notifyAll() 方法用来唤醒所有处在 wait 状态的线程，不是立刻就全部唤醒，而是一个接一个唤醒；

wait，notify，notifyAll 都是 Object 类的方法，在使用时都必须放在 synchronized 块中；

public static void main(String[] args) throws InterruptedException {
        Object object = new Object();
        Thread t = new Thread(new Runnable() {
            @Override
            public 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. 指令重排序问题

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