interrupt()方法

最新推荐文章于 2023-04-23 21:36:11 发布

BryantLmm

最新推荐文章于 2023-04-23 21:36:11 发布

阅读量1.3w

点赞数 9

分类专栏：多线程系列

本文链接：https://blog.csdn.net/BryantLmm/article/details/83792864

版权

多线程系列专栏收录该内容

21 篇文章 0 订阅

订阅专栏

title：线程中断

date：2017年11月4日23:02:38

今天来看看线程中断的问题。

当一个线程运行时，另一个线程可以调用对应的Thread对象的interrupt（）方法来中断它，该方法只是在目标线程中设置一个标志，表示它已经被中断，并立即返回。中断的结果线程是死亡、还是等待新的任务或是继续运行至下一步，就取决于这个程序本身。线程会不时地检测这个中断标示位，以判断线程是否应该被中断（中断标示值是否为true）。它并不像stop方法那样会中断一个正在运行的线程。

一.如何判断线程是否被中断

在Thread类的API中有三个和线程中断关系密切的方法，上面的interrupt()方法当然就是其中一个，还有两个则是用来判断线程是否中断。他们分别是

isInterrupted

先看JDK API 文档的简单介绍。

public boolean isInterrupted()
测试线程是否已经中断。线程的中断状态 不受该方法的影响。 
线程中断被忽略，因为在中断时不处于活动状态的线程将由此返回 false 的方法反映出来。 
返回：
如果该线程已经中断，则返回 true；否则返回 false。

interrupted
```
public static boolean interrupted()
```
测试当前线程是否已经中断。线程的中断状态由该方法清除。换句话说，如果连续两次调用该方法，则第二次调用将返回 false（在第一次调用已清除了其中断状态之后，且第二次调用检验完中断状态前，当前线程再次中断的情况除外）。
线程中断被忽略，因为在中断时不处于活动状态的线程将由此返回 false 的方法反映出来。

返回：
如果当前线程已经中断，则返回 true；否则返回 false。

这里我们要注意，这是Thread的static方法，我们看看Thread的源码
```
    public static boolean interrupted() {
        return currentThread().isInterrupted(true);
    }
    private native boolean isInterrupted(boolean ClearInterrupted);
 public boolean isInterrupted() {
        return isInterrupted(false);
    }
```
我们注意到interrupted()和isInterrupted()都是调用了本地方法isInterrupted(boolean ClearInterrupted);但是刚好他们的参数是相反的，这也就是API文档里说的，对于isInterrupted()线程的中断状态不受该方法的影响。而对于interrupted()线程的中断状态由该方法清除。

我们来写个测试程序来看看。
```
package com.wangcc.thread.interrupt;

public class InterruptReset {
	public static void main(String[] args) {
		System.out.println("Point X: Thread.interrupted()=" + Thread.interrupted());
		Thread.currentThread().interrupt();
		System.out.println("Point Y: Thread.interrupted()=" + Thread.interrupted());
		System.out.println("Point Z: Thread.interrupted()=" + Thread.interrupted());
		System.out.println("Point T: Thread.interrupted()=" + Thread.interrupted());

	}
}
```
我们查看结果：
```
Point X: Thread.interrupted()=false
Point Y: Thread.interrupted()=true
Point Z: Thread.interrupted()=false
Point T: Thread.interrupted()=false
```
如果线程被中断，而且中断状态尚不清楚，那么，这个方法返回true。与isInterrupted（）不同，它将自动重置中断状态为false，第二次调用Thread.interrupted（）方法，总是返回false，除非中断了线程。不过目前为止，对于为什么这么设计还没有一丝头绪。

通过上述说明，我们先得出一个简单结论：

判断某个线程是否已被发送过中断请求，请使用Thread.currentThread().isInterrupted()方法（因为它将线程中断标示位设置为true后，不会立刻清除中断标示位，即不会将中断标设置为false），而不要使用thread.interrupted()（该方法调用后会将中断标示位清除，即重新设置为false）方法来判断，下面是线程在循环中时的中断方式：

while(!Thread.currentThread().isInterrupted() && more work to do){
    do more work
}

二.如何中断线程

如果一个线程处于了阻塞状态（如线程调用了thread.sleep、thread.join、thread.wait、1.5中的condition.await、以及可中断的通道上的 I/O 操作方法后可进入阻塞状态），则在线程在检查中断标示时如果发现中断标示为true，则会在这些阻塞方法（sleep、join、wait、1.5中的condition.await及可中断的通道上的 I/O 操作方法）调用处抛出InterruptedException异常，并且在抛出异常后立即将线程的中断标示位清除，即重新设置为false。抛出异常是为了线程从阻塞状态醒过来，并在结束线程前让程序员有足够的时间来处理中断请求。

注，synchronized在获锁的过程中是不能被中断的，意思是说如果产生了死锁，则不可能被中断（请参考后面的测试例子）。与synchronized功能相似的reentrantLock.lock()方法也是一样，它也不可中断的，即如果发生死锁，那么reentrantLock.lock()方法无法终止，如果调用时被阻塞，则它一直阻塞到它获取到锁为止。但是如果调用带超时的tryLock方法reentrantLock.tryLock(long timeout, TimeUnit unit)，那么如果线程在等待时被中断，将抛出一个InterruptedException异常，这是一个非常有用的特性，因为它允许程序打破死锁。你也可以调用reentrantLock.lockInterruptibly()方法，它就相当于一个超时设为无限的tryLock方法。

没有任何语言方面的需求一个被中断的线程应该终止。中断一个线程只是为了引起该线程的注意，被中断线程可以决定如何应对中断。某些线程非常重要，以至于它们应该不理会中断，而是在处理完抛出的异常之后继续执行，但是更普遍的情况是，一个线程将把中断看作一个终止请求。

所以我们线程的run方法一般要求下面这么写

public void run() {
    try {
        ...
        /*
         * 不管循环里是否调用过线程阻塞的方法如sleep、join、wait，这里还是需要加上
         * !Thread.currentThread().isInterrupted()条件，虽然抛出异常后退出了循环，显
         * 得用阻塞的情况下是多余的，但如果调用了阻塞方法但没有阻塞时，这样会更安全、更及时。
         */
        while (!Thread.currentThread().isInterrupted()&& more work to do) {
            do more work 
        }
    } catch (InterruptedException e) {
        //线程在wait或sleep期间被中断了
    } finally {
        //线程结束前做一些清理工作
    }
}

上面是while循环在try块里，如果try在while循环里时，因该在catch块里重新设置一下中断标示，因为抛出InterruptedException异常后，中断标示位会自动清除，此时应该这样：

public void run() {
    while (!Thread.currentThread().isInterrupted()&& more work to do) {
        try {
            ...
            sleep(delay);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();//重新设置中断标示
        }
    }
}

注意之所以run方法进入时都要使用!Thread.currentThread().isInterrupted()轮询是把interrupt方法当做一个终止这个线程的请求，也就是相当于一个flag标志位。一定要理解这一点。

使用中断信号量中断非阻塞状态的线程

     /**

   - @ClassName: InterruptTest
   - @Description: 中断信号量中断线程
   - @author wangcc
   - @date 2017年11月11日 下午1:44:20
   - */
       public class InterruptTest extends Thread {
     	private volatile boolean stop = false;

   public static void main(String[] args) throws InterruptedException {
   	InterruptTest test = new InterruptTest();
   	System.out.println("Starting thread...");

   	test.start();
   	Thread.sleep(3000);
   	System.out.println("Asking thread to stop...");
   	test.stop = true;
   	Thread.sleep(3000);
   	System.out.println("Stopping application...");

   }

   public void run() {
   	while (!stop) {
   		System.out.println("Thread is running");
   		long begin = System.currentTimeMillis();
   		/**
   		 * 使用while循环模拟sleep方法，这里不要使用sleep，否则在阻塞时会抛InterruptedException异常而退出循环，
   		 * 这样while检测stop条件就不会执行，失去了意义。
   		 */
   		while (System.currentTimeMillis() - begin > 1000) {

   		}
   	}
   }
   }

注意，我们这里的stop标志位使用了volatile关键字来修饰，为什么这么修饰，我们会在后面说到这个关键字的时候详细介绍。

使用thread.interrupt()中断非阻塞状态线程

package com.wangcc.MyJavaSE.thread.interrupt;

public class InterruptTest1 extends Thread {

	public static void main(String[] args) throws InterruptedException {
		// TODO Auto-generated method stub
		InterruptTest1 test = new InterruptTest1();
		System.out.println("Starting thread...");

		test.start();
		Thread.sleep(3000);
		System.out.println("Asking thread to stop...");
		test.interrupt();
		Thread.sleep(3000);
		System.out.println("Stopping application...");
	}

	public void run() {
		while (!Thread.currentThread().isInterrupted()) {
			System.out.println("Thread is running");
			long begin = System.currentTimeMillis();
			/**
			 * 使用while循环模拟sleep方法，这里不要使用sleep，否则在阻塞时会抛InterruptedException异常而退出循环，
			 * 这样while检测stop条件就不会执行，失去了意义。
			 */
			// try {
			// Thread.sleep(1000);
			// } catch (InterruptedException e) {
			// // TODO Auto-generated catch block
			// e.printStackTrace();
			// }
			while (System.currentTimeMillis() - begin > 1000) {

			}
		}
	}
}

三.总结

一、没有任何语言方面的需求一个被中断的线程应该终止。中断一个线程只是为了引起该线程的注意，被中断线程可以决定如何应对中断。

二、对于处于sleep，join等操作的线程，如果被调用interrupt()后，会抛出InterruptedException，然后线程的中断标志位会由true重置为false，因为线程为了处理异常已经重新处于就绪状态。

三、不可中断的操作，包括进入synchronized段以及Lock.lock()，inputSteam.read()等，调用interrupt()对于这几个问题无效，因为它们都不抛出中断异常。如果拿不到资源，它们会无限期阻塞下去。

对于Lock.lock()，可以改用Lock.lockInterruptibly()，可被中断的加锁操作，它可以抛出中断异常。等同于等待时间无限长的Lock.tryLock(long time, TimeUnit unit)。

对于inputStream等资源，有些(实现了interruptibleChannel接口)可以通过close()方法将资源关闭，对应的阻塞也会被放开。

其实，Java的中断是一种协作机制。也就是说调用线程对象的interrupt方法并不一定就中断了正在运行的线程，它只是要求线程自己在合适的时机中断自己。每个线程都有一个boolean的中断状态（这个状态不在Thread的属性上），interrupt方法仅仅只是将该状态置为true。

比如对正常运行的线程调用interrupt()并不能终止他，只是改变了interrupt标示符。

一般说来，如果一个方法声明抛出InterruptedException，表示该方法是可中断的,比如wait,sleep,join，也就是说可中断方法会对interrupt调用做出响应（例如sleep响应interrupt的操作包括清除中断状态，抛出InterruptedException）,异常都是由可中断方法自己抛出来的，并不是直接由interrupt方法直接引起的。

Object.wait, Thread.sleep方法，会不断的轮询监听 interrupted 标志位，发现其设置为true后，会停止阻塞并抛出 InterruptedException异常。

四.interrupt()方法的使用

在阅读线程池源码的时候，我们发现关闭线程池的时候就是使用的interrupt()方法，我们来看一下线程池关闭这块的源码。

我们看到很多文章都说，我们在关闭线程池的时候不要直接调用shutdownNow()方法，而是需要先调用shutdown()方法接着调用awaitTermination(long timeout, TimeUnit unit)方法，那到底为什么这样说呢，我们通过源码来分析一下。

shutdownNow()

    public List<Runnable> shutdownNow() {
        List<Runnable> tasks;
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            checkShutdownAccess();
            //原子性的修改线程池的状态为STOP
            advanceRunState(STOP);
            //遍历线程里的所有工作限次，然后调用线程的interrupt方法。
            interruptWorkers();
            //将队列中还没有执行的任务放到列表中，返回给调用方
            tasks = drainQueue();
        } finally {
            mainLock.unlock();
        }
        /*
        
        在以下情况将线程池变为TERMINATED终止状态
 * shutdown 且 正在运行的worker 和 workQueue队列 都empty
 * stop 且  没有正在运行的worker
 * 
 * 这个方法必须在任何可能导致线程池终止的情况下被调用，如：
 * 减少worker数量
 * shutdown时从queue中移除任务
 * 
 * 这个方法不是私有的，所以允许子类ScheduledThreadPoolExecutor调用
        */
        tryTerminate();
        return tasks;
    }

shutdownNow()方法的执行逻辑就是讲线程池状态修改为STOP,然后调用线程里的所有线程的interrupt()方法。

    private void interruptWorkers() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            for (Worker w : workers)
                w.interruptIfStarted();
        } finally {
            mainLock.unlock();
        }
    }

前面已经说过了，调用线程的interrupt()方法并不意味着被中断的线程应该终止，该线程到底会怎样处理，还需要看线程是如何应对中断的。

Worker线程的run()方法实际上调用的是runWorker(Worker w)方法。

 final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            
            while (task != null || (task = getTask()) != null) {
                w.lock();
                // If pool is stopping, ensure thread is interrupted;
                // if not, ensure thread is not interrupted.  This
                // requires a recheck in second case to deal with
                // shutdownNow race while clearing interrupt
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                        task.run();
                    } catch (RuntimeException x) {
                        //如果interrupt()的时候，task.run()里面的方法执行了可中断方法，会导致该工作线程抛出异常。
                        thrown = x; throw x;
                    } catch (Error x) {
                        thrown = x; throw x;
                    } catch (Throwable x) {
                        thrown = x; throw new Error(x);
                    } finally {
                        afterExecute(task, thrown);
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

正常情况下，线程池里的线程，就是在这个while循环里不停地执行。其中代码task.run()就是在执行我们提交给线程池的任务，如当我们调用shutdownNow()时，task.run()里面调用了可中断方法(比如调用了Object.wait()或者Thread.sleep()等)，则会导致报错，可中断方法抛出InterruptedException,如果task.run()里正在正常执行，则不受影响，继续执行完这个任务。

我们知道如果一个工作线程正常的消亡，则是task = getTask()返回null，导致退出循环，run()方法执行完毕。

 private Runnable getTask() {
        boolean timedOut = false; // Did the last poll() time out?

        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

            // Check if queue empty only if necessary.
            //
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                decrementWorkerCount();
                return null;
            }

            int wc = workerCountOf(c);

            // Are workers subject to culling?
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

            if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {
                if (compareAndDecrementWorkerCount(c))
                    return null;
                continue;
            }

            try {
            //如果Worker线程处于读取任务阻塞中
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
            //没有立即终止线程，而是catch住
                timedOut = false;
            }
        }
    }

如果我们调用shutdownNow方法时，线程处于从队列里读取任务而阻塞中，则会导致抛出InterruptedException异常，但因为异常被捕获，线程将会继续在这个for循环里执行。下一次执行时，由于shutdownNow()方法里将线程修改为STOP状态，所以当代码执行到

   if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                decrementWorkerCount();
                return null;
            }

由于STOP状态值是大于SHUTDOWN状态，STOP也大于等于STOP，不管任务队列是否为空，都会进入if语句从而返回null,线程退出,此时线程正常退出。

总结：

当调用shutdownNow()时，工作线程在执行task.run()过程中调用了可中断方法（没有捕获InterruptedException异常的情况下），则会抛出异常。
当调用shutdownNow()时，工作线程正在getTask()方法中执行，则会通过for循环进入到if语句，接着getTask()返回null,从而线程退出。不管线程池里是否有未完成的任务。

shutdown()

   public void shutdown() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            checkShutdownAccess();
            //原子性的置为SHUTDOWN状态
            advanceRunState(SHUTDOWN);
            interruptIdleWorkers();
            onShutdown(); // hook for ScheduledThreadPoolExecutor
        } finally {
            mainLock.unlock();
        }
        tryTerminate();
    }

与shutdownNow()方法不同的是，它将线程池的状态置为SHUTDOWN，而不是STOP，而且阻塞线程的方法也不一样。

interruptIdleWorkers()

 private void interruptIdleWorkers(boolean onlyOne) {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            for (Worker w : workers) {
                Thread t = w.thread;
                if (!t.isInterrupted() && w.tryLock()) {
                    try {
                        t.interrupt();
                    } catch (SecurityException ignore) {
                    } finally {
                        w.unlock();
                    }
                }
                if (onlyOne)
                    break;
            }
        } finally {
            mainLock.unlock();
        }
    }

跟shutdownNow()方法调用interruptWorkers()方法不同的是，interruptIdleWorkers(boolean onlyOne)方法在遍历线程池里的线程时，有一个w.tryLock()加锁判断，只有加锁成功的线程才会被调用interrupt()方法。那什么情况下才能被加锁成功?什么情况下不能被加锁成功呢？这就需要我们继续回到线程执行的runWorker()方法。阅读源码，我们知道正在执行线程池里任务的线程不会被中断。

那工作线程什么时候退出呢？这就要看getTask方法的返回什么时候为null了。

在getTask()里的if判断中，由于线程池被shutdown()方法修改为SHUTDOWN状态，SHUTDOWN大于等于SHUTDOWN成立没问题，但是SHUTDOWN不在大于等于STOP状态，所以只有队列为空，getTask()方法才会返回null，导致线程退出。

总结：

当我们调用线程池的shuwdown()方法时，

如果线程正在执行线程池里的任务，即便任务处于阻塞状态，线程也不会被中断，而是继续执行。

如果线程池阻塞等待从队列里读取任务，则会被唤醒，但是会继续判断队列是否为空，如果不为空会继续从队列里读取任务，为空则线程退出。

关闭线程池总结

经过上述分析，我们知道如果使用shutdownNow()方法终止线程池的时候，有可能会抛出异常，而且他会将那些已添加到队列中的任务抛弃。所以我们一般会使用shutdown()方法来终止线程池。但是只使用该方法的话，我们每办法知道线程池是否已经被终止了，比如，有个任务阻塞了，那就会导致线程池关闭不了。所以我们最好在调用了shutdown（）方法后再调用awaitTermination()方法来查看线程池关闭的状态，注意，该方法只是用来查看线程池关闭的状态，并不能完成终止线程的任务。

 public boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException {
        long nanos = unit.toNanos(timeout);
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            for (;;) {
                if (runStateAtLeast(ctl.get(), TERMINATED))
                    return true;
                if (nanos <= 0)
                    return false;
                nanos = termination.awaitNanos(nanos);
            }
        } finally {
            mainLock.unlock();
        }
    }

如果线程池已关闭，则返回true，如果线程池在调用该方法时还没有关闭，那么就调用termination.awaitNanos(nanos);开始阻塞，如果在timeout时间线程池依旧没有关闭，则会返回false。所以在实际应用的时候，当检测到该方法返回false的时候，做一些处理，比如再次尝试关闭线程池等，或者发出线程池没有正常关闭的通知。

最后给出一个使用线程池的实例

package com.iyourcar.game.carshow.util;

import static org.junit.Assert.assertEquals;

import java.util.Collections;
import java.util.HashSet;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

import org.junit.Test;

public class IdGeneratorTests {



    @Test
    public void testNextId() throws InterruptedException {
        final IdGenerator idg = IdGenerator.INSTANCE;
        ExecutorService es = Executors.newFixedThreadPool(10);
        final HashSet<String> idSet = new HashSet<>();
        Collections.synchronizedCollection(idSet);
        long start = System.currentTimeMillis();
        System.out.println("***** start generate id ******");
        for (int i = 0; i < 10; i++)
            es.execute(new Runnable() {
                public void run() {
                    for (int j = 0; j < 50000; j++) {
                        String id = idg.nextId();
                        synchronized (idSet) {
                            idSet.add(id);
                            System.out.println(id);
                        }
                    }
                }
            });
        es.shutdown();
        if (es.awaitTermination(10, TimeUnit.SECONDS)) {
            System.out.println("线程池正常关闭");
        } else {
            System.out.println("线程池未关闭");
        }
        long end = System.currentTimeMillis();
        System.out.println("***** end generate id *****");
        System.out.println("***** cost " + (end - start) + " ms!");
        assertEquals(10 * 50000, idSet.size());


    }
}

BryantLmm

关注

9
点赞
踩
30

收藏

觉得还不错? 一键收藏
2
评论
interrupt()方法

title：线程中断date：2017年11月4日23:02:38今天来看看线程中断的问题。当一个线程运行时，另一个线程可以调用对应的Thread对象的interrupt（）方法来中断它，该方法只是在目标线程中设置一个标志，表示它已经被中断，并立即返回。中断的结果线程是死亡、还是等待新的任务或是继续运行至下一步，就取决于这个程序本身。线程会不时地检测这个中断标示位，以判断线程是否应该被中断...
复制链接

扫一扫