Java并发-线程池篇-附场景分析

// 容量固定的线程池
Executor fixedThreadPool = Executors.newFixedThreadPool(5);
// 容量动态增减的线程池
Executor cachedThreadPool = Executors.newCachedThreadPool();
// 单个线程的线程池
Executor singleThreadExecutor = Executors.newSingleThreadExecutor();
// 基于调度机制的线程池（不同于上面的线程池，这个池创建的任务不会立马执行，而是定期或者延时执行）
Executor scheduledThreadPool = Executors.newScheduledThreadPool(5);

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {

public class FixedThreadPoolDemo {
    public static void main(String[] args) {
        // 创建一个固定容量为10的线程池，核心线程数和最大线程数都为10
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 1_000_000; i++) {
            try{
                executorService.execute(()->{
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                });
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
    at java.util.concurrent.LinkedBlockingQueue.offer(LinkedBlockingQueue.java:416)
    at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1371)
    at com.jalon.concurrent.chapter6.FixedThreadPoolDemo.main(FixedThreadPoolDemo.java:21)

public class ThreadPoolExecutorDemo {
    public static void main(String[] args) {
        ExecutorService service = new ThreadPoolExecutor(
                1, // 核心线程数
                1, // 最大线程数
                60L, // 空闲时间
                TimeUnit.MILLISECONDS,
                new ArrayBlockingQueue<>(1), // 数组工作队列，长度1
                new ThreadPoolExecutor.DiscardPolicy()); // 拒绝策略：丢弃
        for (int i = 0; i < 1_000_000; i++) {
            // 通过这里的打印信息，我们可以知道循环了3次
            // 原因就是第一次的任务在核心线程中执行，第二次的任务放到了工作队列，第三次的任务被拒绝执行
            System.out.println(i);
            service.execute(()->{
                // 这里会报异常，是因为执行了拒绝策略（达到了最大线程数，队列也满了，此时新进来的任务就会执行拒绝策略）
                // 这里需要注意的是，抛出异常后，代码并不会退出，而是卡在异常这里，包括主线程也会被卡住(这个是默认的拒绝策略）
                // 我们可以用其他的拒绝策略，比如DiscardPolicy,此时代码就会继续往下执行
                System.out.println(Thread.currentThread().getName());
            });
        }
        try {
            Thread.sleep(1000);
            System.out.println("主线程 sleep ");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public interface ExecutorService extends Executor {
​
    void shutdown(); // 优雅地关闭，这个关闭会持续一段时间，以等待已经提交的任务去执行完成（但是在shutdown之后提交的任务会被拒绝）
​
    List<Runnable> shutdownNow(); // 粗暴地关闭，这个关闭会立即关闭所有正在执行的任务，并返回工作队列中等待的任务
​
    boolean isShutdown();
​
    boolean isTerminated();
​
    // 用来等待线程的执行
    // 如果在timeout之内，线程都执行完了，则返回true；
    // 如果等了timeout，还没执行完，则返回false；
    // 如果timeout之内，线程被中断，则抛出中断异常
    boolean awaitTermination(long timeout, TimeUnit unit) 
        throws InterruptedException;
​
    <T> Future<T> submit(Callable<T> task);
   
    <T> Future<T> submit(Runnable task, T result);
}