线程的实现方式

目录

概述

具体实现

方式一: 继承 java.lang.Thread 类（线程子类）

方式二: 实现 java.lang.Runnable 接口（线程执行类）

方式三: 实现 java.util.concurrent.Callable 接口，允许子线程返回结果、抛出异常

方式四: 使用线程池创建

总结 

---

概述

线程的创建方式其实和普通的通过new关键字创建实例对象没有什么区别,只是Thread类的构造方法进行了多次重载,使得在调用构造方法时可以传入不同的参数,来实现不同功能、是否具有返回值等不同的线程对象。

线程的不同创建方式本质就是在调用构造方法时传入不同的参数,来实现创建出的线程对象的不同功能(通过线程池创建除外)。

具体实现

方式一: 继承 java.lang.Thread 类（线程子类）

我们可以直接通过继承Thread类来重写run()方法,实现自己需要的业务逻辑。

// 线程子类
public class MyThread extends Thread{
    public void run(){
        dosth();
    }
}

// 主线程main()
public class AllThread{
    public static void main(String[] args){
        // 创建并启动子线程
        MyThread myThread = new MyThread();
        myThread.start();
    }
}    

方式二: 实现 java.lang.Runnable 接口（线程执行类）

我们可以通过实现Runnable接口,创建一个任务执行类,在创建线程对象时通过构造其实方法的重载传入,就实现了完成不同任务的线程。

个人理解: 实现Runnable接口其实就是编写一个指定任务,然后创建一个线程时将这个任务交给线程去做。

// 线程执行类
public class RunnableThread implements Runnable {
     public void run() {
         for (int i = 0; i < 10000; i++) {
             System.out.println("子线程" + i + " ");
         }
     }
}


// 主线程main
public class AllThread {
     public static void main(String[] args) {
         //创建并启动子线程,将自己编写的RunnableThread对象传入
         Thread t = new Thread(new RunnableThread());
         t.start();
     }
}

方式三: 实现 java.util.concurrent.Callable 接口，允许子线程返回结果、抛出异常

以上两种方法都没有返回值,那么如果我们的业务逻辑中需要获得该线程执行后的结果,那么我们就可以通过实现Callable接口创建线程。

Callable接口支持泛型,所以也就会返回指定类型的执行结果。

但是我们通过它的构造方法列表发现,它的重载方法中并不存在Callable类型的参数,只有Runnable类型的参数: 

其实,想要通过实现Callable接口来创建线程,需要一个中间人来辅助完成这个任务: FutureTask类,这个类支持了使用Runnable或者Callable来创建一个实例。

那么为什么它能起到这个作用呢? 我们通过源码来得出结论: 

FutureTask类实现了RunnableFuture类,而这个类又继承自Runnable类,所以FutureTask间接的实现了Runnable接口,且支持泛型,可以获取返回值。

  下面是案例实现: 

// 实现子线程
public class CallableThread implements Callable<Integer>{
 private int begin,end;
 public CallableThread (int begin,int end){
 this.begin = begin;
 this.end = end;
 }
 @Override
 public Integer call() throws Exception {
 int result = 0;
 for(int i=begin;i<=end;i++){
 result+=i;
 }
 return result;
 }
}

// 子线程封装为FutureTask对象,计算1-100的累加和
CallableThread callableThread1= new CallableThread(1,100);
FutureTask<Integer> task1 = new FutureTask<>(callableThread1);
// 子线程封装为FutureTask对象,计算101-200的累加和
CallableThread callableThread2= new CallableThread(101,200);
FutureTask<Integer> task2 = new FutureTask<>(callableThread2);
// 分别启动两个子线程
new Thread(task1).start();
new Thread(task2).start();
// 分别获取两个子线程的计算结果
int sum1 = task1.get();
int sum2 = task2.get();
// 汇总计算结果
int total = sum1 + sum2;

通过FutureTask对象的get()方法获取线程执行后的结果。 

方式四: 使用线程池创建

线程池，按照配置参数（核心线程数、最大线程数等）创建并管理若干线程对象。程序中如果需要使用线程，将一个执行任务传给线程池，线程池就会使用一个空闲状态的线程来执行这个任务。执行结束以后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个任务。使用线程池可以很好地提高性能。

// 创建固定大小的线程池
ExecutorService threadPool = Executors.newFixedThreadPool(10);
while (true) {
 // 提交多个执行任务至线程池，并执行
 threadPool.execute(new Runnable() {
 @Override
 public void run() {
 System.out.println("当前运行的线程名为： " + Thread.currentThread().getName());
 try {
 Thread.sleep(1000);
 } catch (Exception e) {
 throw new RuntimeException(e);
 }
 }
 });
}

使用线程池对象的execute()方法,传入指定任务Runnable实例对象。但是同样的execute()方法没有返回值。

可以通过线程池对象的submit()方法,传入Callable()接口的实现类对象,该方法的返回值是一个FutureTask对象,用于存放线程执行后的结果,可以通过get()方法得到执行结果。

总结 

1. 线程创建有四种方式: 继承Thread类,实现Runnable接口,实现Callable接口,最后一种通过线程池分配线程,但需要传入Runnable的实现类对象;
2. 线程调度由操作系统决定，程序本身无法决定调度顺序；
3. 将Callable接口的实现类传给FutureTask类对象,再将FutureTask对象传入Thread类的构造方法中;
4. 线程池对象的submit()方法返回一个FutureTask对象,该对象中存放了线程的执行结果。