0041 Java学习笔记-多线程-线程池、ForkJoinPool、ThreadLocal-白红宇

0041 Java学习笔记-多线程-线程池、ForkJoinPool、ThreadLocal

阅读量：4338 次

发布时间：2019-06-07

本文共 5765 字，大约阅读时间需要 19 分钟。

什么是线程池

创建线程，因为涉及到跟操作系统交互，比较耗费资源。如果要创建大量的线程，而每个线程的生存期又很短，这时候就应该使用线程池了，就像数据库的连接池一样，预先开启一定数量的线程，有任务了就将任务传递进去，任务执行完毕不终止线程，等待下一个任务

线程池的种类

ExecutorService：
- 这是个接口，代表尽快执行的线程池，只要有空闲进程，就立即执行
- Future<?> submit(Runnable task)
  - 将Runnable对象提交给线程池，线程池有空闲线程时执行任务，返回的Future对象，因为run()没有返回值，因此实际是null，但可以调用isDone()和isCancelled()方法
- <T> Future <T> submit(Runnable task,T result)
  - result是线程执行结束后的返回值
- <T> Future <T> submit(Callable<T> task)
  - Future代表Callable的call()方法的返回值
- void shutdown()
  - 不再接收新任务，已接收的任务执行完成，然后关闭线程池
- List<Runnable> shutdownNow()
  - 停止所有线程任务，并返回等待处理的任务列表
- boolean isShutdown()
- boolean isTerminated()
  - shutdown()之后，所有任务都执行完毕，则返回true

ScheduledExecutorService
- 这也是个接口，代表在指定延迟或者周期性的执行任务的线程池
- ScheduledFuture<V> schedule(Callable<V> callable,long delay,TimeUnit unit)
  - Callable任务在delay后执行
- ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit)
  - Runnable任务在delay后执行
- ScheduledFuture<?> scheduleAtFixedTate(Runnable command, long initialDelay, long period, TimeUnit unit)
  - 在delay延迟后开始执行，之后周期性(period)执行
  - 这里的周期是从上一个任务的开始时间开始计算
  - 比如：第一次执行任务在1秒处，执行了3秒，第4秒结束，如果设置的period是5秒，那就在第6秒第二次执行该任务
  - TimeUnit是个枚举类：可以是天、小时、分钟、秒、毫秒、毫微秒
- ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)
  - initialDelay后开始执行，执行完毕后，间隔delay后再次执行
  - 执行中遇到异常，会终止执行，否则会一直执行，应设立条件终止任务
  - 跟上一个方法不同的是，这个方法，第二个周期执行的起算点是第一个周期结束时间点

创建线程池

通过Executors的静态工厂方法创建线程池

创建ExecutorService线程池
- newCachedThreadPool()
  - 具有缓存功能的线程池，系统根据需要创建线程，缓存与线程池中
- newFixedThreadPool(int nThreads)
  - 可重用的、具有固定线程数的线程池
- newSingleThreadExecutor()
  - 单线程的线程池
- newWorkStealingPool(int parallelism)
  - 创建以讹持有足够线程的线程池来支持给定的并行级别，并且使用多个队列来减少竞争
- newWorkStealingPool()
  - 这个方法是上个方法的简化版，将cpu个数传给上一个方法就是下面这个方法

创建ScheduledExecutorService线程池
- newScheduledThreadPool(int corePoolSize)
  - corePoolSize是线程数目
- newSingleThreadScheduledExecutor()
  - 只有一个线程

示例一：

package testpack;import java.util.Date;import java.util.concurrent.Executors;import java.util.concurrent.ScheduledExecutorService;import java.util.concurrent.TimeUnit;public class Test2  {     public static void main(String[] args) throws InterruptedException{         Runnable task=()->{                        //创建一个线程任务            for (int i=0;i<1;i++) {                System.out.println(new Date());                try{                    Thread.sleep(3000);                }catch(InterruptedException ex){                    ex.printStackTrace();                }                System.out.println(new Date());            }        };        ScheduledExecutorService ses=Executors.newScheduledThreadPool(1);  //创建一个单线程延迟处理处理线程池，        ses.scheduleAtFixedRate(task,1,5,TimeUnit.SECONDS);     //标记㈠。延迟1秒开始处理，从开始处理的时间点开始算，5秒后执行第二个周期    }}

输出：

Fri Dec 09 16:22:07 CST 2016 //07秒开始处理
Fri Dec 09 16:22:10 CST 2016 //run中暂停3秒
Fri Dec 09 16:22:12 CST 2016 //07+5秒开始第二个周期
Fri Dec 09 16:22:15 CST 2016 //run中暂停3秒
Fri Dec 09 16:22:17 CST 2016 //07+5+5开始第三个周期

示例二：将上面标记㈠的方法改为：scheduleWithFixedDelay，输出如下：

Fri Dec 09 16:28:35 CST 2016 //35秒开始处理
Fri Dec 09 16:28:38 CST 2016 //run中暂停3秒
Fri Dec 09 16:28:43 CST 2016 //38+5秒开始第二个周期
Fri Dec 09 16:28:46 CST 2016 //run中暂停3秒
Fri Dec 09 16:28:51 CST 2016 //46+5秒开始第三个周期

ForkJoinPool

ForkJoinPool与多CPU、多核CPU计算有关

是ExecutorService的实现类，也是一种线程池

配合ForkJoinTask完成对一个大任务进行递归拆解成多个小任务并行计算

构造器与方法：
- ForkJoinPool(int parallelism)
  - 创建一个包含指定个数并行线程的线程池
- ForkJoinPool()
  - 创建一个Runtime.availableProcessors()返回值个数的并行线程的线程池
- static ForkJoinPool commenPool()
  - 返回一个通用线程池，其运行状态不受shutdown()和shutdownNow()的影响，除非调用System.exit()退出虚拟机
- static int getCommenPoolparallelism()
  - 返回通用池的并行级别
- submit(ForkJoinTask task)
  - 执行指定任务
- invoke(ForkJoinTask task)

ForkJoinTask
- 这是个抽象类，有RecursiveAction()和RecursiveTask()两个抽象子类，前者无返回值，后者有返回值
- 创建这两类任务时，要继承这两个类，然后重写compute()方法

进一步参考：
- 《Java并发编程的艺术》第6.4节
- 《Java 7 并发编程实战手册》第5章

示例：

package testpack;import java.util.concurrent.ForkJoinPool;import java.util.concurrent.RecursiveAction;import java.util.concurrent.TimeUnit;public class Test2  {     public static void main(String[] args) throws InterruptedException{         ForkJoinPool pool=new ForkJoinPool();        pool.submit(new Task(0,327));        pool.awaitTermination(2,TimeUnit.SECONDS);        pool.shutdown();    }}class Task extends RecursiveAction{    private static final int THRESHOLD=50;    private int start;    private int end;    public Task(int start,int end){        this.start=start;        this.end=end;    }    protected void compute(){        if (end-start

ThreadLocal类

ThreadLocal可以把一个多个线程一起操作的变量包装成一个局部变量，每个线程都拥有一个该变量的副本，各线程对该变量的操作互补影响

只有如下三个方法：
- void set(T value)
- T get();
- void remove()

各个线程的该局部变量的初始值是null

示例

package testpack;public class Test1  {     public static void main(String[] args){         Account a=new Account("初始名字");        new MyThread(a).start();        new MyThread(a).start();    }}class MyThread extends Thread{    private Account account;    public MyThread(Account account){        this.account=account;    }    public void run(){        for (int i=0;i<5;i++) {            if (i==3){                account.setName(Thread.currentThread().getName());            }            System.out.println("线程名称："+getName()+" ，账户名："+account.getName()+" 输出："+i);        }    }}class Account {    private ThreadLocal
    
      name=new ThreadLocal<>();    public Account(String str){        this.name.set(str);        System.out.println("构造时的账户名："+this.name.get());    }    public String getName(){        return name.get();    }    public void setName(String str){        this.name.set(str);    }}

输出：

构造时的账户名：初始名字
线程名称：Thread-0 ，账户名：null 输出：0
线程名称：Thread-1 ，账户名：null 输出：0
线程名称：Thread-0 ，账户名：null 输出：1
线程名称：Thread-1 ，账户名：null 输出：1
线程名称：Thread-0 ，账户名：null 输出：2
线程名称：Thread-1 ，账户名：null 输出：2 //初始值为null
线程名称：Thread-0 ，账户名：Thread-0 输出：3
线程名称：Thread-0 ，账户名：Thread-0 输出：4
线程名称：Thread-1 ，账户名：Thread-1 输出：3
线程名称：Thread-1 ，账户名：Thread-1 输出：4