前言
线程池的相关类
-
Executor
-
ExecutorService
-
AbstractExecutorService
-
ThreadPoolExecutor
Executor
public interface Executor { void execute(Runnable command); }
ExecutorService
public interface ExecutorService extends Executor { void shutdown(); List<Runnable> shutdownNow(); boolean isShutdown(); <T> Future<T> submit(Callable<T> task); <T> Future<T> submit(Runnable task, T result); Future<?> submit(Runnable task); <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException; ...... }
-
shutdownNow : 关闭线程池,返回放入了线程池,但是还没开始执行的线程。
-
submit : 执行的任务 允许拥有返回值。
-
invokeAll : 运行把任务放进集合中,进行批量的执行,并且能有返回值
-
submit 有返回值,execute 没有返回值。 所以说可以根据任务有无返回值选择对应的方法,如果觉得不太好理解的话,可以报名参加一个java培训,这样学习可能更好一些。
-
submit 方便异常的处理。 如果任务可能会抛出异常,而且希望外面的调用者能够感知这些异常,那么就需要调用 submit 方法,通过捕获 Future.get 抛出的异常。
AbstractExecutorService
public Future<?> submit(Runnable task) { if (task == null) throw new NullPointerException(); RunnableFuture<Void> ftask = newTaskFor(task, null); execute(ftask); return ftask; }
ThreadPoolExecutor
private final HashSet<Worker> workers = new HashSet<Worker>(); private final BlockingQueue<Runnable> workQueue;
public void execute(Runnable command) { ...... if (workerCountOf(c) < corePoolSize) { if (addWorker(command, true)) return; c = ctl.get(); } if (isRunning(c) && workQueue.offer(command)) { int recheck = ctl.get(); if (! isRunning(recheck) && remove(command)) reject(command); else if (workerCountOf(recheck) == 0) addWorker(null, false); } ...... }
-
对于 maximumPoolSize:指的是 线程池中最多允许有多少个线程。
-
对于 corePoolSize: 指的是线程池中正在运行的线程。
-
如果现在线程池中正在运行的线程数量大于 corePoolSize 指定的值而 小于maximumPoolSize 指定的值,那么就会创建一个线程对该任务进行执行,一旦一个线程被创建运行。
-
如果线程池中的线程数量大于corePoolSize,那么这个任务执行完毕后,该线程会被回收;如果 小于corePoolSize,那么该线程即使空闲,也不会被回收。下个任务过来,那么就使用这个空闲线程。
private boolean addWorker(Runnable firstTask, boolean core) { boolean workerStarted = false; boolean workerAdded = false; Worker w = null; try { w = new Worker(firstTask); final Thread t = w.thread; if (t != null) { final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { int rs = runStateOf(ctl.get()); if (rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null)) { if (t.isAlive()) // precheck that t is startable throw new IllegalThreadStateException(); workers.add(w); int s = workers.size(); if (s > largestPoolSize) largestPoolSize = s; workerAdded = true; } ...... }
private final class Worker extends AbstractQueuedSynchronizer implements Runnable { ...... final Thread thread; Runnable firstTask; Worker(Runnable firstTask) { setState(-1); // inhibit interrupts until runWorker this.firstTask = firstTask; this.thread = getThreadFactory().newThread(this); } public void run() { runWorker(this); } ......
final void runWorker(Worker w) { Thread wt = Thread.currentThread(); Runnable task = w.firstTask; w.firstTask = null; w.unlock(); // allow interrupts boolean completedAbruptly = true; try { while (task != null || (task = getTask()) != null) { w.lock(); if ((runStateAtLeast(ctl.get(), STOP) || (Thread.interrupted() && runStateAtLeast(ctl.get(), STOP))) && !wt.isInterrupted()) wt.interrupt(); try { beforeExecute(wt, task); Throwable thrown = null; try { task.run(); } catch (RuntimeException x) { thrown = x; throw x; } catch (Error x) { thrown = x; throw x; } catch (Throwable x) { thrown = x; throw new Error(x); } finally { afterExecute(task, thrown); } } ...... }
private Runnable getTask() { for (;;) { ...... try { Runnable r = timed ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : workQueue.take(); if (r != null) return r; timedOut = true; } catch (InterruptedException retry) { timedOut = false; } } }
总结
private final HashSet<Worker> workers = new HashSet<Worker>(); private final BlockingQueue<Runnable> workQueue;
写在最后
-
写出来,说出来才知道对不对,知道不对才能改正,改正了才能成长。
-
在技术方面,希望大家眼里都容不得沙子。如果有不对的地方或者需要改进的地方希望可以指出,万分感谢。