Java - 线程池创建的三种方式(两种常见方式和一种不常见的方式)

线程池创建的两种常见方式和一种不常见的方式

线程池创建的两种常见方式有继承Thread 和 实现Runnable接口；一种不常见甚至被许多人遗忘的方式是Callable接口。下面就来看一看两种常见的和一种不常见的。

1.继承Thread

Thread是Java用于实现多线程的类之一，继承Thread类之后就是一个线程类。继承之后需要重写一个run()方法，run()方法就是线程要执行的任务。执行路径的触发方式，不是调用run()方法，而是通过thread对象的start()方法来启动任务。

// 如果需要开辟新的线程就得使用到Thread类，注意 是所有的需要开辟新线程的方式都得使用Thread
// 后面的Runnable、Callable都得用到Thread来进行启动新的线程

1.1继承Thread类开启多线程

先写一个继承Thread的类(Java当中只有单继承)

public class MyThread extends Thread{    
	/**
     * run方法就是线程要执行的任务方法
     */
    @Override
    public void run() {//重写run方法
        //这里的代码就是一条新的执行路径
        //执行路径的触发方式，不是调用run()方法，而是通过thread对象的start()方法来启动任务。
        //它会启动一个线程，在该线程中运行
        for (int i = 0; i < 4; i++) {
            System.out.println("执行mythread"+i);
        }
    }
}

mian方法

public class Demo1 {
    public static void main(String[] args) {
        //创建Thread类对象
        Thread thread = new MyThread();
        thread.start();
        //main函数的主线程
        for (int i = 0; i < 4; i++) {
            System.out.println("执行main"+i);
        }
    }
}

执行的结果就是

执行main0
执行mythread0
执行mythread1
执行mythread2
执行mythread3
执行main1
执行main2
执行main3

谁先执行是不能确定的，结果每一次执行都可能不一样，是因为在Java当中线程是以 抢占式分配 的机制。以上情况称为线程不安全，想要线程安全就使用加锁机制，可以看我这一篇文章——显式锁和隐式锁异同 进行了解。

需要注意的点
1.	main方法是运行在main线程里面的，它是主线程；后来开启都是它的分支线程；
2.	子线程调用的方法都在子线程中运行。每个线程都拥有自己的栈空间，共用一份堆内存。

1.2匿名内部类实现方式

另外它还有一种很简单的实现方式来实现多线程：

public class Demo1 {
    public static void main(String[] args) {
        new Thread(){//匿名创建一个Thread，继承Thread类
            @Override
            public void run() {
                for (int i = 0; i < 4; i++) {
                    System.out.println("随时"+i);
                }
            }
        }.start();
        for (int i = 0; i < 4; i++) {
            System.out.println("随地" + i);
        }
    }
}

匿名内部类的缺陷就是只能使用一次，优点是简洁快速。

2.Runnable接口

实现Runnable与继承Thread相比，有如下优势：

	1. 通过创建任务，然后给线程分配的方式来实现的多线程。更适合多个线程同时执行相同任务的情况；
	2. 可以避免单线程(除开主线程)所带来的局限性。Java中只能通过创建任务，然后给线程分配的方式来实现的多线程，任务与线程本身是分离的，提高了程序的健壮性；
	3. 后续学习的线程池技术，只接受Runnable接口类型的任务，不接收继承Thread类型的线程。

Runnable是一个接口，也是常用的实现多线程的技术，同样我们得重写它的run()方法。

2.1Runnable接口实现多线程

需要使用到Thread这个类，先实现一个Runnable接口:

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        //重写run()方法
        for (int i = 0; i < 4; i++) {
            System.out.println("Runnable"+i);
        }
    }
}

mian线程

public class Demo1 {
    public static void main(String[] args) {
        //1.    创建一个任务对象
        MyRunnable r = new MyRunnable();
        //2.    创建一个线程，并为其分配一个任务
        //把MyRunnable对象传给Thread,记得查看Thread类的构造方法更进一步的理解记忆
        Thread t = new Thread(r);
        //3.    执行这个任务
        t.start();
        for (int i = 0; i < 4; i++) {//在main线程下执行
            System.out.println("执行main"+i);
        }
    }
}

执行结果

执行main0
Runnable0
执行main1
Runnable1
执行main2
Runnable2
执行main3
Runnable3

当然这里也可以实现匿名内部类来执行。在不加任何的操作的情况下，线程与线程之间执行起来不会进行排队。

3.Callable接口

Callable接口与之前 Runnable/Thread 所理解的线程的用法不一样。Thread和Runnable创建的新线程是一条新的执行路径，不影响主线程，而Callable就像主线程派个它一个任务，它执行完会有一个结果，主线程可以选择/不选择拿到这个结果。使用FutureTask通过Callable创建的线程。

3.1Callable线程的两种实现

1. 	主线程与子线程一起走。不调用FutureTask类的get()方法；
2. 	主线程等待子线程返回一个值后再往下执行。需要调用FutuerTask.get()得到返回结果，此方法会阻塞主进程继续往下执行。

3.2Runnable与Callable接口的定义

//Callable接口
public interface Callable<V>{//泛型
    V call() throws Exception;
}
//Runnable接口
public interface Runnable{
    public abstract void run();
}

二者的相同点

1. 	都是接口
2. 	都可以编写多线程程序
3. 	都采用Thread.start()启动线程

二者的不同点

1. 	Runnable没有返回值，Callable可以返回执行结果
2. 	Callable接口的call()允许抛出异常，Runnable的run()不能抛出

3.3Callable接口的使用方式

1.	编写类实现Callable接口，实现call()方法
	class XXX implements Callable<T>{
		@override
		public <T> call() throws Exception{
			return T;
		}
	}
2.	创建FutureTask对象，并传入第一步编写的Callable类对象
    	FutureTask<V> future = new FutureTask<>(callable);
3.	创建Thread,启动线程
    	new Thread(future).start();

3.4FutureTask类

构造器	描述
FutureTask(Runnable runnable,V result)	创建一个FutureTask，在运行的时候给定Runnable，且get在成功时返结果
FutureTask(Callable callable)	创建一个FutureTask，在运行时执行给定的Callable

FutureTsk常用的方法

变量和类型	方法	描述
V	get()	需要等待计算完成，检索结果
V	get(long timeout,TimeUnit unit)	最多等待计算的时间，后检索结构(如果可用)

3.5Callable创建线程实例

public class Demo10 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> callable = new MyCallabel();
        FutureTask<Integer> task = new FutureTask<>(callable);
        new Thread(task).start();
        //会使得子线程在执行的时候主线程等待它的返回值
        Integer j = task.get();
        System.out.println("返回值："+j);
        for (int i = 0; i < 10; i++) {//主线程执行代码
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
    //实现Callable接口
    static class MyCallabel implements Callable<Integer> {
        @Override
        public Integer call() throws Exception {//重写call()方法
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
            //返回100
            return 100;
        }
    }
}

FutureTask的父类也有许多方法是我们常用的，这里就不一一列举了，提两个

1. 	isDone()：判断线程任务是否执行完毕
2. 	cancel(boolean)：true表示取消get()方法。返回false说明已结束线程取消失败

4.注意

这里就是提醒一点，不要误以为那一种不常用甚至自己一直没用过的Callable类，不能创建线程。Java当中创建线程的方式有三种，它们分别是：实现Runnable接口、继承Thread类和实现Callable接口。

另外，所有的线程都要创建Thread类对象(或依靠匿名内部类启动)，进行启动新的线程。