java并发编程实践学习（7) 取消和关闭

最新推荐文章于 2021-02-12 21:18:55 发布

memoryCoderC

最新推荐文章于 2021-02-12 21:18:55 发布

阅读量303

点赞数

分类专栏： java并发学习文章标签： java 编程并发线程

本文链接：https://blog.csdn.net/qq_27428109/article/details/55000558

版权

java并发学习专栏收录该内容

17 篇文章 0 订阅

订阅专栏

一般来说线程在结束任务后自行停止，但有时也需要在自然结束前就停止它们。
安全、快速、可靠停止线程不容易。Thread.stop和suspend可以做到，但是它们有严重缺陷，应该避免使用。java提供了中断机制使一个线程要求另一个线程停止。立即停止会导致共享结构处于不一致的状态。当要求停止时，应该先清除当前进程中的工作然后再终止。
处理好失败、关闭、还是取消是好的软件和勉强运行软件的区别。

一.任务取消

如果任务能在自然完成之前改为完成状态，那么这个任务叫做可取消的（cancellable），
取消活动的原因：

用户请求取消。用户通过管理接口请求取消。
限时任务。有时一个任务应该在规定时间内完成，否则任务会被取消
应用程序事件。一个任务请求另一个任务取消。
错误。一个任务在执行过程中发生错误，需要取消任务，可能还需要取消其他相关任务。
关闭。当一个程序或服务关闭时必须对正在处理和等待的任务进行一些操作，可以允许当前任务完成，也可以取消。

没有一种停止线程的方式是绝对安全的，只有通过协作使任务遵循一个协议来请求取消。
一种协作方式是设置标志，任务定期查看标志如果标志为结束任务就提前结束。
使用volatile域保存取消状态

@ThreadSafe
public class PrimeGenerator implementsRunnable {
    private final List<BigInteger> primes = new ArrayList<>();
    private volatile boolean canceled;
    @Override
    public void run() {
        BigInteger p = BigInteger.ONE;
        while(!canceled){
            p = p.nextProbablePrime();
            synchronized(this) { //同步添加素数
                primes.add(p);
            }
        }
    }
    /**
     * 取消生成素数
     */
    publicvoidcancel(){
        canceled = true;
    }
    /**
     * 同步获取素数
     * @return 已经生成的素数
     */
    public synchronized List<BigInteger> get(){
        return new ArrayList<>(primes);//避免primes逸出
    }
}

一个任务必须拥有取消策略，这个策略必须说明“怎么取消”、“什么时候取消”、“取消时执行的行为”。

1.中断

特定的阻塞类库支持中断。线程中断是一种协作机制，一个线程给另一个线程发送型号量，通知它在可能的情况下停止正在做的工作，去做其他事情。
每一个线程都有一个boolean类型的中断状态，在中断时被设置为true。interrupt方法会中断目标线程，isInterrupted方法返回目标线程的中断状态，interrupted方法会清除当前线程的中断状态并返回之前的值，这是唯一清除中断状态的方法。
阻塞库函数会清除中断状态，调用interrupt()不会立刻中断正在执行的线程，只是将线程的中断标识位设置成true。线程会在下一个取消点中断自己，也就是说，线程在调用sleep()、join()、wait()方法时会收到线程中断信号，则会抛出InterruptedException，在catch块中捕获到这个异常时，线程的中断标志位已经被设置成false了。
中断通常是实现取消最明智的选择
通过中断进行取消

public class PrimeProducer extends Thread {
    private final BlockingQueue<BigInteger> queue;

    public PrimeProducer(BlockingQueue<BigInteger> queue){
        this.queue = queue;
    }
    @Override
    public void run() {
        try{
            BigInteger p = BigInteger.ONE;
            while(!Thread.currentThread().isInterrupted()){
                queue.put(p = p.nextProbablePrime());
            }
        } catch(InterruptedException e) {
            // thread exit
        }
    }
    /**
     * 取消
     */
    public void cancel(){
        interrupt(); //中断当前线程
    }
}

2.中断策略

中断策略是指当发现中断请求时，应该做什么，哪些操作对于中断请求是原子操作，以及在多快时间内响应中断。
当检查到中断请求时，任务并不需要放弃所有的事情-他可以选择推迟，直到更合适的时机。这时需要记得它已经被请求中断，完成正在进行的任务，然后抛出InterruptedException或者指明中断。

3.响应中断

当发现中断请求时有俩中处理InterruptedException的实用策略：

传递异常，使你的方法成为可中断的阻塞方法（将异常抛出）。
保存中断状态，上层调用栈中的代码能够对其进行处理。

4.通过Futrue取消

public void timedRun(Runnable r, longtimeout, TimeUnit unit)
            throws InterruptedException {
    Future<?> task = taskExec.submit(r);
    try{
        task.get(timeout, unit);
    } catch(ExecutionException e) {
        //任务执行中抛出异常
    } catch(TimeoutException e) {
        //任务超时处理
    } finally{
        //如果任务执行完毕,则没有影响; 如果任务执行中，则会中断任务
        if(task != null) task.cancel(true);
    }
}

当Future.get抛出InterruptedException或TimeoutException时，如果你知道不再需要结果，那么就可以调用Future.cancel来取消任务。

5.处理不可中断阻塞

不是所有的阻塞方法或阻塞机制都响应中断，比如Socket I/O或者等待获得内部锁而阻塞。这时我们可以使用类似中断的手段来停止。

java.IO中同步Socket I/O。在InputStream和OutputStream中不能响应中断，但是关闭底层的Socket可以让read或write所阻塞的线程抛出一个SocketException
java.nio中同步I/O。中断或关闭正在InterruptibleChannel上等待的线程时，会对应抛出ClosedByInterruptException或AsynchronousCloseException。
Selector的异步I/O。如果一个线程在调用Selector.select时阻塞了，则不会响应中断（interrupt），但是调用close或 wakeup会使线程抛出ClosedSelectorException。
等待获得内部锁时。如Synchronized阻塞时不会响应中断。但Lock类的lockInterruptibly允许在等待锁时响应中断。（后面讲）

6.用newTaskFor封装非标准取消

可以使用钩子函数来改进用来封装非标准取消的方法，这时java6中添加到ThreadPoolexecutord的新特性。当提交一个Callable给ExecutionService时，submit返回一个Future，可以用Future来取消任务。newTaskFor钩子是一个工厂方法，创建一个Future来代表任务，这个Future属于由FutureTask实现的RunnableFuture接口，这个接口可以自定义cancel方法，实现自定义的取消方式。

public stract class SocketUsingTask<T>  implements CancellableTask<T>{

    protected synchronized void setSocket(Socket s){socket=s;}

    public synchronized void cancel(){
        try{
            if (socket!=null) socket.close();
        }catch (IOException ignored){
        }
    }
    public RunnableFuture<T> newTask(){
        return new FutureTask<T>(this){
            public boolean cancel(boolean mayInterruptIfRunning){
                try{
                    socketUsingTask.this.cancel();
                }finally{
                    return super.cancel(mayInterruptIfRunning);
                }
            }
        };
    }

}

二.停止基于线程的服务

应用程序通常会创建拥有线程的服务，比如线程池，这些服务通常比创建它们的方法存在的时间长。如果应用程序优雅的退出，它们需要自行结束。你不应该中断，改变它的优先级，等等。
那么线程池拥有它的工作者，所以需要中断这些线程应该由线程池负责。应用程序拥有服务，服务拥有工作者线程，但是应用程序不拥有工作者线程。所以服务应该提供生命周期方法来关闭他自己，并关闭它所拥有的工作者线程。ExecutorService提供了shutdown和shutdownNow方法
对于线程持有的服务，只要服务的存在时间大于创建线程的方法存在的时间，那么就应该提供生命周期方法

2.关闭ExecutorService

Executor提供了关闭的两种方法：使用shutdown优雅的关闭和shutdownNow强行关闭。强行关闭的速度更快但是风险大，而正常关闭虽然速度慢却安全。其他拥有线程的服务也应该这样做。

3.致命药丸

另一种保证生产者和消费者服务关闭的方式是使用致命药丸（poison poill）：一个可识别的对象，置于队列中意味着“得到它就停止一切工作”。
在先进先出的队列中保证了消费者完成队列中关闭之前的工作，生产者不应该在致命药丸之后再提交工作。

4.shutdownNow的局限性

当通过shutdownNow强行关闭一个ExecutorService时。它试图取消正在进行的任务、并返回那些已经提交但没有开始的任务清单。这样这些任务可以被日志记录或者存起来等进一步的处理。但是却不支持将正在进行中的任务完成或者返回给调用者。

三.处理反常的线程终止

在多线程程序中，当线程失败的时候，应用程序看起来还在工作，所以我们有方法可以检测盒防止线程从程序中“泄露”。
任何代码都可以抛出RuntimeException。无论何时，当你通过Runnable这样的抽象体调用未知不可信的代码时，你需要考虑捕获RuntimeException。

1.未捕获异常的处理

线程的API提供了UncaughtExceptionHandler工具，使你能监测到线程因为未捕获的异常引起的“死亡”。和前面主动捕获合在一起组成了对抗线程泄露的强有力保障。
当一个线程因为未捕获异常退出时，JVM、会把这个事件报告给应用程序提供的UncaughtExceptionHandler；如果处理器（handler）不存在默认向System.err打印出栈的追踪信息。
为了给线程池设置UncaughtexceptionHandler，需要向ThreadPoolExecutor的构造函数提供一个ThreadFactory。
给线程设置UncaughtexceptionHandler

public static void main(String[] args) throws InterruptedException {                  
    Thread t = new Thread(new UncaughtException.Run());  
    t.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {  
        @Override  
        public void uncaughtException(Thread t, Throwable e) {  
            System.out.println("uncaughtExceptionHandler catch a Exception---------");  
            System.out.println(e.getMessage());  
        }  
    });  

    t.start();  
    Thread.sleep(100);  
}  

static class Run implements Runnable{  
    @Override  
    public void run() {  
        System.out.println("runnable run---------------");        
        int i = 1/0;  
    }  
}

给线程池设置UncaughtexceptionHandler

public class MyThreadFactory implements ThreadFactory{
    public Thread newThread(Runnable r) {
        Thread t = new Thread(r);
        t.setUncaughtExceptionHandler(new RewriteUncatchtExceptionHandler());
        System.out.println("Thread[" + t.getName() + "] created.");
        return t;

    }
} 
/**

   * 虽然从写ThreadFactory以后，可以捕获到异常，但是只能是execute,而submit还是不行
   */
public static void catchedExecutor() {
    ExecutorService executorService = Executors.newCachedThreadPool(new MyThreadFactory());
    executorService.execute(new Task());
    executorService.shutdownNow();
}

四.JVM关闭

JVM可以正常关闭也可以非正常关闭。当最后一个正常（非精灵）线程终结时，或者调用System.exit，或者使用其他与平台相关的手段，都开始一个正常关闭。它也可以通过Runtime.halt或者杀死JVM的操作系统进程来强行关闭。

1.关闭钩子

我们需要在JVM关闭时做些扫尾的工作，比如删除临时文件、停止日志服务以及内存数据写到磁盘等，为此JVM提供了关闭钩子（shutdown hooks）来做这些事情。
正常的关闭中首先启动所有已注册的（关闭钩子）Shutdown hook。我们使用Runtime.addShutdownHook注册关闭钩子。
对于一个JVM中注册的多个关闭钩子它们将会并发执行，所以JVM并不能保证它的执行顺行。当所有的Hook线程执行完毕后，如果此时runFinalizersOnExit为true，那么JVM将先运行Finalizer，然后停止。Hook线程会延迟JVM的关闭时间，这就要求在编写钩子过程中必须要尽可能的减少Hook线程的执行时间。另外由于多个钩子是并发执行的，那么很可能因为代码不当导致出现竞态条件或死锁等问题，为了避免该问题，强烈建议在一个钩子中执行一系列操作。

public class ShutDownHook extends Thread{  
    public static void main(String[] args){  
    Runtime.getRuntime().addShutdownHook(new ShutDownHook());  
    for(int i=0;i<10;i++){  
        System.out.println("i="+i);  
        if(i==4){  
        System.exit(0);  
        }  
        try {  
        Thread.sleep(1000);  
        } catch (InterruptedException e) {  
        // TODO Auto-generated catch block  
        e.printStackTrace();  
        }  
    }  
    }  
    public void run(){  
    System.out.println("hook shutdown!");  
    }  
}

2.精灵线程（守护线程）

有时你想创建一些线程辅助工作但是不想阻碍JVM的关闭，这时需要精灵线程。
精灵线程是一类特殊的线程，它和普通线程的区别在于它并不是应用程序的核心部分，当一个应用程序的所有非守护线程终止运行时，即使仍然有守护线程在运行，应用程序也将终止，反之，只要有一个非守护线程在运行，应用程序就不会终止。守护线程一般被用于在后台为其它线程提供服务。
在java中，设置某线程为守护线程（精灵线程），可以通过方法setDaemon(boolean on)来实现。如果一个线程被设为守护线程或者用户线程，那么该线程处于后台运行，当主线程做完，那么整个程序就结束了，自然而然该线程也就结束了。需要强调的一点是该方法必须在启动线程前调用。
我们也可以通过isDaemon（）方法来判断某一个线程是否是精灵线程。

public class UserTimeOutThread extends Thread{
    private SepUserlist sepUserlist=new SepUserlist();
    public UserTimeOutThread(){
        this.setDaemon(true);//必须在调用start（）方法之前调用
        start();
    }
    public void run(){ 
        //该线程需要做的工作，在这儿是设置每隔5分钟进行一次扫描
        while(true){
            try{
                super.sleep(300000);
            }catch(Exception e){
                System.out.println(e.toString());
            }
            System.out.println("search user");
            sepUserlist.TravelVector(SocketConstant.name);  
        }
    } 
}

3.Finalizer

垃圾回收器对那些具有特殊finalize的方法的对象会特殊对待；在回收器获得他们后，finalize被调用，这样就能保证持久化的资源可以被释放。
因为finalizer运行在一个JVM管理的线程中，任何finalizer访问的状态都会被对多个线程访问，因此必须同步，finalizer运行时不提供任何保证，并且复杂的话会带来巨大开销，书写finalizer也十分困难。因此用显示的close方法和finally结合来管理资源比只使用finalizer要好。所以尽量避免编写使用包含特殊finalizer的类

memoryCoderC

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java并发编程实践学习（7) 取消和关闭

一般来说线程在结束任务后自行停止，但有时也需要在自然结束前就停止它们。安全、快速、可靠停止线程不容易。Thread.stop和suspend可以做到，但是它们有严重缺陷，应该避免使用。java提供了中断机制使一个线程要求另一个线程停止。立即停止会导致共享结构处于不一致的状态。当要求停止时，应该先清除当前进程中的工作然后再终止。
复制链接

扫一扫