Java基础知识（15）- Java 多线程编程(四) | 线程控制、线程死锁

1. 线程控制

    1) 启动线程

        通过调用 Thread 类的 start 方法来启动一个线程，这时此线程是处于就绪状态，并没有运行。
        
        得到 CPU 时间片后，线程就开始自动执行 run 方法，run 方法被称为线程体，它包含了要执行的这个线程的内容，run方法运行结束，此线程随即终止。
    
        run 方法当作普通方法的方式调用。程序还是要顺序执行，要等待 run 方法体执行完毕后，才可继续执行下面的代码； 程序中只有主线程——这一个线程， 其程序执行路径还是只有一条， 这样就没有达到写线程的目的。

    2) 暂停、恢复和停止线程

        暂停(suspend)、恢复(resume)和停止(stop)，这些 API 是已过期的，不建议使用。
        
        不建议使用的原因：

            (1) 以 suspend 方法为例，在调用后，线程不会释放已经占有的资源（比如锁），而是占有着资源进入睡眠状态，这样容易引发死锁问题；
            (2) stop 方法在终结一个线程时不会保证线程的资源正常释放，通常是没有给予线程完成资源释放工作的机会，因此会导致程序可能工作在不确定状态下；
            (3) 因为 suspend、resume 和 stop 方法带来的副作用，这些方法才被标注为不建议使用的过期方法；

    3) 中断线程

        (1) 使用退出标志

            当 run 方法执行完后，线程就会退出。但有时 run 方法是永远不会结束的，如在服务端程序中使用线程进行监听客户端请求，或是其他的需要循环处理的任务。

            在这种情况下，一般是将这些任务放在一个循环中，如 while 循环。如果想使 while 循环在某一特定条件下退出，最直接的方法就是设一个 boolean 类型的标志，并通过设置这个标志为 true 或 false来控制 while 循环是否退出。

        (2) 使用 interrupt 方法

            interrupt 方法中断线程：设置线程的中断状态位为 true，线程不时地检测中断标示位，判断线程是否应该被中断 (中断标示值是否为 true)。

            interrupt 方法只是改变中断状态，不会中断一个正在运行的线程，需要用户自己去监视线程的状态为并做处理。

            这一方法实际完成的是，给受阻塞的线程发出一个中断信号，这样受阻线程检查到中断标识，就得以退出阻塞的状态。

            更确切的说，如果线程被Object.wait, Thread.join 和 Thread.sleep 三种方法之一阻塞，此时调用该线程的 interrupt() 方法，那么该线程将抛出一个 InterruptedException 中断异常（该线程必须事先预备好处理此异常），从而提早地终结被阻塞状态。如果线程没有被阻塞，这时调用 interrupt()将不起作用，直到执行到 wait()、 sleep() 或 join() 时，才会抛出 InterruptedException。

            a) 使用 interrupt() + InterruptedException 来中断线程：

                线程处于阻塞状态，如Thread.sleep、wait、IO阻塞等情况时，调用interrupt方法后，sleep等方法将会抛出一个InterruptedException。

            b) 使用 interrupt() + isInterrupted() 来中断线程：

                this.interrupted(): 测试当前线程是否已经中断（静态方法）。如果连续调用该方法，则第二次调用将返回false。在api文档中说明 interrupted()方法具有清除状态的功能。执行后具有将状态标识清除为false的功能。

　　            this.isInterrupted(): 测试线程是否已经中断，但是不能清除状态标识。

    4) join 线程

        join 方法是 Thread类 提供的让一个线程等待另一个线程完成的方法。格式：

            thread.start();
            thread.join();

    5) 后台线程

        后台线程（Daemon Thread）是在后台运行的，它的任务是为其他的线程提供服务，也被称为守护线程或精灵线程。后台线程的特征：如果所有的前台线程都死亡，后台线程会自动死亡。

        调用 Thread 对象的 setDaemon(true) 方法可以将一个指定的线程设置为后台线程。格式：

            thread.setDaemon(true);
            thread.start();

    6) 线程睡眠

        线程调用 sleep() 方法进入阻塞状态后，在其睡眠时间段内，该线程不会获得执行的机会，即使系统中没有其他可执行的线程，处于sleep()中的线程也不会执行，因此sleep()方法常用来暂停程序的执行。

        Thread 类为睡眠线程提供了两种方法：

            public static void sleep(long miliseconds)
            public static void sleep(long miliseconds，int nanos)

        参数声明：
            
            miliseconds - 以毫秒为单位的睡眠时间。
            nanos - 这是 0-999999 额外纳秒的睡眠时间。

 

    7) 线程让步

        线程让步 yield()方法作用是：暂停当前正在执行的线程对象，并执行其他线程。

        但是，实际中无法保证 yield() 达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。

    8) sleep() 和 yield()的区别：

        (1) sleep() 方法让线程进入阻塞状态，其他所有处于就绪状态的线程都有机会执行，yield() 方法会让线程重新回到就绪状态，但是只有优先级等于或者大于他的线程才会被执行；
        (2) 使用 sleep() 方法需要捕获异常，yield() 不需要；
        (3) sleep() 方法比 yield() 方法有更好的移植性，不建议使用yield();

    实例：

        public class App {
            public static volatile boolean stopFlag = false;

            public static void main( String[] args ) {

                // 使用退出标志中断线程
                testFlagExit();
                System.out.println("----------------------------------------");

                // 或使用 interrupt() + InterruptedException 中断线程
                testInterruptExit();
                System.out.println("----------------------------------------");

                // 使用 interrupt() + isInterrupted() 中断线程
                testIsInterruptedExit();
                System.out.println("----------------------------------------");

                // Thread join
                ThreadJoinRunnable threadJoin1 = new ThreadJoinRunnable("Thread Join 1");
                ThreadJoinRunnable threadJoin2 = new ThreadJoinRunnable("Thread Join 2");
                ThreadJoinRunnable threadJoin3 = new ThreadJoinRunnable("Thread Join 3");
                try {
                    threadJoin1.start();
                    threadJoin1.join();
                    threadJoin2.start();
                    threadJoin2.join();
                    threadJoin3.start();
                    threadJoin3.join();
                }  catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }

            // 使用退出标志中断线程
            public static void testFlagExit() {

                Thread t = new Thread(new Runnable() {
                    public void run() {
                        String name = Thread.currentThread().getName();
                        int i = 1;
                        try {

                            for (; i <= 10; i++) {
                                if (stopFlag) {
                                    break;
                                }
                                System.out.println(name + ": (" + i + ") stopFlag = " + stopFlag);
                                Thread.sleep(1000);
                            }
                        } catch (InterruptedException e) {
                            System.out.println(name + ": interrupted");
                        }
                        System.out.println(name + ": (" + i + ") stopFlag = " + stopFlag + ", exit");
                    }
                }, "Thread Flag"  );
                t.start();

                try {
                    Thread.sleep(5000);

                    System.out.println("main: stopping " + t.getName() + ", set stopFlag = true");
                    stopFlag = true;

                    Thread.sleep(1000);

                }  catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }

            // 或使用 interrupt() + InterruptedException 中断线程
            public static void testInterruptExit() {
                Thread t = new Thread(new Runnable() {
                    public void run() {
                        String name = Thread.currentThread().getName();
                        try {

                            for (int i = 1; i <= 10; i++) {
                                System.out.println(name + ": (" + i + ")");
                                Thread.sleep(1000);
                            }
                        } catch (InterruptedException e) {
                            System.out.println(name + ": interrupted");
                        }
                        System.out.println(name +": exit");
                    }
                }, "Thread Interrupt"  );
                t.start();

                try {
                    Thread.sleep(5000);

                    System.out.println("main: stopping " + t.getName() + ", call interrupt()");
                    t.interrupt();

                    Thread.sleep(1000);
                }  catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            // 使用 interrupt() + isInterrupted() 中断线程
            public static void testIsInterruptedExit() {
                Thread t = new Thread(new Runnable() {
                    public void run() {
                        String name = Thread.currentThread().getName();
                        Boolean b = Thread.currentThread().isInterrupted();
                        int i = 1;

                        while(!b) {
                            System.out.println(name + ": isInterrupted(" + i + ") = " + b);
                            b = Thread.currentThread().isInterrupted();
                            i++;
                        }

                        System.out.println(name +": isInterrupted(" + i + ") = " + b + ", exit");
                    }
                }, "Thread IsInterrupted"  );
                t.start();

                try {
                    Thread.sleep(1);

                    System.out.println("main: stopping " + t.getName() + ", call interrupt()");
                    t.interrupt();

                    Thread.sleep(1000);
                }  catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        class ThreadJoinRunnable extends Thread implements Runnable {

            ThreadJoinRunnable(String name) {
                this.setName(name);
            }

            public void run() {
                try {
                    System.out.println(getName());
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    System.out.println(getName() + ": interrupted");
                }
                System.out.println(getName() + ": exit");
            }
        }

    输出：

        Thread Flag: (1) stopFlag = false
        Thread Flag: (2) stopFlag = false
        Thread Flag: (3) stopFlag = false
        Thread Flag: (4) stopFlag = false
        Thread Flag: (5) stopFlag = false
        main: stopping Thread Flag, set stopFlag = true
        Thread Flag: (6) stopFlag = true, exit
        ----------------------------------------
        Thread Interrupt: (1)
        Thread Interrupt: (2)
        Thread Interrupt: (3)
        Thread Interrupt: (4)
        Thread Interrupt: (5)
        main: stopping Thread Interrupt, call interrupt()
        Thread Interrupt: interrupted
        Thread Interrupt: exit
        ----------------------------------------
        Thread IsInterrupted: isInterrupted(1) = false
        Thread IsInterrupted: isInterrupted(2) = false
        Thread IsInterrupted: isInterrupted(3) = false
        ...

        Thread IsInterrupted: isInterrupted(19) = false
        Thread IsInterrupted: isInterrupted(20) = false
        main: stopping Thread IsInterrupted, call interrupt()
        Thread IsInterrupted: isInterrupted(21) = false
        Thread IsInterrupted: isInterrupted(22) = true, exit
        ----------------------------------------
        Thread Join 1
        Thread Join 1: exit
        Thread Join 2
        Thread Join 2: exit
        Thread Join 3
        Thread Join 3: exit

2. 线程死锁

    线程死锁是指两个或两个以上的线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。

    下面我们通过一些实例来说明死锁现象。

    生活中的一个实例：两个人面对面过独木桥，甲和乙都已经在桥上走了一段距离，即占用了桥的资源，甲如果想通过独木桥的话，乙必须退出桥面让出桥的资源，让甲通过，但是乙不服，为什么让我先退出去，我还想先过去呢，于是就僵持不下，导致谁也过不了桥，这就是死锁。

    1) 死锁产生的原因

        (1) 系统资源的竞争

            通常系统中拥有的不可剥夺资源，其数量不足以满足多个进程运行的需要，使得进程在运行过程中，会因争夺资源而陷入僵局，如磁带机、打印机等。只有对不可剥夺资源的竞争才可能产生死锁，对可剥夺资源的竞争是不会引起死锁的。

        (2) 进程推进顺序非法

            进程在运行过程中，请求和释放资源的顺序不当，也同样会导致死锁。例如，并发进程 P1、P2分别保持了资源R1、R2，而进程P1申请资源R2，进程P2申请资源R1时，两者都会因为所需资源被占用而阻塞。   

    2）死锁发生时的条件：

        (1) 互斥条件：一个资源每次只能被一个进程使用。独木桥每次只能通过一个人。
        (2) 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。乙不退出桥面，甲也不退出桥面。
        (3) 不剥夺条件: 进程已获得的资源，在未使用完之前，不能强行剥夺。甲不能强制乙退出桥面，乙也不能强制甲退出桥面。
        (4) 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。如果乙不退出桥面，甲不能通过，甲不退出桥面，乙不能通过。

    3) 如何避免死锁

        在有些情况下死锁是可以避免的。下面介绍三种用于避免死锁的技术：

        (1) 加锁顺序（线程按照一定的顺序加锁）
        (2) 加锁时限（线程尝试获取锁的时候加上一定的时限，超过时限则放弃对该锁的请求，并释放自己占有的锁）
        (3) 死锁检测   

    Java 中死锁最简单的情况是，一个线程T1持有锁L1并且申请获得锁L2，而另一个线程T2持有锁L2并且申请获得锁L1，因为默认的锁申请操作都是阻塞的，所以线程T1和T2永远被阻塞，导致死锁。

    这是最容易理解也是最简单的死锁的形式。但是实际环境中的死锁往往比这个复杂的多。可能会有多个线程形成了一个死锁的环路，比如：线程T1持有锁L1并且申请获得锁L2，而线程T2持有锁L2并且申请获得锁L3，而线程T3持有锁L3并且申请获得锁L1，这样导致了一个锁依赖的环路：T1依赖T2的锁L2，T2依赖T3的锁L3，而T3依赖T1的锁L1，从而导致了死锁。

        
    实例：

        public class App {
            public static void main( String[] args ) {

                // 死锁的情况1
                Thread t1 = new Thread(new DeadLock(true), "Thread DeadLock 1");
                Thread t2 = new Thread(new DeadLock(false), "Thread DealLock 2");

                // 死锁的情况2
                //Thread t1 = new Thread(new DeadLock(false), "Thread DeadLock 1");
                //Thread t2 = new Thread(new DeadLock(true), "Thread DealLock 2");

                // 不死锁的情况1
                //Thread t1 = new Thread(new DeadLock(true), "Thread DeadLock 1");
                //Thread t2 = new Thread(new DeadLock(true), "Thread DealLock 2");

                // 不死锁的情况2
                //Thread t1 = new Thread(new DeadLock(false), "Thread DeadLock 1");
                //Thread t2 = new Thread(new DeadLock(false), "Thread DealLock 2");

                t1.start();
                t2.start();

            }
        }

        class DeadLock implements Runnable{

            private static Object obj1 = new Object();
            private static Object obj2 = new Object();
            private boolean flag;

            public DeadLock(boolean flag){
                this.flag = flag;
            }

            @Override
            public void run(){
                String name = Thread.currentThread().getName();
                System.out.println(name + "：running ...");

                /*
                 * 同时开启线程1和线程2：
                 * 1. 如果让线程1执行 "代码1"（flag==true），让线程2执行 "代码2" (flag==false), 会死锁;
                 * 2. 如果让线程1执行 "代码2"（flag==false），让线程2执行 "代码1" (flag==true), 会死锁;
                 * 3. 如果让线程1执行 "代码1"（flag==true），让线程2执行 "代码1" (flag==true), 不会死锁;
                 * 4. 如果让线程1执行 "代码2"（flag==false），让线程2执行 "代码2" (flag==false), 不会死锁;
                 */
                if (flag) {
                    // 代码1
                    synchronized(obj1){
                        System.out.println(name + ": lock obj1");
                        System.out.println(name + ": try to lock obj2 ...");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        synchronized(obj2){
                            // 死锁时执行不到这里
                            System.out.println(name +": after 1 second, lock obj2");
                        }
                    }
                } else {
                    // 代码2
                    synchronized(obj2){
                        System.out.println(name + ": lock obj2");
                        System.out.println(name + ": try to lock obj1 ...");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        synchronized(obj1){
                            // 死锁时执行不到这里
                            System.out.println(name +": after 1 second, lock obj1");
                        }
                    }
                }
            }
         }

    
    输出：
　　
        Thread DeadLock 1：running ...
        Thread DeadLock 1: lock obj1
        Thread DeadLock 1: try to lock obj2 ...
        Thread DealLock 2：running ...
        Thread DealLock 2: lock obj2
        Thread DealLock 2: try to lock obj1 ...
        // 此时程序死锁