关于java线程(3)--中断任务

 

线程的状态四种：

1.新建 new，线程被创建时，会短暂的处于这种状态，他已经分配了必需的资源，并执行了初始化，

2.就绪Runnable，这种状态下，只要调度器把时间片分配给线程，线程就可以运行。

3.阻塞Blocked，线程能够运行，但是某个条件阻塞了，调度器将忽略线程，不会分配线程任何CPU时间，直到线程重新进入就绪状态

4.死亡Dead，处于死亡或终止状态的线程将不再是可调度的，并且再也不会得到CPU时间

 

A进入阻塞的条件

1.调用sleep使任务进入休眠状态，

2.通过调用wait使线程挂起，直到线程得到了notify/notifyAll消息

3.等待IO操作完成

4.任务试图在某个对象上调用其同步方法，但是对象锁不可用，另一个任务已经获取了这个锁

5.其他一些阻塞操作，比如BlockQueue.put

 

B.简单的中断处理方式

正在处理的任务，让他停止，最简单的方式就是自己维持一个cancel的标志，类似这样：

 

 

 

 

private volatile boolean cancelled;

public void run(){
   while(!cancelled){
           //do sth
   }
}

 

 

但是这种方式如果有阻塞的话就不行了，因此这时候根本不能走到判断的代码上。

 

一般方法的完成时间可以取决于它要做的事情，以及是否有足够的计算资源，而阻塞的方法还取决于一些外部条件，比如到期时间，I/O，另一个线程的动作（释放一个锁），一般方法在他们的工作做完后即结束，阻塞方法比较难预测，因为他们取决于外部事件。

 

C.响应中断的阻塞

 

sleep、wait、BlockingQueue.put等等是会相应中断的，即可中断的，Thread类包含interrupt方法，可以终止被阻塞的任务，这个方法设置线程的中断状态；如果这个线程已经阻塞，或者将执行一个阻塞操作，那么将抛出InterruptedException异常；基本上，针对异常，最好做一些和业务相关的处理，最好不要直接抛出，也不要直接吃掉异常。

 

新版的API可以在Executor上调用shutdownNow，他将发送一个interrupt调用给他启动的所有线程。如果中断单一的任务，可以使用Executor的submit方法来启动任务，就可以持有Future对象，调用它的cancel方法。Cancel方法有一个参数，mayInterruptIfRunning，对于响应中断的任务，它表示发送中断信息，请求中断当前正在运行的线程；如果是false，则表示“如果还没有启动，不要运行这个任务”，这可能对那些不能中断的任务是有效地。

 

 

D．检查中断

另外调用中断方法时，如果有可相应中断的方法，那么就会抛出异常发生中断，不然什么也不会发生。因此，如果是这种情况，需要用下面的方式来退出

 

interrupt只是设置线程的中断状态，被中断的线程，可以通过调用interrupted来轮询中断状态（这类似于前面最简单的中断处理方式），该方法还会同时清除中断状态。这不仅仅告诉你interrupt是否被调用。而且还可以清除中断状态，确保不会通知你两次。如果只是单独的查询，可以使用Threaad.isInterrupted方法！

 

void run(){
		try{
			//判断是否中断，并且清除中断状态
			while(!Thread.interrupted()){
				
		}catch(InterruptedException e){
			println "exception "+e
		}
} 

 

D.不响应中断阻塞

IO和Syn是不可中断的阻塞

1.针对I/O，有一个麻烦，但是有效地方案，即阻塞的时候直接关闭I/O.而不是靠阻断去关闭。

2.另外，nio类提供了可相应中断的类，被阻塞的通道会自动地响应中断。Nio的非阻塞I/O也不支持可中断i/o,但是可以通过关闭通道或者请求Selector上的唤醒来取消阻塞操作

 

<!--[if !supportLists]-->3.<!--[endif]-->对于锁的阻塞，不同线程去获取锁的时候会阻塞，一个线程内，调用两个syn的方法是不会阻塞的，因为锁是可重入的，当前线程已经获得了锁。另外，如果是用Lock去获取锁的话，那么它会可以响应中断。

 

 

不可响应中断的阻塞可能需要用一些猥琐的办法处理，比如io，需要将io资源在操作线程之外控制，并且在中断的时候显示的调用它的close方法。如果是显示的操作Thread，那么可以重写interrupt方法：

 

 

class IOBlocked2 extends Thread{
	InputStream inj;
	Socket socket;
	IOBlocked2(){
		socket=new Socket("localhost",8080)
		this.inj=socket.getInputStream()
	}
	
	public void interrupt(){
		try{
			println "interruptSelf"
			socket.close();
		}catch(IOException e){
		
		}finally{
			super.interrupt()
		}
	}
	
	public void run(){
		try{
			println "waiting for read"
			inj.read();
		}catch(IOException e){
			if(Thread.currentThread().isInterrupted()){
				println "interrpted"
			}else{
				println "ioException"
			}
		}
		println "io over"
	}
}

 

如果是使用ExecuterService，那么可以通过Future的cancel方法取消，Future对象是在提交给ExecuterService的使用由newTaskFor方法创建的，因此可以重写该方法：

 

 

interface CancellableTask<T> extends Callable<T>{
	void cancel();
	RunnableFuture<T> newTaskFor();
}

class CancellableExecutor extends ThreadPoolExecutor{
	
	public CancellableExecutor(int corePoolSize, int maximumPoolSize,
			long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
		super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
	}

	protected<T> RunnableFuture<T> newTaskFor(Callable<T> callabled){
		if(callabled instanceof CancellableTask)
			return ((CancellableTask)callabled).newTaskFor();
		else
			return super.newTaskFor(callabled);
	}
}


abstract class SocketUsingTask<T> implements CancellableTask<T>{
	InputStream inj;
	Socket socket;
	 
	public SocketUsingTask() throws Exception{
		socket=new Socket("localhost",8080);
		this.inj=socket.getInputStream();
	}
	
	public void cancel(){
		try{
			System.out.println( "cancelSelf");
			socket.close();
		}catch(IOException e){
			System.out.println(e);
		}
	}
	
	public RunnableFuture<T> newTaskFor(){
		return new FutureTask<T>(this){
			public boolean cancel(boolean mayInterruptIfRunning){
				try{
					SocketUsingTask.this.cancel();
				}finally{
					return super.cancel(mayInterruptIfRunning);
				}
			}
		};
	}
	
}

 

F.不响应中断----不可取消的任务

 

像Thread.sleep、BlockingQueue.put等操作，是响应中断的，但是也可以用另外一种处理策略：保存中断状态

 

有些任务拒绝被中断，这使得它们是不可取消的。但是，不可取消的任务也应该尝试保留中断状态，以防在不可取消的任务结束之后，调用栈上更高层的代码需要对中断进行处理。下面的代码，方法等待一个阻塞队列，直到队列中出现一个可用项目，而不管它是否被中断。为了方便他人，它在结束后在一个 finally 块中恢复中断状态，以免剥夺中断请求的调用者的权利。（它不能在更早的时候恢复中断状态，因为那将导致无限循环 —— BlockingQueue.take() 将在入口处立即轮询中断状态，并且，

如果发现中断状态集，就会抛出 InterruptedException。）

 

 

public Task getNextTask(BlockingQueue<Task> queue) {
    boolean interrupted = false;
    try {
        while (true) {
            try {
                return queue.take();
            } catch (InterruptedException e) {
                interrupted = true;
                // fall through and retry
            }
        }
} finally {
	//在返回前恢复中断状态，不要掩盖中断状态
        if (interrupted)
            Thread.currentThread().interrupt();
    }
}

 

F.Thread.stop和Thread.suspend被废除了

线程的Resume、suspend、stop方法都已经被废弃，因为他们是极度不安全的，参考：

为什么 Thread.stop和Thread.suspend等被废弃了？

Why Are Thread.stop, Thread.suspend,

Thread.resume and Runtime.runFinalizersOnExit Deprecated?