线程池的使用

创建多线程时，不仅会消耗系统资源，还会降低系统的稳定性，例如占用过多的系统资源导致OOM；

因此我们要合理利用线程池

好处：

• 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。

• 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。

• 提高线程的可管理性。线程是稀缺资源，使用线程池可以进行统一的分配、调优和监控。

缺点：

线程池是构建多线程应用程序的强大机制，但使用它并不是没有风险的。 用线程池构建的应用程序容易遭受任何其它多线程应用程序容易遭受的所有并发风险，诸如同步错误和死锁，它还容易遭受特定于线程池的少数其它风险，诸如与池有关的死锁、资源不足和线程泄漏。

以下为线程池的创建

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class test_ThreadPoolExecutor {

    public static void main(String[] args) {
        /*核心线程池的大小*/
        int corePoolSize=2;
        /*核心线程池的最大线程数*/
        int maxPoolSize=4;
        /*线程最大空闲时间*/
        long keepAliveTime=10;
        /*时间单位*/
        TimeUnit unit= TimeUnit.SECONDS; //enum枚举 。常量
        /*阻塞队列 容量为2 最多允许放入两个空闲任务*/
        BlockingQueue<Runnable> workQueue= new ArrayBlockingQueue<Runnable>(2);
        /* 线程创建工厂*/
        ThreadFactory threadFactory=new NameTreadFactory();
        /*线程池拒绝策略*/
        RejectedExecutionHandler hander =new MyIgnorePolicy();

        ThreadPoolExecutor executor=null;//ThreadPoolExecutor:线程池执行者
        try {
            /*推介的创建线程池的方式*/
            /* 不推介使用现成的API船舰线程池*/
            executor = new ThreadPoolExecutor(corePoolSize, maxPoolSize, keepAliveTime, unit, workQueue, threadFactory, hander);
            executor.prestartAllCoreThreads();//准备好核心的线程
            //任务数量
            int count = 10;
            for (int i = 1; i <= count; i++) {
                RunnableTask task = new RunnableTask(String.valueOf(i));
                executor.submit(task);//提交任务到线程池  ：结果：还有4个任务无法执行
            }
        }catch(Exception e){
            e.printStackTrace();
            executor.shutdown();//有异常则关闭线程池
        }



    }

    static class RunnableTask implements Runnable{
        private String name;
        public RunnableTask(String name){
            this.name=name;
        }

        @Override
        public String toString() {
            return "RunnableTask{" +
                    "name='" + name + '\'' +
                    '}';
        }

        @Override
        public void run() {
            System.out.println(this.toString()+" is running");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    /**
     * 线程工厂
     */
    static class NameTreadFactory implements ThreadFactory{
        /*线程id AtomicInteger 原子类*/
        private final AtomicInteger threadId=new AtomicInteger(1);
        @Override
        public Thread newThread(Runnable r) {
            Thread t=new Thread(r,"线程-"+threadId.getAndIncrement());
            System.out.println(t.getName()+"已经被创建");
            return t;
        }
    }

    /**
     * 线程池被拒绝策略
     */
    public static class MyIgnorePolicy implements RejectedExecutionHandler{

        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
            doLog(r,executor);
        }
        private void doLog(Runnable r, ThreadPoolExecutor executor){
            //可做日志记录等
            System.err.println("线程池:"+executor.toString()+r.toString()+" 被拒绝执行");
        }
    }





}