Java线程的学习_线程池

系统启动一个新线程需要很高的成本，因为它涉及与操作系统交互。在这种情况下，使用线程池可以很好地提高性能，尤其是当程序中需要创建大量生存期很短暂的线程时。

线程池在系统启动时即创建大量空闲的线程，程序将一个Runnable对象或Callable对象传给线程池，线程池就会启动一个线程来run()或call()方法，当run()或call()方法执行结束后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个Runnable对象的run()或call()方法。除此之外，使用线程池可以有效地控制系统中并发线程的数量。

使用Executors类来创建线程池：

方法名
newCachedThreadPool()	创建一个具有缓存功能的线程池，系统根据需要创建线程，这些线程将会被缓存在线程池中
newFixedThreadPool(int nThreads)	创建一个可重用的、具有固定线程数的线程池
newSingleThreadExecutor()	创建一个只有单线程的线程池，它相当与调用newFixedThreadPool()方法时传入参数为1
newScheduledThreadPool(int corePoolSize)	创建具有指定线程数的线程池，它可以在指定延迟后执行线程任务。corePoolSize指池中所保存的线程数，即使线程是空闲的也被保存在线程池内。
newSingleThreadScheduledExecutor()	创建只有一个线程的线程池，它可以在指定延迟后执行线程任务
ExecutorService newWorkStealingPool(int parallelism)	创建持有足够的线程的线程池来支持给定的并行级别，该方法还会使用多个队列来减少竞争
ExecutorService newWorkStealingPool()	该方法是前一个方法的 简化版本，如果当前机器有4个CPU，则目标并行级别被设置为4，也就是相当于为前一个方法传入4作为参数。

使用线程池来执行线程任务的步骤：
1.调用Executors类的静态工厂方法创建一个ExecutorService对象，该对象代表一个线程池。
2.创建Runnable实现类或Callable实现类的实例，作为线程执行任务。
3.调用ExecutorService对象的submit()方法来提交Runnable实例或Callable实例。
4.当不想提交任何任务时，调用ExecutorService对象的shutdown()方法来关闭线程池。

使用线程池来执行指定Runnable对象所代表的的任务：

public class ThreadPoolTest {

    public static void main(String[] args)throws Exception{
        //创建一个具有固定线程数（6）的线程池
        ExecutorService pool = Executors.newFixedThreadPool(6);
        //使用Lambda表达式创建Runnable对象
        Runnable target = () -> {
            for(int i = 0; i < 100; i++){
                System.out.println(Thread.currentThread().getName() + "的i值为：" + i);
            }
        };
        //向线程池中提交两个线程
        pool.submit(target);
        pool.submit(target);
        //关闭线程池
        pool.shutdown();
    }
}

---

ForkJoinPool类

ForkJoinPool类的作用是将一个任务拆分为多个“小任务”并行计算，再把多个“小任务”的结果合并成总的计算结果。ForkJoinPool类是ExecutorService的实现类，因此是一种特殊的线程池。

方法
ForkJoinPool(int parallelism)	创建一个包含parallelism个并行线程的ForkJoinPool
ForkJoinPool()	以runtime.availableprocessors（处理器数量）返回值为parallelism参数来创建ForkJoinPool。
ForkJoinPool commonPool()	该方法返回一个通用池，通用池的运行状态不回受shutdown()或shutdownNow()方法的影响。
int getCommonPoolParallelism()	返回通用池的并行级别

创建了ForkJoinPool实例之后，就可调用ForkJoinPool的submit（ForkJoinTask task）或invoke（ForkJoinTask task）方法来执行指定任务。其中ForkJoinTask代表一个可以并行、合并的任务。ForkJoinTask是一个抽象类，它还有两个抽象子类：RecursiveAction（没有返回值）和RecursiveTask（有返回值）。

没有返回值的“大任务”拆分：

//继承RecursiveAction来实现“可分解”的任务
class PrintTask extends RecursiveAction{
    //每个“小任务”最多打印50个数
    private static final int THRESHOLD = 50;
    private int start;
    private int end;
    //打印从start到end的任务
    public PrintTask(int start, int end){
        this.start = start;
        this.end = end;
    }
    @Override
    protected void compute() {
        // 当end与start之间的差小于THRESHOLD时，开始打印
        if(end - start < THRESHOLD){
            for(int i = 0; i < end; i++){
                System.out.println(Thread.currentThread().getName() + "的i值：" + i);
            }
        }else{
            //当end与start之间的差大于THRESHOLD时，开始打印
            //将大任务分解成两个“小任务”
            int middle = (start + end) / 2;
            PrintTask left = new PrintTask(start, middle);
            PrintTask right = new PrintTask(middle, end);
            //并执行两个“小任务”
            left.fork();
            right.fork();
        }

    }
}
public class ForkJoinPoolTest {

    public static void main(String[] args)throws Exception{

        ForkJoinPool pool = new ForkJoinPool();
        //提交可分解的PrintTask任务
        pool.submit(new PrintTask(0, 300));
        pool.awaitTermination(2, TimeUnit.SECONDS);
        //关闭线程池
        pool.shutdown();
    }
}

有返回值的“大任务”：

//继承RecursiveTask来实现“可分解”的任务
class CalTask extends RecursiveTask<Integer>{

    //每个“小任务”最多只累加20个数
    private static final int THRESHOLD = 20;
    private int arr[];
    private int start;
    private int end;
    //累加从start到end数组
    public CalTask(int[] arr, int start, int end){
        this.arr = arr;
        this.start = start;
        this.end = end;
    }
    @Override
    protected Integer compute() {
        int sum = 0;
        // 当end与start之间的差小于THRESHOLD时，开始进行实际累加
        if(end - start < THRESHOLD){
            for(int i = start; i < end; i++){
                sum += arr[i];
            }
            return sum;
        }else{
            //当end与start之间的差大于THRESHOLD，既要累加的数超过20个时，将大任务分解成两个小任务
            int middle = (start + end) / 2;
            CalTask left = new CalTask(arr, start, middle);
            CalTask right = new CalTask(arr, middle, end);
            //并执行两个小任务
            left.fork();
            right.fork();
            //把两个小任务累加的结果合并起来
            return left.join() + right.join();
        }
    }

}
public class Sum {

    public static void main(String[] args)throws Exception{
        int[] arr = new int[100];
        Random rand = new Random();
        int total = 0;
        //初始化100个数字元素
        for(int i = 0, len = arr.length; i < len; i++){
            int tmp = rand.nextInt(20);
            //对数组元素赋值，并将数组元素的值添加到sum总和中
            System.out.println(tmp);
            total += (arr[i] = tmp);
        }
        System.out.println("初始化统计出的和：" + total);
        //创建一个通用池
        ForkJoinPool pool = ForkJoinPool.commonPool();
        //提交可分解的CaltTask任务
        Future<Integer> future = pool.submit(new CalTask(arr, 0, arr.length));
        System.out.println("使用CalTask计算出的和：" + future.get());
        //关闭线程
        pool.shutdown();
    }
}