线程池基础讲解

线程池基本了解

        池化思想（一般是对对象的池化）：线程池、字符串常量池、数据库连接池

        池化思想的优点：提高资源的利用率

        在没有线程池的时候：

1. 来了一个任务，手动创建线程对象；
2. 执行任务；
3. 执行完毕，释放线程对象；

         使用线程池之后，线程可以重复利用。线程池初始化，里面放几个线程，每当有任务到来，则从线程池中拿走一个线程，任务执行结束之后，在把线程归还线程池。

        线程池的优点：

• 提高资源（线程对象）的利用率；
• 提高程序的响应速度；
• 便于统一管理线程对象；
• 可以控制最大并发数（通过设置线程池的参数）；

线程池的基本原理

•         首先会预先创建一定数量的线程对象（工作线程，WorkThread）放入到线程池里面，初始化等待队列（任务队列，WorkQueue）。当任务来临时，从线程池里面获取线程执行任务，执行结束后把线程归还线程池。
•          如果来的任务数量太多，而线程池中没有空闲线程的话，则多于任务进入等待队列排队等待执行。
•         如果同时来很多任务，等待队列也已经满了，线程池发现并发任务太多了，则线程池启动应急处理预案，创建新的线程对象，执行等待队列中的任务。
•         但是线程池有容量上限（有最大线程数），不会无限制的创建线程对象，当等待队列已经满了，线程池中也没有空闲线程对象，线程池容量也已经达到上限了，此时又有新任务来临，则采取拒绝策略，拒绝任务（抛出异常、或让其他线程池处理）。
• 线程存活时间：如果某些线程在一定时间内没有执行任务，则线程池会销毁这些线程。

创建线程池基本参数

corPoolSize: 核心线程数量，线程池初始化时创建的线程对象
maximumPoolSize: 线程池最大容纳的线程数量
keepAliveTime: 临时线程存活时间（1L）（结合unit，表示1秒钟）
unit: 临时线程存活时间单位，TimeUnit.SECONDS（秒）
workQueue: 等待队列，new ArrayBlockingQueue<>(3), 
threadFactory: 线程工厂，Executors.defaultThreadFactory(),
handler: 拒绝策略，new ThreadPoolExecutor.AbortPolicy())是抛出异常。


1、使用线程池处理Runnable任务

public class MyThreadPool {
    public static void main(String[] args) {
        ExecutorService  es = new ThreadPoolExecutor(
                3,
                5,
                1L,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(3),
                Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());

//1、处理Runnable任务，没有返回值        
for (int i = 0; i < 6; i++) {
            es.execute(()->{
                System.out.println(Thread.currentThread().getName()+"--->在执行任务");
            });
        }
        es.shutdown();
    }
}

        上述示例代码，线程池中有3个核心线程，线程池的上限是5个线程对象，最多可以同时处理8个任务，当处理任务数多余8时候，则采取拒绝策略，抛出异常。

2、使用线程池处理Callable任务

import java.util.concurrent.*;

/**
 * @Description
 * @Author 
 * @Date
 */
public class MyThreadPool {
    public static void main(String[] args) throws Exception {

        //corePoolSize: 核心线程数量
        //maximumPoolSize：线程池的最大线程容量
        //keepAliveTime：临时线程的存活时间
        //unit：临时线程的存活时间单位（秒，分，时，天）
        //workQueue：线程池的任务队列
        //threadFactory：线程池的线程工厂
        //handler：线程池的任务拒绝策略

        //2、处理Callable任务，有返回值
        ExecutorService es2 = new ThreadPoolExecutor(
                2,
                3,
                8L,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(2),//任务队列最多只可以放3个队列
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.CallerRunsPolicy());

        Future<String> f1 = es2.submit(new MyCallable(10));
        System.out.println(f1.get());

        Future<String> f2 = es2.submit(new MyCallable(20));
        System.out.println(f2.get());

        Future<String> f3 = es2.submit(new MyCallable(30));
        System.out.println(f3.get());

        Future<String> f4 = es2.submit(new MyCallable(40));
        System.out.println(f4.get());

        es2.shutdown();
    }
}

import java.util.concurrent.Callable;

/**
 * @Description
 * @Author 
 * @Date 
 */
public class MyCallable implements Callable<String > {

    int n;

    public MyCallable(int n) {
        this.n = n;
    }

    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum+=i;
        }
        return Thread.currentThread().getName()+"计算出1-"+n+"的和"+sum;
    }
}

        

其余拒绝策略