Java中的线程中断

最新推荐文章于 2024-02-25 10:51:03 发布

原创最新推荐文章于 2024-02-25 10:51:03 发布 · 1.2k 阅读

0 ·

CC 4.0 BY-SA版权

Java笔记专栏收录该内容

9 篇文章

订阅专栏

本文详细介绍了线程的不同状态，包括新建、就绪、阻塞和死亡，并探讨了线程进入阻塞状态的原因及线程中断的相关方法。通过实例演示了如何检查线程的中断状态。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1、线程的状态：

1）新建（new）：线程被创建之后，已经执行了初始化，系统也为线程分配了各种所需的资源，只要获得cpu，线程既可以开始执行；

2）就绪（Runnable）：此时，线程虽然处于Runnable状态，但是它不一定正在运行，只有当线程获得了cpu时间片才真正的在运行，系统给线程分配的时间片没办法控制；

3）阻塞（Blocked）：线程能够运行，但是某种条件阻止了它的运行，此时，线程调度器不会再将cpu时间片分配给处于该状态下的线程，直到线程重新进入就绪状态；

4）死亡（Dead）：线程被中断或者从run方法返回。

2、导致线程进入阻塞状态的原因：

1）调用sleep()、wait()、join()方法；

2）线程在等待I/O操作的完成；

3）线程在等待获得同步锁。

3、线程的中断状态：

interrupt status，也即中断状态，true表示线程被中断了，false表示没有被中断。在Java API中表示中断状态的字段是：private volatile Interruptible blocker;对“Interruptible”这个类不需要深入分析，对于“blocker”变量有以下几个操作：

1）默认的blocker = null；

2）interrupt0()方法将会导致线程的中断状态被设置为true；

3）再次调用interrupt0()方法将导致线程的中断状态被清除（中断状态变成false）。

4、线程中断相关的方法：

1）public void interrupt()：

public void interrupt() {
        if (this != Thread.currentThread())
            checkAccess();


        synchronized (blockerLock) {
            Interruptible b = blocker;
            if (b != null) {
                interrupt0();           // Just to set the interrupt flag
                b.interrupt(this);
                return;
            }
        }
        interrupt0();
    }

这个方法并没有直接中断线程，只是设置了线程的中断状态为true（同步快的后面调用了interrupt0()方法）。同步块中的if语句在默认情况下并不会执行，因为b（也就是中断状态）默认情况下是null。如果线程调用了sleep()、wait()、join()方法而使线程进入阻塞状态（b != null），interrupt()方法会清除中断状态(同步快中调用了一次interrupt0()方法)，并抛出InterruptedException异常；

2）public static boolean interrupted()：

public static boolean interrupted() {
        return currentThread().isInterrupted(true);
    }

返回线程前一次的中断状态，返回之后，线程的中断状态会被设置为false；

3）public boolean isInterrupted()：

public boolean isInterrupted() {
        return isInterrupted(false);
    }

返回线程当前的中断状态，与2）不同的是，这个方法并不会清除线程的中断状态。（一般使用这个方法来检查线程的中断状态）

4）private native boolean isInterrupted(boolean ClearInterrupted)

检查线程是否被中断，线程的中断状态会被重新设置为传进去的状态。（这个方法因为是private型的，所以没法调用）

注：

a、这里所说的线程的中断跟操作系统中的中断（进程因为分配的CPU时间片用完而放弃CPU）不是一个概念；

b、异常并不是由引起中断的方法抛出的，而是由前面说的sleep、wait、join方法抛出的；

c、线程的中断状态被设置为true之后，线程是否抛出中断异常，由线程自己来决定。正常运行的线程不会抛出中断异常，阻塞的线程会抛出中断异常；

5、代码1：几种类型的中断

说明：下面的每一个类都代表一种类型的中断

class SleepBlocked implements Runnable {

	@Override
	public void run() {
		// TODO Auto-generated method stub
		try {
			System.out.println("SleepBlocked线程休眠中...");
			TimeUnit.SECONDS.sleep(100);// 线程休眠100秒
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			System.out.println("SleepBlocked线程休眠期间被中断");
		}
	}
}

class JoinBlocked implements Runnable {

	@Override
	public void run() {
		// TODO Auto-generated method stub
		try {
			System.out.println("JoinBlocked等待子线程执行完毕...");
			new JoinThread().join();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			System.out.println("JoinBlocked线程等待子线程执行期间被中断");
		}
	}

	class JoinThread extends Thread {

		public JoinThread() {
			start();
		}

		public void run() {
			// TODO Auto-generated method stub
			while (true)
				// 中间插进来的进程一直不退出，使外层的线程一直处于阻塞状态
				Thread.yield();
		}
	}

}

class IOBlocked implements Runnable {
	private InputStream in;

	public IOBlocked(InputStream is) {
		in = is;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		try {
			System.out.println("IOBlocked线程等待输入...");
			in.read(); // 这个方法也会产生阻塞，等待输入完成
		} catch (IOException e) {
			if (Thread.currentThread().isInterrupted()) {
				System.out.println("IOBlocked线程等待输入期间被中断");
			} else {
				throw new RuntimeException(e);
			}
		}
	}
}

class SynchronizedBlocked implements Runnable {

	public synchronized void f() {
		while (true)
			Thread.yield();
	}

	public SynchronizedBlocked() {
		new Thread() {
			public void run() {
				f(); // 此处的f()方法会在run()中的f()方法之前执行
			}
		}.start();
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("SynchronizedBlocked线程等待获取同步锁...");
		f(); // 此处的f()方法会一直处于阻塞状态，等待获得同步锁，当然，它永远也不会获得同步锁
	}
}

class RunningThread implements Runnable {
	boolean flag = true;

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("RunningThread线程正常执行中...");
		while (flag)
			// 为了骗编译器，在这个地方不能用true代替flag
			Thread.yield();
		System.out.println("RunningThread执行过程中被中断");
	}

}

class InterruptedThread implements Runnable {

	boolean flag = true;

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("InterruptedThread线程正常执行中...");
		while (flag)
			// 为了骗编译器，在这个地方不能用true代替flag
			Thread.yield();
		System.out.println("InterruptedThread执行过程中被中断");
	}

}

public class ThreadInterrupting {
	private static ExecutorService exec = Executors.newCachedThreadPool();

	static void test_cancel(Runnable r)
			throws InterruptedException {
		Future<?> f = exec.submit(r);
		TimeUnit.MILLISECONDS.sleep(100);
		f.cancel(true);
	}

	static void test_interrupt(Runnable r)
			throws InterruptedException {
		Thread thread = new Thread(r);
		thread.start();
		TimeUnit.MILLISECONDS.sleep(100);
		thread.interrupt();
	}

	public static void main(String[] args) throws InterruptedException {
		// TODO Auto-generated method stub
		System.out.println("function of Future.cancel():");
		test_cancel(new SleepBlocked());
		test_cancel(new JoinBlocked());
		test_cancel(new IOBlocked(System.in));
		test_cancel(new SynchronizedBlocked());
		test_cancel(new RunningThread());

		System.out.println("--------------割--------------");
		TimeUnit.SECONDS.sleep(3); // 主线程休眠一会，等待前面的线程执行完毕

		System.out.println("function of Thread.interrupt():");
		test_interrupt(new SleepBlocked());
		test_interrupt(new JoinBlocked());
		test_interrupt(new IOBlocked(System.in));
		test_interrupt(new SynchronizedBlocked());
		test_interrupt(new RunningThread());

		TimeUnit.SECONDS.sleep(3);
		System.out.println("退出");
		System.exit(0);
	}

}

输出结果：

function of Future.cancel():
SleepBlocked线程休眠中...
SleepBlocked线程休眠期间被中断
JoinBlocked等待子线程执行完毕...
JoinBlocked线程等待子线程执行期间被中断
IOBlocked线程等待输入...
RunningThread线程正常执行中...
--------------割--------------
function of Thread.interrupt():
SleepBlocked线程休眠中...
SleepBlocked线程休眠期间被中断
JoinBlocked等待子线程执行完毕...
JoinBlocked线程等待子线程执行期间被中断
IOBlocked线程等待输入...
SynchronizedBlocked线程等待获取同步锁...
RunningThread线程正常执行中...
退出

发现cancel()方法和interrupt()方法的效果是一样的。

结论：被sleep()、join()方法阻塞的线程，可以被中断，但是被I/O、同步锁阻塞的线程不能被中断，也不能直接中断正在正常运行的线程。

6、检查中断状态：

1）使用IsInterrupted()

class NormalRunningThread extends Thread { // 一个正常运行的线程
	private boolean flag = true;

	public void run() {
		while (flag)
			Thread.yield();
		System.out.println("NormalRunningThread线程被打断");
	}
}

class BlockedThread extends Thread { // 一个被阻塞的线程

	public void run() {
		try {
			sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			System.out.println("BlockedThread线程被打断");
		}
	}
}

public class Methods_isInterrupted {
	private static Thread thread;

	private synchronized static void test_interrupt(Thread t)
			throws InterruptedException {
		thread = t;
		thread.start();

		// 线程开启之后，中断状态为false，isInterrupted方法不会影响线程的中断状态
		if (thread.isInterrupted())
			System.out.println("调用isInterrupted方法后" + thread.getName()
					+ "的中断状态为true");

		thread.interrupt(); // 设置线程的中断状态为true
		if (thread.isInterrupted()) // 判断完线程的中断状态之后，中断状态不变
			System.out.println("设置线程的中断状态之后" + thread.getName() + "的中断状态为true");
	}

	public static void main(String args[]) throws InterruptedException {
		test_interrupt(new NormalRunningThread());
		test_interrupt(new BlockedThread());

		TimeUnit.SECONDS.sleep(2);
		System.exit(0);
	}
}

输出结果：

设置线程的中断状态之后Thread-0的中断状态为true
设置线程的中断状态之后Thread-1的中断状态为true
BlockedThread线程被打断

发现interrupt()方法的确会将线程的中断状态设置为true，至于线程的中断状态被设置为true之后线程会采取什么操作，那就是线程自己的事了。

2）使用interrupted()

class NeedsCleanup {
	private final int id;

	public NeedsCleanup(int ident) {
		id = ident;
		System.out.println("NeedsCleanup " + id);
	}

	public void cleanup() {
		System.out.println("Cleaning up " + id);
	}
}

class Blocked implements Runnable {
	private volatile double d = 0.0;

	@Override
	public void run() {
		// TODO Auto-generated method stub
		try {
			while (!Thread.interrupted()) {
				NeedsCleanup n1 = new NeedsCleanup(1);
				try {
					System.out.println("Sleeping");
					TimeUnit.SECONDS.sleep(1);
					NeedsCleanup n2 = new NeedsCleanup(2);
					try {
						System.out.println("Calculating"); //干一件复杂的事
						for (int i = 0; i < 2500000; i++)
							d = d + (Math.PI + Math.E) / d;
						System.out.println("Finished time-consuming operation");
					} finally {
						n2.cleanup();
					}
				} finally {
					n1.cleanup();
				}
			}
			System.out.println("Exiting via while() test");
			if(!Thread.currentThread().isInterrupted()) {
				System.out.println("中断状态被清除了");
			}
		} catch (InterruptedException e) {
			System.out.println("Exiting via InterruptedException");
		}
	}

}

public class InterruptingIdiom {

	public static void main(String[] args) throws NumberFormatException,
			InterruptedException {
		// TODO Auto-generated method stub
		Thread t = new Thread(new Blocked());
		t.start();
		TimeUnit.MILLISECONDS.sleep(1100); 
		t.interrupt();
	}

}

说明一下，由于机器性能不同，为了使Blocked线程能在正常工作的时候退出，main线程需要休眠的时间可能不同，这是我的一个测试结果：

NeedsCleanup 1
Sleeping
NeedsCleanup 2
Calculating
Finished time-consuming operation
Cleaning up 2
Cleaning up 1
Exiting via while() test
中断状态被清除了

最后一句话为什么会被打印出来？因为在Blocked线程正常工作期间，调用了interrupt()方法设置线程的中断状态为true，while在进行下一次循环条件（!Thread.interrupted()）的检测时，得到的结果为false，但是得到false的同时interrupted()方法会将线程的中断状态清除（也即设置为false）。