线程池 --------常见的四中线程池

由于线程的频繁调度，而影响性能，通过线程池来维护，减少线程的频繁的创建和销毁。
在Executors统一管理，看一下常见的四中线程池：
1.newFixedThreadPool：创建定长的线程池，超出定长在线程队列中等待。

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

2.newCachedThreadPool：线程数无限大，当线程队列中有空闲线程时会复用，否则重新创建线程，同时线程60s没有用时，从线程队列中移除。

 public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

3.newScheduledThreadPool：次线程池是在规定的时间进行调度。

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

4.newSingleThreadExecutor：仅有一个线程在调度，且有顺序的进行出队和入队。

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

但是他们都调用了ThreadPoolExecutor：看一下核心构造器里的几个参数
corePoolSize：要保留在池中的线程数量。
maximumPoolSize：线程池中允许的最大线程数。
keepAliveTime：空闲线程等待的最大时间。
unit：keepAliveTime的时间单位。
workQueue：可执行的任务队列。
threadFactory：执行创建一个新的线程时使用。
handler：当达到了线程边界和队列容量，执行被阻塞时使用的处理程序。

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

线程池中常用几个方法源码：
看一下runState控制得几种状态：

RUNNING:  接受新任务并能够对添加的任务处理。
SHUTDOWN: 不接受新任务，但能处理已在队列中的任务。
STOP:    不接受新任务，不处理排队的任务，并同时中断正在进行的任务。
TIDYING:  所有任务全部中断，同时将workerCount 置0，并将所有线程切换到TIDYING状态，会执行钩子函数terminated()。
TERMINATED: 表示线程池彻底终止。执行完terminated()之后，就会由 TIDYING -> TERMINATED。

线程池的几种转态转换：
在这里插入图片描述

 public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        int c = ctl.get();//保证了数据的原子性，不被其他线程干扰
        if (workerCountOf(c) < corePoolSize) {//运行的线程数小于corePoolSize的数量时
            if (addWorker(command, true))//添加一个新的到任务中
                return;
            c = ctl.get();
        }
        if (isRunning(c) && workQueue.offer(command)) {//插入任务成功且是Running状态下
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))//移除任务成功且不是Running状态下
                reject(command);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        //如果添加到任务中失败，抛出异常。
        else if (!addWorker(command, false))
            reject(command);
    }

这里addWorker(Runnable firstTask, boolean core)中的两个参数：
firstTask：新线程首要运行。
core：用一个布尔值判断当前线程数是否小于corePoolSize或maximumPoolSize。在源码中

wc >= (core ? corePoolSize : maximumPoolSize))

shutdown()方法:对以前的任务切换到SHUTDOWN状态，不接受新的任务。

public void shutdown() {
        final ReentrantLock mainLock = this.mainLock;//重入锁
        mainLock.lock();
        try {
            checkShutdownAccess();//判断调用者是否有权限shutdown线程池
            advanceRunState(SHUTDOWN);//线程池状态切换为SHUTDOWN
            interruptIdleWorkers();//中断可能正在等待任务的线程
            onShutdown(); // SHUTDOWN转态下的进一步清理。但是使用了ScheduledThreadPoolExecutor取消延迟的任务。
        } finally {
            mainLock.unlock();
        }
        tryTerminate();//试着终止线程池
    }

线程池 --------常见的四中线程池

猜你喜欢