Java—线程池

线程池的作用：只启动固定数量的线程，防止并发时产生过多的线程影响性能，线程不够时，其他线程需要进行等待线程池的线程释放才可以使用

一、线程池处理Runnable任务

import java.util.concurrent.*;

public class Test {
    public static void main(String[] args) {
        /**参数说明 ,临时线程是在核心线程忙碌且队列满时启用，线程异常抛出是，核心线程+临时线程+队列满了时，抛出
         * int corePoolSize,核心线程，不会主动关闭
         * int maximumPoolSize, 最大线程，==核心线程+临时线程
         * long keepAliveTime,临时线程为空闲时间
         * TimeUnit unit,临时时间单位
         * BlockingQueue<Runnable> workQueue, 队列个数
         * ThreadFactory threadFactory,工厂方法，默认使用
         * RejectedExecutionHandler handler，线程不足时，新的线程进来抛异常
         */
        ExecutorService pool = new ThreadPoolExecutor(3, 5, 6, TimeUnit.SECONDS,
                                                    new ArrayBlockingQueue<>(5),
                                                    Executors.defaultThreadFactory(),
                                                    new ThreadPoolExecutor.AbortPolicy());
        Myrunnable taget = new Myrunnable();
        pool.execute(taget);
        pool.execute(taget);
        pool.execute(taget);
        pool.execute(taget);
        pool.execute(taget);
        pool.execute(taget);
        pool.execute(taget);
        pool.execute(taget);
        //创建临时线程
        pool.execute(taget);
        pool.execute(taget);
        //已达到最高线程和队列数量，线程抛出
        pool.execute(taget);

    }
}

class Myrunnable implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "输出" + i);
        }
        try {
            Thread.sleep(50000);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

二、线程池处理Callable任务，与Runnable任务类似

package com.ruqi.poolsdemo;

import java.util.concurrent.*;

public class Test {
    public static void main(String[] args) throws Exception{

        ExecutorService pool = new ThreadPoolExecutor(3, 5, 6, TimeUnit.SECONDS,
                                                    new ArrayBlockingQueue<>(5),
                                                    Executors.defaultThreadFactory(),
                                                    new ThreadPoolExecutor.AbortPolicy());

        Future<String> f = pool.submit(new MyCallable(50)); //提交任务返回的Future对象，可以通过调用get方法拿到call方法的值
        System.out.println(f.get());

    }
}

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

    public MyCallable(){}

    public MyCallable(int n){
        this.n = n;
    }
    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 0; i < n; i++) {
            sum += n;
        }
        return Thread.currentThread().getName() + "计算结果" + sum;
    }
}

 三、Excutors创建线程池，不适合大型应用

 

public class Test {
    public static void main(String[] args) throws Exception{

        ExecutorService pool = Executors.newFixedThreadPool(10);
        Future<String> f = pool.submit(new MyCallable(50)); 
        System.out.println(f.get());

    }
}

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

    public MyCallable(){}

    public MyCallable(int n){
        this.n = n;
    }
    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 0; i < n; i++) {
            sum += n;
        }
        return Thread.currentThread().getName() + "计算结果" + sum;
    }
}