[温故]图解java多线程设计模式(二)

一、join & interrupt

这俩方法属于线程对象里的方法,属于线程本身的操作。

1.1:join方法

用于等待一个线程的终止,等待期间将会阻塞,直到被等待的线程终止结束。

所以join可以用来做多任务异步处理,比如还是拿利用CompletableFuture优化程序的执行效率这篇里的第一个例子做优化,这篇文章里使用线程池的future模式进行多任务异步处理,现在使用join改写下:

再来简单贴下这几个方法


private String getTop() { // 这里假设getTop需要执行200ms
        try {
            Thread.sleep(200L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "顶部banner位";
    }

    private String getLeft() { // 这里假设getLeft需要执行50ms
        try {
            Thread.sleep(50L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "左边栏";
    }

    private String getRight() { // 这里假设getRight需要执行80ms
        try {
            Thread.sleep(80L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "右边栏";
    }

    private String getUser() { // 这里假设getUser需要执行100ms
        try {
            Thread.sleep(100L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "用户信息";
    }

然后现在使用简单的线程做异步处理:


// 简单异步获取
    public WebModule getWebModuleMsgSimpleAsync() throws ExecutionException, InterruptedException {

        WebModule webModule = new WebModule();

        Thread topTask = new Thread(() -> webModule.setTop(this.getTop()));
        Thread leftTask = new Thread(() -> webModule.setLeft(this.getLeft()));
        Thread rightTask = new Thread(() -> webModule.setRight(this.getRight()));
        Thread userTask = new Thread(() -> webModule.setUser(this.getUser()));

        //触发各个异步任务
        topTask.start();
        leftTask.start();
        rightTask.start();
        userTask.start();

        //等待所有的任务均执行完毕
        topTask.join();
        leftTask.join();
        rightTask.join();
        userTask.join();

        return webModule;
    }

测试代码:


@Test
    public void testSimpleASync() throws Exception {
        // 同步方法测试,预估耗时200ms
        long start = System.currentTimeMillis();
        WebModule module = webHome.getWebModuleMsgSimpleAsync();
        System.out.println("通过异步方法获取首页全部信息消耗时间:" + (System.currentTimeMillis() - start) + "ms");
        System.out.println("结果为:" + module.toString());
    }

测试结果:


通过异步方法获取首页全部信息消耗时间:272ms
结果为:top: 顶部banner位;  left: 左边栏;  right: 右边栏;  user: 用户信息

比预估的要多72ms,经过后来的测试,发现这72ms耗时发生在线程创建的时候,以及后续线程状态转换带来的消耗,下面等待异步结束的时间约等于200ms,符合预期。

1.2:interrupt方法

用于主动终止一个线程,线程本身调用该方法后,视为已终止状态,join解除阻塞,下面来用interrupt和join来做个实验:


public class JoinTest {

    private boolean isStop = false;

    public static void main(String[] args) throws Exception {
        JoinTest test = new JoinTest();
        Thread loopT = new Thread(test::loopTask);
        loopT.start();

        sleep(2000L); //2s后终止线程
        test.setStop(true);

        long s = System.currentTimeMillis();
        loopT.join();
        System.out.println("线程终止后,join阻塞时间为:" + (System.currentTimeMillis() - s));
        System.out.println("end~");
    }

    public void setStop(boolean stop) {
        isStop = stop;
    }

    public void loopTask() {
        while (!isStop) { //若状态为false,则继续执行下面的逻辑,每隔1s打印一次
            sleep(1000L);
            System.out.println("loop trigger ~");
        }
        Thread.currentThread().interrupt(); //在这里终止掉当前线程
        //事实上,在终止掉线程后,还有接下来的逻辑要执行
        long s = System.currentTimeMillis();
        for (int i = 0; i < 1000000; i++) {
            int[] a = new int[100]; //模拟耗时操作,这里不能用sleep了,因为当前线程已经被终止了
        }
        System.out.println("线程终止后,逻辑块运行时间:" + (System.currentTimeMillis() - s));
    }

    public static void sleep(long time) {
        try {
            Thread.sleep(time);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

执行结果:


loop trigger ~
loop trigger ~
线程终止后,逻辑块运行时间:129
线程终止后,join阻塞时间为:129
end~

即便线程被终止了,后面的逻辑也会触发,join依旧会选择阻塞,直到后续逻辑执行完毕,事实上,大部分任务都可以及时的终止,比如第一个例子,异步出去的任务,最终都会执行完成,线程变为终止状态,join都可以顺利结束,但是反观上例,如果没人及时的设置isStop的值,程序会一直执行下去,没有终止态,join会无止境的终止下去,这里提一下stop,线程的stop方法已被官方标记为“不建议使用”的方法,如果把上例的interrupt的调用换成stop,来看看其运行结果:


loop trigger ~
loop trigger ~
线程终止后,join阻塞时间为:0
end~

可以看到,线程终止后的后续逻辑均没有触发,等于说stop是一种很粗暴的终止线程的方式,一旦被stop,那么里面的业务逻辑将直接断掉,因此官方并不推荐使用该方法来终止线程。

而interrupt,仅仅是对目标线程发送了了一个中断信号(改变了线程的中断状态而已),当目标线程再次通过obj.wait、thread.sleep、thread.join方法进入阻塞状态时,接收到该信号,就会抛出InterruptedException异常,这时候需要业务方自行处理或者直接抛出,以结束线程阻塞状态(这里需要注意的是被obj.wait方法阻塞时,抛出该异常需要目标线程再次获得实例对象obj的锁才行)。

上述三个“需要花费时间”的方法均抛出了InterruptedException异常,针对这些特性,想要完成以下操作就非常方便了:

①取消wait方法等待notify/notifyAll的处理

②取消在sleep方法指定时间内停止的处理

③取消join方法等待其他线程终止的处理

取消之后所做的处理,取决于需求,可能会终止线程,或者通知用户已取消,或者终止当前处理进入下一个处理阶段。

二、线程状态迁移图

图1

上面的图太多太杂,我们通过对一些可以影响线程状态的操作的分类,来简化一下上面的图:

 

图2

 

posted @ 2019-03-13 09:08  胖虎1993  阅读(403)  评论(0编辑  收藏