04-10 线程池(一)

class MyTask implements Runnable {
    int i = 0;
    public MyTask(int i) {
        this.i = i;
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "程序员做第" + i + "个项目");
        try {
            Thread.sleep(3000L);//业务逻辑
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

//corePoolSize：核心线程
//maximumPoolSize：线程池中最多的线程数
//keepAliveTime：表示空闲线程的存活时间（非核心线程）
//unit：keepAliveTime的单位
//workQueue：任务队列
public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }

newCachedThreadPool

ExecutorService executorService1 = Executors.newCachedThreadPool();
 for (int i = 1; i <= 100; i++) {
            executorService1.execute(new MyTask(i));
        }

//corePoolSize=0，线程池最大数量是int的maxVal
//所以在创建任务的时候，会每个任务都创建一个线程去执行
//这里的任务队列是SynchronousQueue，SynchronousQueue不存储元素
//SynchronousQueue插入的每个任务必须等到另一个线程调用才会移除
public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
}

newFixedThreadPool

ExecutorService executorService2 = Executors.newFixedThreadPool(10);
        for (int i = 1; i <= 100; i++) {
            executorService2.execute(new MyTask(i));
        }

//这里的核心线程数和最大线程数都是一样的，都是我们的传参10。
//也就是同时最多有10个线程去执行任务，超过10个的时候，把任务放在工作队列里面
//这里的工作队列是LinkedBlockingQueue无界队列
public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

newSingleThreadExecutor

ExecutorService executorService3 = Executors.newSingleThreadExecutor();
        for (int i = 1; i <= 100; i++) {
            executorService3.execute(new MyTask(i));
        }

//这里的核心线程数和最大线程数都是1
//也就是说同时只能有一个线程在执行
//超过1个任务都会放在队列LinkedBlockingQueue里面
public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

�

自定义线程池

//设置了核心线程数是10，最大线程数20
//在执行下面代码的时候，会在第31个任务出现异常
//因为最多可执行的线数是20，队列最多存放的任务是10个，所以在超过30个任务的时候会出错(拒绝策略)
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 20,
                0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(10));//自定义线程
        for (int i = 1; i <= 100; i++) {
            threadPoolExecutor.execute(new MyTask(i));
        }

�