java线程中断和死锁详解

古城微笑少年丶 2023-01-04 13:10 149阅读 0赞

### 1、线程中断： ###

java中的线程中断是一种线程间的协作模式，通过设置线程的中断标志并不能直接终止该线程的执行，而是被终端的线程根据中断状态自行处理。

*  void interrupt()方法：中断线程，例如，当线程A运行时，线程B可以调用线程A的interrupt()方法来设置线程A的中断标志为true并立即返回。设置标志仅仅是设置标志，线程A实际并没有被中断，它会继续执行下去。如果线程A因为调用了wait系列函数、join方法或者sleep方法而被阻塞挂起，这时候若线程B调用线程A的interrupt()方法，线程A会在调用这些方法的地方抛出InterruptedException异常而返回。
 *  boolean isInterrupted()方法：检测当前线程石佛iu被中断，如果是返回true，否则返回false。
 *      public boolean isInterrupted() {
            // 传递false，说明不清除中断标志
            return isInterrupted(false);
        }
 *  boolean interrupted()方法：检测当前线程是否被中断，如果是返回true，否则返回false。与isInterrupted不同的是，该方法如果发现当前线程被中断，则会清除中断标志，并且该方法是static方法，可以通过Thread类直接调用。如果本次调用了清除操作，则返回true，否则返回false。举个例子：如果stopFlag为true，调用interrupted()，则stopFlag将被设置为false，同时函数返回true.如果stopFlag为false，调用interrupted()，则直接返回false.
 *      public static boolean interrupted() {
            // 清除中断标志
            return currentThread().isInterrupted(true);
        }
 *  从上面的代码可以看出，在interrupted()内部是获取当前调用线程的中断标志而不是调用interrupted()方法的实例对象的中断标志。

### 1.1、根据中断标志判断线程是否终止 ###

public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                // 如果当前线程被中断则退出循环
                while (!Thread.currentThread().isInterrupted())
                    System.out.println(Thread.currentThread() + "hello");
            }
        });
        
        // 启动子线程
        thread.start();
        // 主线程休眠1s，以便中断前让子线程输出
        Thread.sleep(1000);
        // 中断子线程
        System.out.println("main thread interrupt thread");
        thread.interrupt();
        // 等待子线程执行完毕
        thread.join();
        System.out.println("main is over");
    }

### 1.2、提前返回 ###

当线程为了等待一些特定条件的到来时，一般会调用sleep函数、wait系列函数或者join()函数来阻塞挂起当前线程。比如一个线程调用了Thread.sleep(3000)，那么调用线程会被阻塞，直到3s后才从阻塞状态变为激活状态。但是有可能在3s内条件已经满足，这是就不用等到三秒后在返回。可以调用该线程的interrupt()方法，强制sleep()方法抛出InterruptedException异常而返回，线程恢复到激活状态。

public static void main(String[] args) throws InterruptedException {
        Threead threadOne = new Thread(new Runnable() {
            public void run() {
                try {
                    System.out.println("threadOne begin sleep for 2000 seconds");
                    Thread.sleep(2000000);
                    System.out.println("threadOne awaking");
                }catch (InterruptedException e) {
                    System.out.println("threadOne is interrupted while sleeping");
                    return;
                }
                System.out.println("threadOne-leaving normally");
            }
        });
        // 启动线程
        threadOne.start();
        // 确保子线程进入休眠状态
        Thread.sleep(1000);
        // 打断子线程的休眠，让子线程从sleep函数返回
        threadOne.interrupt();
        // 等待子线程执行完毕
        threadOne.join();
        System.out.println("main thread is over");
    }

**执行程序：**

threadOne begin sleep for 2000 seconds
    threadOne is interrupted while sleeping
    main thread is over
    
    Process finished with exit code 0

### 1.3、interrupted()与isInterrupted()方法的区别： ###

public class InterruptedTest3 {
        public static void main(String[] args) throws   InterruptedException {
             Thread threadOne = new Thread(new Runnable() {
                 @Override
                 public void run() {
                     // 注意程序不会自行结束
                     for (;;) {
    
                     }
                 }
             });
    
             // 启动线程
            threadOne.start();
            System.out.println("执行前:" + threadOne.isInterrupted());
            // 设置中断标志
            threadOne.interrupt();
    
            // 获取中断标志
            System.out.println("isInterrupted:" + threadOne.isInterrupted());
            // 获取中断标志并重置
            // interrupted(): 类方法，在当前线程重置中断状态，由true---》false，执行多次效果一样
            // interrupted()内部是获取当前调用线程的中断标志而不是调用interrupted()方法的实例对象的中断标志
            System.out.println("isInterrupted:" + Thread.interrupted());
    
            // 获取中断标志并重置
            System.out.println("isInterrupted:" + Thread.interrupted());
    
            // 获取中断标志
            System.out.println("isInterrupted:" + threadOne.isInterrupted());
    
            threadOne.join();
            System.out.println("main thread is over");
        }
    }

**执行程序：**

执行前:false
    isInterrupted:true
    isInterrupted:false
    isInterrupted:true

### 2、线程上下文切换 ###

在多线程编程中，线程个数一般大于CPU个数，而每个CPU同一时刻只能被一个线程使用，为了让用户感觉多个线程是同时执行的，CPU资源的分配采用了时间片轮转的策略，也就是每个线程分配一个时间片，线程在时间片内占用CPU执行任务。当前线程使用完时间片后，就会处于就绪状态并让出CPU让其他线程占用，这就是上下文切换，从当前线程的上下文切换到了其他线程。

线程在切换线程上下文时需要保存当前线程的执行现场，当再次执行时根据保存的执行现场信息恢复执行现场。

线程上下文切换的时机有：当前线程的CPU时间片使用完处于就绪状态时，当前线程被其他线程中断时。

### 3、线程死锁 ###

### 3.1、死锁的概念 ###

死锁时指两个或两个以上的线程在执行过程中，因争夺资源而造成的互相等待的现象，在无外力作用的情况下，这些线程会一直相互等待而无法继续运行下去。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpX3dfY2g_size_16_color_FFFFFF_t_70][]

在上图中，线程A已经持有了资源2，它同时还想申请资源1，线程B已经持有了资源1，它同时还想申请资源2，所以线程1和线程2就因为相互等待对方已经持有的资源，而进入了死锁状态。

### 3.2、死锁产生的四个必要条件 ###

*  互斥使用：即当资源被一个线程使用（占有）时，别的线程不能使用
 *  不可抢占：资源请求者不能强制从资源占有者手中强度资源，资源只能由资源占有者主动释放
 *  请求和保持：即当资源请求者在请求其他的资源的同时保持对原有资源的占有
 *  循环等待：即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。这样就形成了一个等待环路

public class DeadLockTest {
        // 创建资源
        private static Object resourceA =  new Object();
        private static Object resourceB = new Object();
    
        public static void main(String[] args) {
            // 创建线程A
            Thread threadA = new Thread(new Runnable() {
                @Override
                public void run() {
                    // 获取到resourceA的监视器锁
                    synchronized (resourceA) {
                        System.out.println(Thread.currentThread() + "get ResourceA");
    
                        try {
                            Thread.sleep(1000);
                        }catch (InterruptedException e) {
                            e.printStackTrace();
                        }
    
                        System.out.println(Thread.currentThread() + "waiting get sourceB");
                        synchronized (resourceB) {
                            System.out.println(Thread.currentThread() + "get resourceB");
                        }
                    }
                }
            });
    
            // 创建线程B
            Thread threadB = new Thread(new Runnable() {
                @Override
                public void run() {
                    synchronized (resourceB) {
                        System.out.println(Thread.currentThread() + "get resourceB");
    
                        try {
                            Thread.sleep(1000);
                        }catch (InterruptedException e) {
                            e.printStackTrace();
                        }
    
                        System.out.println(Thread.currentThread() + "waiting get resourceA");
                        synchronized (resourceA) {
                            System.out.println(Thread.currentThread() + "get resourceA");
                        }
                    }
                }
            });
    
            // 启动线程
            threadA.start();
            threadB.start();
        }
    }

**执行程序：**

Thread[Thread-1,5,main]get resourceB
    Thread[Thread-0,5,main]get ResourceA
    Thread[Thread-1,5,main]waiting get resourceA
    Thread[Thread-0,5,main]waiting get sourceB
    
    Process finished with exit code -1

### 3.3、避免线程死锁 ###

死锁的情况下打破任何一个必要条件，便可让死锁消失。一般只有请求持有和环路等待条件是可以被破坏的。

一般有两种方法：一是用synchronized，一种是用Lock显示锁实现。

public class DeadLockTest {
        // 创建资源
        private static Object resourceA =  new Object();
        private static Object resourceB = new Object();
    
        public static void main(String[] args) {
            // 创建线程A
            Thread threadA = new Thread(new Runnable() {
                @Override
                public void run() {
                    // 获取到resourceA的监视器锁
                    synchronized (resourceA) {
                        System.out.println(Thread.currentThread() + "get ResourceA");
    
                        try {
                            Thread.sleep(1000);
                        }catch (InterruptedException e) {
                            e.printStackTrace();
                        }
    
                        System.out.println(Thread.currentThread() + "waiting get sourceB");
                        synchronized (resourceB) {
                            System.out.println(Thread.currentThread() + "get resourceB");
                        }
                    }
                }
            });
    
            // 创建线程B
            Thread threadB = new Thread(new Runnable() {
                @Override
                public void run() {
                    // 申请资源的有序性
                    synchronized (resourceA) {
                        System.out.println(Thread.currentThread() + "get resourceB");
    
                        try {
                            Thread.sleep(1000);
                        }catch (InterruptedException e) {
                            e.printStackTrace();
                        }
    
                        System.out.println(Thread.currentThread() + "waiting get resourceA");
                        synchronized (resourceB) {
                            System.out.println(Thread.currentThread() + "get resourceA");
                        }
                    }
                }
            });
    
            // 启动线程
            threadA.start();
            threadB.start();
        }
    }

### 4、守护线程和用户线程 ###

java中的线程分为两类，分别为daemon线程(守护线程）和user线程(用户线程)。区别之一是当最后一个非守护线程结束时，JVM会正常退出，而不管当前是否有守护线程，也就是说守护线程是否结束并不影响JVM的退出。只要还有一个用户线程还没结束，正情况下JVM就不会退出。

### 4.1、创建守护线程 ###

public static void main(Stirng[] args) {
        Thread daemonThread = new Thread(new Runnable() {
            public void run() {
    
            }
        });
        // 设置为守护线程
        daemonThread.setDaemon(true);
        daemonThread.start();
    }

**总结：**

如果希望在主线程结束后JVM进程马上结束，那么在创建线程时可以将其设置为守护线程，如果你希望在主线程结束后子线程继续工作，等子线程结束后再让JVM进程结束，那么就将子线程设置为用户线程。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpX3dfY2g_size_16_color_FFFFFF_t_70]: /images/20221119/07833c1358404d268833a69c06d94542.png