JUC包多线程之线程池的创建与使用

一，线程池：提供了一个线程队列，队列中保存着所有等待状态的线程，避免了创建与销毁额外的开销，提高了响应速度。

二，线程池的体系结构

java.util.concurrent.Exector：负责线程的使用与调度的根接口

　　|-- ExecutorService 为Exector子接口：线程池等的主要接口

　　　|-- ThreadPoolExecutor 线程池的实现类

　　　|-- ScheduledExecutorService 为ExecutorService的子接口：负责线程的调度

　　　　|-- ScheduledThreadPoolExecutor：继承ThreadPoolExecutor和实现了ScheduledExecutorService接口

三，工具类：Executors

　　　1.ExecutorService pool = Executors.newFixedThreadPool(5);创建了含有5个线程的线程池

　　　2.ExecutorService pool = Executors.newCachedThreadExecutor();创建了缓存线程池，线程数量不固定

　　　3.ExecutorService pool = Executors.newSingleThreadExecutor();创建了含有单个线程的线程池

　　　3.ScheduledExecutorService pool = Executors.newScheduledThreadPool();创建固定大小的线程池，可以延迟或者定时的执行任务

代码例子：

package xianchengtest;


import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class TestThreadPool {

    public static void main(String[] args) throws Exception {
        //1.创建线程池
        ExecutorService pool = Executors.newFixedThreadPool(5);
        //创建一个list集合用于回收结果
        List<Future<Integer>> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            Future<Integer> future = pool.submit(new Callable<Integer>(){
                
                @Override
                public Integer call() throws Exception {
                    int sum = 0;
                    for (int i = 0; i <= 100; i++) {
                        sum += i ;
                    }
                    return sum;
                }
            });
            list.add(future);//加入回收结果
        }
        //关闭线程池
        pool.shutdown();
        
        for (Future<Integer> future : list) {
            System.out.println(future.get());
        }

        //另外一种使用线程池的方法
//        ThreadPoolDemo th = new ThreadPoolDemo();
//        //2.为线程池中的线程分配任务
//        for (int i = 0; i < 10; i++) {
//            pool.submit(th);
//        }
//        //3.关闭线程池
//        pool.shutdown();
    }
//以前的启动线程的方法，要一个个的启动
//    new Thread(th).start();
//    new Thread(th).start();
}
class ThreadPoolDemo implements Runnable{
    private int i = 0;

    @Override
    public void run() {
        while(i<=100) {
            System.out.println(Thread.currentThread().getName() + " : "+ i++);
        }
    }
    
}

带延时执行的线程池代码例子：

package xianchengtest;

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class TestScheduledThreadPool {

    public static void main(String[] args) throws Exception {
        //1.创建线程池
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(5);
        //2.分配任务

        for (int i = 0; i < 10; i++) {
            Future<Integer> future = pool.schedule(new Callable<Integer>() {

                @Override
                public Integer call() throws Exception {
                    int num = new Random().nextInt(100);
                    System.out.println(Thread.currentThread().getName() + " : "+ num);
                    return num;
                }
            },1,TimeUnit.SECONDS);
            System.out.println(future.get());
        }
        //3.关闭线程池
        pool.shutdown();
        
    }

}