线程池了解-Executors工具类

什么是线程池

如何创建线程池

    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3, 5, 8,
                TimeUnit.SECONDS, new ArrayBlockingQueue<>(4),
                Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());

    }

线程池处理Runnable任务

MyRunnable.java

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() +"---输出666");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class ThreadPoolTest1 {
    public static void main(String[] args) {
        //1.通过ThreadPoolExecutor创建一个线程池对象
        ExecutorService pool = new ThreadPoolExecutor(3, 5, 8,
                TimeUnit.SECONDS, new ArrayBlockingQueue<>(4),
                Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());

        Runnable target = new MyRunnable();

        pool.execute(target);//线程池会自动创建一个新线程，自动处理这个任务，自动执行！
        pool.execute(target);//线程池会自动创建一个新线程，自动处理这个任务，自动执行！
        pool.execute(target);//线程池会自动创建一个新线程，自动处理这个任务，自动执行！
        pool.execute(target);//复用前面的核心线程
        pool.execute(target);//复用前面的核心线程

    }
}

输出结果：

pool-1-thread-3—输出666
pool-1-thread-2—输出666
pool-1-thread-1—输出666
pool-1-thread-1—输出666
pool-1-thread-2—输出666

临时线程的创建时机

核心线程在忙，任务队列占满了，然后再出现新任务的时候，就会创建临时线程
将代码修改，睡眠时间加长。

        try {
            Thread.sleep(Integer.MAX_VALUE);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        pool.execute(target);//线程池会自动创建一个新线程，自动处理这个任务，自动执行！
        pool.execute(target);//线程池会自动创建一个新线程，自动处理这个任务，自动执行！
        pool.execute(target);//线程池会自动创建一个新线程，自动处理这个任务，自动执行！
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
        //到了临时线程的创建时机
        pool.execute(target);
        pool.execute(target);

输出结果：

pool-1-thread-2—输出666
pool-1-thread-3—输出666
pool-1-thread-1—输出666
pool-1-thread-5—输出666
pool-1-thread-4—输出666

线程池处理Callable任务

public class ThreadPoolTest2 {
    public static void main(String[] args) throws Exception {
        //1.通过ThreadPoolExecutor创建一个线程池对象
        ExecutorService pool = new ThreadPoolExecutor(3, 5, 8,
                TimeUnit.SECONDS, new ArrayBlockingQueue<>(4),
                Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());

        //2.使用线程处理Callable任务
        Future<String> f1 = pool.submit(new MyCallable(100));
        Future<String> f2 = pool.submit(new MyCallable(200));
        Future<String> f3 = pool.submit(new MyCallable(300));
        Future<String> f4 = pool.submit(new MyCallable(400));

        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());

    }

MyCallable.java

public class MyCallable implements Callable<String> {
    private int n;

    public MyCallable(int n) {
        this.n = n;
    }
    //2.重写call方法
    @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;
    }
}

输出结果：

pool-1-thread-1求出了1-100的和是:4950
pool-1-thread-2求出了1-200的和是:19900
pool-1-thread-3求出了1-300的和是:44850
pool-1-thread-3求出了1-400的和是:79800

Executors工具类

        ExecutorService pool1 = Executors.newFixedThreadPool(3);

      ExecutorService pool2 = Executors.newSingleThreadExecutor();