线程生命周期

image.png

线程池

线程池 - 一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。

线程池的作用：主要用于解决线程生命周期开销问题和资源不足问题。

线程池的创建：通常，线程池都是通过线程池工程创建，再调用线程池中的方法获取线程，再通过线程去执行任务方法。
**

利用Runnable接口向线程池提交任务

  • Executors：线程池创建工厂类
    • public static ExecutorService newFixedThreadPool(int nThreads)：返回线程池对象
  • ExecutorService：线程池类
    • Future<?> submit(Runnable task)：获取线程池中某一个线程对象，并执行
    • Future接口：用来记录线程任务执行完毕后产生的结果。


ExecutorService：线程池类
线程池赋值线程的生命周期，我们只需要向线程提交执行目标，线程池就会自动分配线程，执行对应的操作。
1.定义线程执行目标
2.向线程池提交线程
Future<?> submit(Runnable task):接收一个Runnable，执行该线程执行目标**

使用线程池中线程对象的步骤（线程池创建与使用）：

  1. 创建线程池对象
  2. 创建Runnable接口实现类对象
  3. 提交Runnable接口实现类对象
  4. 关闭线程池 ```java package threadPoolDemo;

public class Ticket implements Runnable { //定义票数 private int number = 100; @Override public void run() { //车站不停地在卖票 while(true){ //有票就买票 if(number>0){ System.out.println(Thread.currentThread().getName()+”正在销售第”+(number—)+”张票”); }else{ //没有票，就跳出循环，不再卖票 break; } } } }

  1. ```java
  2. package threadPoolDemo;
  4. import java.util.concurrent.ExecutorService;
  5. import java.util.concurrent.Executors;
  7. public class ThreadPoolDemo {
  8.     public static void main(String[] args) {
  9.         //返回一个线程池
  10.         ExecutorService threadPool = Executors.newFixedThreadPool(3);
  11.         //创建线程执行目标
  12.         Ticket ticket = new Ticket();
  13.         //向线程池提交任务
  14.         threadPool.submit(ticket);
  15.         threadPool.submit(ticket);
  16.         threadPool.submit(ticket);
  17.         threadPool.submit(ticket);
  18.         threadPool.submit(ticket);
  19.         //可以在适当的时候关闭线程池
  20.         //threadPool.shutdown();
  21.     }
  22. }

利用Callable接口向线程池提交任务

Callable接口：与Runnable接口功能相似，用来指定线程的任务。其中的call()方法，用来返回线程任务执行完毕后的结果，call方法可以抛出异常。

ExecutorService：线程池类
 Future submit(Callable task)：
 获取线程池中的某一个线程对象，并执行线程中的call()方法
 Future接口：用来记录线程任务执行完毕后产生的结果。

使用线程池中线程对象的步骤（线程池创建与使用）：

  • 创建线程池对象
  • 创建Callable接口实现类对象
  • 提交Callable接口实现类对象
  • 关闭线程池 ```java package threadPoolDemo;

import java.util.concurrent.Callable;

public class MyCallable implements Callable { @Override public String call() throws Exception { return “我是线程任务的返回结果”; } }

```java
package threadPoolDemo;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ThreadPoolDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //返回一个线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(3);
        //创建线程执行目标
        Ticket ticket = new Ticket();
        //向线程池提交任务
        threadPool.submit(ticket);
        threadPool.submit(ticket);
        threadPool.submit(ticket);
        threadPool.submit(ticket);
        threadPool.submit(ticket);

        //对应后边Callable的返回值Future，没有返回值的run方法，返回值是null，没有意义，不会这样使用
        Future<?> ticketFuture = threadPool.submit(ticket);
        System.out.println(ticketFuture.get());

        //创建带返回值的线程执行目标
        MyCallable callable = new MyCallable();
        //向线程池提交任务，并返回线程执行目标的结果
        Future<String> future = threadPool.submit(callable);
        //从执行结果中返回call的具体返回值
        String result = future.get();
        System.out.println(result);

        //可以在适当的时候关闭线程池
        //threadPool.shutdown();
    }
}