【并发编程】实现多线程的几种方式

---

本博客系列是学习并发编程过程中的记录总结。由于文章比较多，写的时间也比较散，所以我整理了个目录贴（传送门），方便查阅。

---

在java中有多种方式可以实现多线程编程（记得这是一道常问的面试题，特别是在应届生找工作的时候被问的频率就更高了）。

• 继承thread类并重写run方法；
• 实现runnable接口，并将这个类的实例当做一个target构造thread类
• 实现callable接口；

继承thread类

通过继承thread类来实现多线程编程很容易。下面代码中mythread类继承了thread类，并重写了run方法。

但是这种方式不是很建议使用，其中最主要的一个原因就是java是单继承模式，mythread类继承了thread类之后就不能再继承其他类了。所以使用implement的形式比继承的方式更好。线面会讲到使用runnable接口实现多线程。

public class mythread extends thread {

    public static final int thread_count = 5;

    public static void main(string[] args) {

        list<thread> threadlist = new arraylist<>();

        for (int i = 0; i < thread_count; i++) {
            thread thread = new mythread();
            thread.setname("mythread--"+i);
            threadlist.add(thread);
        }
        threadlist.foreach(var->{var.start();});
    }

    @override
    public void run() {
        super.run();
        system.out.println("my thread name is:"+thread.currentthread().getname());
        random random = new random();
        int sleeptime = random.nextint(5);
        try {
            timeunit.seconds.sleep(sleeptime);
        } catch (interruptedexception e) {
            e.printstacktrace();
        }finally {
            system.out.println(thread.currentthread().getname()+" end after "+sleeptime+" seconds");
        }
    }
}

实现runnable接口实现多线程

下面我们就通过实现runnable接口的形式来改造下上面的代码。

可以发现，通过实现runnable接口实现多线程编程也非常方便。但是不需要再继承thread类，减少了耦合。同时new了一个runner对象后，这个对象可以比较方便地在各个线程之间共享。因此相对于继承thread的方式，更加推荐使用runnable接口的方式实现多线程编程。

public class mythread {

    public static final int thread_count = 5;

    public static void main(string[] args) {

        list<thread> threadlist = new arraylist<>();
        runner runner = new runner();

        for (int i = 0; i < thread_count; i++) {
            thread thread = new thread(runner);
            thread.setname("mythread--"+i);
            threadlist.add(thread);
        }
        threadlist.foreach(var->{var.start();});
    }


    public static class runner implements runnable{
        @override
        public void run() {
            system.out.println("my thread name is:"+thread.currentthread().getname());
            random random = new random();
            int sleeptime = random.nextint(5);
            try {
                timeunit.seconds.sleep(sleeptime);
            } catch (interruptedexception e) {
                e.printstacktrace();
            }finally {
                system.out.println(thread.currentthread().getname()+" end after "+sleeptime+" seconds");
            }
        }
    }

}

实现callable接口

上面介绍了两种方式都可以很方便地实现多线程编程。但是这两种方式也有几个很明显的缺陷：

• 没有返回值：如果想要获取某个执行结果，需要通过共享变量等方式，需要做更多的处理。
• 无法抛出异常：不能声明式的抛出异常，增加了某些情况下的程序开发复杂度。
• 无法手动取消线程：只能等待线程执行完毕或达到某种结束条件，无法直接取消线程任务。

为了解决以上的问题，在jdk5版本的java.util.concurretn包中，引入了新的线程实现机制：callable接口。

@functionalinterface
public interface callable<v> {
    /**
     * computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws exception if unable to compute a result
     */
    v call() throws exception;
}

看了callable接口的介绍，其实这个接口的功能是和runnable一样的，和runnable接口最主要区别就是:

• callable接口可以有返回值；
• callable接口可以抛出异常；

下面通过使用callable接口的方式来改造下上面的代码：

public class mythread {

    public static final int thread_count = 5;

    public static void main(string[] args) throws exception {

        executorservice executorservice = executors.newfixedthreadpool(thread_count);
        runner runner = new runner();

        for (int i = 0; i < thread_count; i++) {
            future<integer> submit = executorservice.submit(runner);
            //get方法会一直阻塞等到线程执行结束
            system.out.println(submit.get());
        }
        executorservice.shutdown();

    }


    public static class runner implements callable<integer> {

        @override
        public integer call() throws exception {
            system.out.println("my thread name is:"+thread.currentthread().getname());
            random random = new random();
            int sleeptime = random.nextint(500);
            try {
                timeunit.seconds.sleep(sleeptime);
            } catch (interruptedexception e) {
                e.printstacktrace();
            }finally {
                system.out.println(thread.currentthread().getname()+" end after "+sleeptime+" seconds");
            }
            return sleeptime;
        }
    }

}

上面代码中，我们使用future类来获取返回结果。future接口的主要方法如下：

• isdone()：判断任务是否完成。
• iscancelled()：判断任务是否取消。
• get()：获取计算结果（一致等待，直至得到结果）。
• cancel(true)：取消任务。
• get(long,timeunit)：规定时间内获取计算结果（在long时间内等待结果，如果得到则返回；如果未得到，则结束，并抛出timeoutexception异常）。