转载请标明出处：http://blog.csdn.net/xx326664162/article/details/51701508 文章出自：薛瑄的博客

你也可以查看我的其他同类文章，也会让你有一定的收货！

线程池的框架图：

一、ThreadPoolExecutor线程池实现类

ThreadPoolExecutor是线程池的核心类。首先看一下如何创建一个ThreadPoolExecutor。下面是ThreadPoolExecutor常用的一个构造方法：

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue)

看一下这个类中定义的重要变量，如下：

private final BlockingQueue<Runnable> workQueue;              // 阻塞队列
private final ReentrantLock mainLock = new ReentrantLock();   // 互斥锁
private final HashSet<Worker> workers = new HashSet<Worker>();// 线程集合.一个Worker对应一个线程
private final Condition termination = mainLock.newCondition();// 终止条件
private int largestPoolSize;           // 线程池中线程数量曾经达到过的最大值。
private long completedTaskCount;       // 已完成任务数量
private volatile ThreadFactory threadFactory;     // ThreadFactory对象，用于创建线程。
private volatile RejectedExecutionHandler handler;// 拒绝策略的处理句柄
private volatile long keepAliveTime;   // 线程池维护线程所允许的空闲时间
private volatile boolean allowCoreThreadTimeOut;
private volatile int corePoolSize;     // 线程池维护线程的最小数量，哪怕是空闲的
private volatile int maximumPoolSize;  // 线程池维护的最大线程数量  

其中有几个重要的规则需要说明一下：

1、 corePoolSize、workQueue 、maximumPoolSize的关系

1、线程池刚创建时，里面没有一个线程。任务队列是作为参数传进来的。不过，就算队列里面有任务，线程池也不会马上执行它们。

2、当调用 execute() 方法添加一个任务时，线程池会做如下判断：

a. 如果正在运行的线程数量小于 corePoolSize，那么马上创建线程运行这个任务；

b. 如果正在运行的线程数量大于或等于 corePoolSize，那么将这个任务放入队列。

c. 如果这时候队列满了，而且正在运行的线程数量小于 maximumPoolSize，那么还是要创建线程运行这个任务；

d. 如果队列满了，而且正在运行的线程数量大于或等于 maximumPoolSize，那么线程池会抛出异常，告诉调用者“我不能再接受任务了”。

3、当一个线程完成任务时，它会从队列中取下一个任务来执行。

4、当一个线程无事可做，超过一定的时间（keepAliveTime）时，线程池会判断，如果当前运行的线程数大于 corePoolSize，那么这个线程就被停掉。所以线程池的所有任务完成后，它最终会收缩到 corePoolSize 的大小。

这样的过程说明，并不是先加入任务就一定会先执行。假设队列大小为 10，corePoolSize 为 3，maximumPoolSize 为 6，那么当加入 20 个任务时，执行的顺序就是这样的：首先执行任务 1、2、3，然后任务 4~13 被放入队列。这时候队列满了，任务 14、15、16 会被马上执行，而任务 17~20 则会抛出异常。最终顺序是：1、2、3、14、15、16、4、5、6、7、8、9、10、11、12、13。下面是一个线程池使用的例子：

2、workQueue 线程池所使用的缓冲队列

该缓冲队列的长度决定了能够缓冲的最大数量，缓冲队列有三种通用策略：

1、 直接提交。

　　
　　工作队列的默认选项是 SynchronousQueue，它将任务直接提交给线程而不保持它们。
　　在此，如果不存在可用于立即运行任务的线程，则把任务加入队列将失败，因此会构造一个新的线程。
　　此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。直接提交通常要求无界 maximumPoolSizes 以避免拒绝新提交的任务。当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性;
　　

2、 无界队列

　　使用无界队列（例如，不具有预定义容量的 LinkedBlockingQueue）将导致在所有 corePoolSize 线程都忙时，新任务将在队列中等待。这样，创建的线程数量就不会超过 corePoolSize。（因此，maximumPoolSize 的值也就无效了。）

当每个任务完全独立于其他任务，即任务执行互不影响时，适合于使用无界队列；例如，在 Web 页服务器中。这种排队可用于处理瞬态突发请求，当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性;
　　

3、 有界队列

当使用有限的 maximumPoolSizes 时，有界队列（如 ArrayBlockingQueue）有助于防止资源耗尽，但是可能较难调整和控制。

队列大小和最大池大小可能需要相互折衷：使用大型队列和小型池可以最大限度地降低 CPU 使用率、操作系统资源和上下文切换开销，但是可能导致人工降低吞吐量。如果任务频繁阻塞（例如，如果它们是 I/O 边界），则系统可能为超过您许可的更多线程安排时间。使用小型队列通常要求较大的池大小，CPU 使用率较高，但是可能遇到不可接受的调度开销，这样也会降低吞吐量.

举例：

例子一：使用直接提交策略，也即SynchronousQueue。

首先SynchronousQueue是无界的，也就是说他存储任务的能力是没有限制的，但是由于该Queue本身的特性，在某次添加元素后必须等待其他线程取走后才能继续添加。在这里不是核心线程便是新创建的线程，但是我们试想一样下，下面的场景。

我们使用以下参数构造ThreadPoolExecutor：

new ThreadPoolExecutor(   2, 3, 30, TimeUnit.SECONDS,    new  SynchronousQueue<Runnable>(),    new RecorderThreadFactory("CookieRecorderPool"),    new ThreadPoolExecutor.CallerRunsPolicy()); 

假设当前核心线程已经有2个正在运行.

1. 此时来了一个任务（A），根据前面介绍的“如果运行的线程等于或多于 corePoolSize，则 Executor 始终首选将请求加入队列，而不添加新的线程。”,所以A被添加到queue中。

2. 又来了一个任务（B），且核心2个线程还没有忙完。接下来首先尝试1中描述，但是由于使用的SynchronousQueue，所以一定无法加入进去。

3. 此时便满足了上面提到的“如果无法将请求加入队列，则创建新的线程”，所以必然会新建一个线程来运行这个任务。

4. 但是如果这三个任务都还没完成，继续来了一个任务，queue中无法插入（任务A还在queue中），而线程数达到了maximumPoolSize，所以只好执行异常策略了。
   为了避免这种情况:，所以在使用SynchronousQueue通常要求maximumPoolSize是无界的（如果希望限制就直接使用有界队列）。对于使用SynchronousQueue的作用jdk中写的很清楚：此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。

如果你的任务A1，A2有内部关联，A1需要先运行，那么先提交A1，再提交A2，当使用SynchronousQueue我们可以保证，A1必定先被执行，在A1么有被执行前，A2不可能添加入queue中

例子二：使用无界队列策略，即LinkedBlockingQueue

拿newFixedThreadPool来说，根据前文提到的规则：

• 如果运行的线程少于 corePoolSize，则 Executor 始终首选添加新的线程，而不进行排队。

那么当任务继续增加，会发生什么呢？

• 如果运行的线程等于或多于 corePoolSize，则 Executor 始终首选将请求加入队列，而不添加新的线程。

OK，此时任务变加入队列之中了，那什么时候才会添加新线程呢？

• 如果无法将请求加入队列，则创建新的线程，除非创建此线程超出 maximumPoolSize，在这种情况下，任务将被拒绝。

无界队列不会出现无法加入队列的情况。不像SynchronousQueue那样有其自身的特点，对于无界队列来说，总是可以加入的（资源耗尽，当然另当别论）。

换句说，永远也不会触发产生新的线程！线程数一直都是corePoolSize大小。忙完当前的线程，就从队列中拿任务开始运行。如果任务运行的时长比较长，而添加任务的速度远远超过处理任务的速度，任务队列就会疯长，任务内存很快就会爆掉

例子三：有界队列，使用ArrayBlockingQueue。

这个是最为复杂的使用，所以JDK不推荐使用也有些道理。与上面的相比，最大的特点便是可以防止资源耗尽的情况发生。

举例来说，请看如下构造方法：

new ThreadPoolExecutor(  2, 4, 30, TimeUnit.SECONDS,   new ArrayBlockingQueue<Runnable>(2),   new RecorderThreadFactory("CookieRecorderPool"),   new ThreadPoolExecutor.CallerRunsPolicy());  

假设，所有的任务都永远无法执行完。

1. 首先来的A,B直接运行
2. 如果来了C,D，他们会被放到queue中
3. 如果接下来再来E,F，则增加线程运行E，F。最大线程数是4
4. 但是如果再来任务，队列无法再接受了，线程数也到达最大的限制了，所以就会使用拒绝策略来处理。

3、ThreadFactory

使用 ThreadFactory 创建新线程。如果没有另外说明，则在同一个 ThreadGroup 中一律使用 Executors.defaultThreadFactory() 创建线程，并且这些线程具有相同的 NORM_PRIORITY 优先级和非守护进程状态。

通过提供不同的 ThreadFactory，可以改变线程的名称、线程组、优先级、守护进程状态等等。如果从 newThread 返回 null 时 ThreadFactory 未能创建线程，则执行程序将继续运行，但不能执行任何任务。

public interface ThreadFactory {  Thread newThread(Runnable r);
}

而构造方法中的threadFactory对象，是通过 Executors.defaultThreadFactory()返回的。Executors.java中的defaultThreadFactory()源码如下：

public static ThreadFactory defaultThreadFactory() {  return new DefaultThreadFactory();  } 

在DefaultThreadFactory类中实现了ThreadFactory接口并对其中定义的方法进行了实现，如下：

static class DefaultThreadFactory implements ThreadFactory {  private static final AtomicInteger poolNumber = new AtomicInteger(1);  private final ThreadGroup group;  private final AtomicInteger threadNumber = new AtomicInteger(1);  private final String namePrefix;  DefaultThreadFactory() {  SecurityManager s = System.getSecurityManager();  group = (s != null) ? s.getThreadGroup() :  Thread.currentThread().getThreadGroup();  namePrefix = "pool-" +  poolNumber.getAndIncrement() +  "-thread-";  }  // 为线程池创建新的任务执行线程  public Thread newThread(Runnable r) {  // 线程对应的任务是Runnable对象r  Thread t = new Thread(group, r,namePrefix + threadNumber.getAndIncrement(), 0);  // 设为非守护线程  if (t.isDaemon())  t.setDaemon(false);  // 将优先级设为Thread.NORM_PRIORITY  if (t.getPriority() != Thread.NORM_PRIORITY)  t.setPriority(Thread.NORM_PRIORITY);  return t;  }
}  

4、RejectedExecutionHandler

当Executor已经关闭（即执行了executorService.shutdown()方法后），并且Executor将有限边界用于最大线程和工作队列容量，且已经饱和时，在方法execute()中提交的新任务将被拒绝.
　 在以上述情况下，execute 方法将调用其 RejectedExecutionHandler 的 RejectedExecutionHandler.rejectedExecution(java.lang.Runnable, java.util.concurrent.ThreadPoolExecutor) 方法。下面提供了四种预定义的处理程序策略：

1. 在默认的 ThreadPoolExecutor.AbortPolicy 处理程序遭到拒绝将抛出运行时 RejectedExecutionException;

2. 在 ThreadPoolExecutor.CallerRunsPolicy线程调用运行该任务的 execute 本身。此策略提供简单的反馈控制机制，能够减缓新任务的提交速度

3. 在 ThreadPoolExecutor.DiscardPolicy 不能执行的任务将被删除;

4. 在 ThreadPoolExecutor.DiscardOldestPolicy 如果执行程序尚未关闭，则位于工作队列头部的任务将被删除，然后重试执行程序（如果再次失败，则重复此过程）。
   线程池默认会采用的是defaultHandler策略。首先看defaultHandler的定义：

private static final RejectedExecutionHandler defaultHandler = new AbortPolicy(); // 使用默认的拒绝策略  

public static class AbortPolicy implements RejectedExecutionHandler {  public AbortPolicy() { }  // 抛出异常  public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {  throw new RejectedExecutionException("Task " + r.toString() +  " rejected from " +  e.toString());  }
} 

看一下其他拒绝策略的具体实现。

class MyRunnable implements Runnable {  private String name;  public MyRunnable(String name) {  this.name = name;  }  @Override  public void run() {  try {  System.out.println(this.name + " is running.");  Thread.sleep(100);  } catch (Exception e) {  e.printStackTrace();  }  }
}

举例：

如上是一个测试任务的例子，下面编写4个测试用例来测试。

1. DiscardPolicy 示例

public class DiscardPolicyDemo {  private static final int THREADS_SIZE = 1;  private static final int CAPACITY = 1;  public static void main(String[] args) throws Exception {  // 创建线程池。线程池的"最大池大小"和"核心池大小"都为1(THREADS_SIZE)，"线程池"的阻塞队列容量为1(CAPACITY)。  ThreadPoolExecutor pool = new ThreadPoolExecutor(THREADS_SIZE, THREADS_SIZE, 0, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(CAPACITY));  // 设置线程池的拒绝策略为"丢弃"  pool.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy());  // 新建10个任务，并将它们添加到线程池中。  for (int i = 0; i < 10; i++) {  Runnable myrun = new MyRunnable("task-"+i);  pool.execute(myrun);  }  // 关闭线程池  pool.shutdown();  }
}  

线程池pool的”最大池大小”和”核心池大小”都为1(THREADS_SIZE)，这意味着”线程池能同时运行的任务数量最大只能是1”。
线程池pool的阻塞队列是ArrayBlockingQueue，ArrayBlockingQueue是一个有界的阻塞队列，ArrayBlockingQueue的容量为1。这也意味着线程池的阻塞队列只能有一个线程池阻塞等待。
根据”“中分析的execute()代码可知：线程池中共运行了2个任务。第1个任务直接放到Worker中，通过线程去执行；第2个任务放到阻塞队列中等待。其他的任务都被丢弃了！

2. DiscardOldestPolicy 示例

public class DiscardOldestPolicyDemo {  private static final int THREADS_SIZE = 1;  private static final int CAPACITY = 1;  public static void main(String[] args) throws Exception {  // 创建线程池。线程池的"最大池大小"和"核心池大小"都为1(THREADS_SIZE)，"线程池"的阻塞队列容量为1(CAPACITY)。  ThreadPoolExecutor pool = new ThreadPoolExecutor(THREADS_SIZE, THREADS_SIZE, 0, TimeUnit.SECONDS,  new ArrayBlockingQueue<Runnable>(CAPACITY));  // 设置线程池的拒绝策略为"DiscardOldestPolicy"  pool.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardOldestPolicy());  // 新建10个任务，并将它们添加到线程池中。  for (int i = 0; i < 10; i++) {  Runnable myrun = new MyRunnable("task-"+i);  pool.execute(myrun);  }  // 关闭线程池  pool.shutdown();  }
}  

运行结果：

task-0 is running.
task-9 is running.

将”线程池的拒绝策略”由DiscardPolicy修改为DiscardOldestPolicy之后，当有任务添加到线程池被拒绝时，线程池会丢弃阻塞队列中末尾的任务，然后将被拒绝的任务添加到末尾。

3. AbortPolicy 示例

public class AbortPolicyDemo {  private static final int THREADS_SIZE = 1;  private static final int CAPACITY = 1;  public static void main(String[] args) throws Exception {  // 创建线程池。线程池的"最大池大小"和"核心池大小"都为1(THREADS_SIZE)，"线程池"的阻塞队列容量为1(CAPACITY)。  ThreadPoolExecutor pool = new ThreadPoolExecutor(THREADS_SIZE, THREADS_SIZE, 0, TimeUnit.SECONDS,  new ArrayBlockingQueue<Runnable>(CAPACITY));  // 设置线程池的拒绝策略为"抛出异常"  pool.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());  try {  // 新建10个任务，并将它们添加到线程池中。  for (int i = 0; i < 10; i++) {  Runnable myrun = new MyRunnable("task-"+i);  pool.execute(myrun);  }  } catch (RejectedExecutionException e) {  e.printStackTrace();  // 关闭线程池  pool.shutdown();  }  }
}  

(某一次)运行结果：

java.util.concurrent.RejectedExecutionExceptionat java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:1774)at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:768)at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:656)at AbortPolicyDemo.main(AbortPolicyDemo.java:27)
task-0 is running.
task-1 is running.

将”线程池的拒绝策略”由DiscardPolicy修改为AbortPolicy之后，当有任务添加到线程池被拒绝时，会抛出RejectedExecutionException。

4. CallerRunsPolicy 示例

public class CallerRunsPolicyDemo {  private static final int THREADS_SIZE = 1;  private static final int CAPACITY = 1;  public static void main(String[] args) throws Exception {  // 创建线程池。线程池的"最大池大小"和"核心池大小"都为1(THREADS_SIZE)，"线程池"的阻塞队列容量为1(CAPACITY)。  ThreadPoolExecutor pool = new ThreadPoolExecutor(THREADS_SIZE, THREADS_SIZE, 0, TimeUnit.SECONDS,  new ArrayBlockingQueue<Runnable>(CAPACITY));  // 设置线程池的拒绝策略为"CallerRunsPolicy"  pool.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());  // 新建10个任务，并将它们添加到线程池中。  for (int i = 0; i < 10; i++) {  Runnable myrun = new MyRunnable("task-"+i);  pool.execute(myrun);  }  // 关闭线程池  pool.shutdown();  }
}  

(某一次)运行结果：

task-2 is running.
task-3 is running.
task-4 is running.
task-5 is running.
task-6 is running.
task-7 is running.
task-8 is running.
task-9 is running.
task-0 is running.
task-1 is running.

将”线程池的拒绝策略”由DiscardPolicy修改为CallerRunsPolicy之后，当有任务添加到线程池被拒绝时，线程池会将被拒绝的任务添加到”线程池正在运行的线程”中取运行。

二、Executor任务提交接口

Executor框架同java.util.concurrent.Executor 接口在Java 5中被引入。Executor框架是一个根据一组执行策略调用，调度，执行和控制的异步任务的框架。Executor存在的目的是提供一种将“任务提交”与”任务如何运行”分离开来的机制。定义如下：

public interface Executor {  void execute(Runnable command);
} 

虽然只有一个方法，但是却为灵活且强大的异步任务执行框架提供了基础。它提供了一种标准的方法将任务的提交过程与执行过程解耦开来，并用Runnable来表示任务。

三、ExecutorService任务周期管理接口

Executor的实现通常都会创建线程来执行任务，但是使用异步方式来执行任务时，由于之前提交任务的状态不是立即可见的，所以如果要关闭应用程序时，就需要将受影响的任务状态反馈给应用程序。

为了解决线程的生命周期问题，EecutorService扩展了Eecutor接口，添加了一些用于生命周期管理的方法。如下：

public interface ExecutorService extends Executor {  void shutdown();  List<Runnable> shutdownNow();  boolean isShutdown();  boolean isTerminated();  boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;  // 省略部分方法
}

四、Executors工具类

那么我们怎么得到Executor对象呢？这就是接下来要介绍的Exectors类了。
Executors为创建Executor，ExecutorService，ScheduledExecutorService，ThreadFactory和Callable类提供了一些方法，类似于集合中的Collections类的功能。

下面是Exectors类的一些方法，用于创建线程池：

1、newCachedThreadPool

它是一种线程数量不定的线程池，并只有非核心线程。

该线程池比较适合没有固定大小并且比较快速就能完成的小任务，它将为每个任务创建一个线程。

那这样子它与直接创建线程对象（new Thread()）有什么区别呢？看到它的第三个参数60L和第四个参数TimeUnit.SECONDS了吗？好处就在于60秒内能够重用已创建的线程。超过60s的闲置线程就会被回收。

Integer.MAX_VALUE 是一个非常大的数，实际上就相当于最大线程数可以任意大

下面是Executors中的newCachedThreadPool()的源代码：

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

2、 newFixedThreadPool

它是一种线程数量固定的线程池，如果提交的任务数量大于限制的最大线程数，那么这些任务将排队，当有一个线程的任务结束之后，将会根据调度策略继续等待执行下一个任务。

下面是Executors中的newFixedThreadPool()的源代码：　

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

3、newSingleThreadExecutor

线程数量为1的FixedThreadPool,如果提交了多个任务，那么这些任务将会排队，每个任务都会在下一个任务开始之前运行结束，所有的任务将会使用相同的线程。下面是Executors中的newSingleThreadExecutor()的源代码：　　

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

通过上面创建线程池的源代码，我们可以发现：
　　1> 除了CachedThreadPool使用的是直接提交策略的缓冲队列，FixedThreadPool和SingleThreadExecutor采用的都是无界缓冲队列，创建的线程数量不会超过 corePoolSize。
　 2> 三个线程池采用的ThreadPoolExecutor构造方法都是同一个，使用的都是默认的ThreadFactory和handler:

private static final RejectedExecutionHandler defaultHandler = new AbortPolicy();  public ThreadPoolExecutor(int corePoolSize,  int maximumPoolSize,  long keepAliveTime,  TimeUnit unit,  BlockingQueue<Runnable> workQueue) {  this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,  Executors.defaultThreadFactory(), defaultHandler);
} 

也就说三个线程池创建的线程对象都是同组，优先权等级为正常的Thread.NORM_PRIORITY（5）的非守护线程，使用的被拒绝任务处理方式是直接抛出异常的AbortPolicy策略（前面有介绍）。

4、newScheduledThreadPool

核心线程数是固定的，
非核心线程数是没有限制的，并且当非核心线程闲置时，会被立即回收
主要用于执行定时任务和具有固定周期的重复任务

    public ScheduledThreadPoolExecutor(int corePoolSize) {super(corePoolSize, Integer.MAX_VALUE,DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,new DelayedWorkQueue());}

参考：
http://blog.csdn.net/mazhimazh/article/details/19243889
http://shift-alt-ctrl.iteye.com/blog/1840385
http://dongxuan.iteye.com/blog/901689
http://blog.csdn.net/sd0902/article/details/8395677
http://shift-alt-ctrl.iteye.com/blog/1840385
Java线程池详解：ThreadPoolExecutor、Executors
引用 Java自带的线程池ThreadPoolExecutor详细介绍说明和实例应用

关注我的公众号，轻松了解和学习更多技术

Java 线程池原理和队列详解相关推荐

1. Java线程池原理与实例详解

   Wiki 采用new Thread的方式产生多线程,可能有以下一些问题:  线程的创建和销毁开销很大,尤其是有些线程的存在时间较短:  线程的创建和销毁过程中伴随着CPU在线程间的切换,开销很大: ...

2. Java线程池七个参数详解

   java多线程开发时,常常用到线程池技术,这篇文章是对创建java线程池时的七个参数的详细解释. 从源码中可以看出,线程池的构造函数有7个参数,分别是corePoolSize.maximumPoolS ...

3. 一文搞懂线程池原理——Executor框架详解

   文章目录 1 使用线程池的好处 2 Executor 框架 2.1 Executor 框架结构 2.2 Executor 框架使用示意图 2.3 Executor 框架成员 2.3.1 Executo ...

4. java线程池使用最全详解

   线程池使用 前言 在执行一个异步任务或并发任务时,往往是通过直接new Thread()方法来创建新的线程,这样做弊端较多,更好的解决方案是合理地利用线程池,线程池的优势很明显,如下: 降低系统资源消 ...

5. Java线程池（ThreadPool）详解

   线程五个状态(生命周期): 线程运行时间 假设一个服务器完成一项任务所需时间为:T1 创建线程时间,T2 在线程中执行任务的时间,T3 销毁线程时间. 如果:T1 + T3 远大于 T2,则可以采用线 ...

6. Java线程池七个参数详解：核心线程数、最大线程数、空闲线程存活时间、时间单位、工作队列、线程工厂、拒绝策略

   源码简介 ThreadPoolExecutor是JDK中的线程池实现,这个类实现了一个线程池需要的各个方法,它提供了任务提交.线程管理.监控等方法. 下面是ThreadPoolExecutor类的构造 ...

7. Java线程池及配置参数详解

   一.线程池的优点 合理利用线程池能够带来三个好处. 第一:降低资源消耗.通过重复利用已创建的线程降低线程创建和销毁造成的消耗. 第二:提高响应速度.当任务到达时,任务可以不需要的等到线程创建就能立即执 ...

8. java 重启线程_java 可重启线程及线程池类的设计(详解)

   了解JAVA多线程编程的人都知道,要产生一个线程有两种方法,一是类直接继承Thread类并实现其run()方法:二是类实现Runnable接口并实现其run()方法,然后新建一个以该类为构造方法参数的 ...

9. Java 线程池原理总结

   Java 线程池原理总结 (一)什么是线程池 线程池做的工作主要是控制运行的线程的数量,处理过程中将任务放入队列,然后在线程创建后启动这些任务,如果线程数量超过了最大数量超出数量的线程排队等候,等其它 ...

最新文章

1. 使用nc传输文件和目录【转】
2. 从零开始html css,HTML/CSS从零开始-常用属性(三)
3. Error:Cannot set the value of read-only property 'outputFile' for ApkVariantOutputImpl_Decorated{apk
4. Shadow Brokers扬言兜售新漏洞攻击工具
5. Linux第二章自测习题——Linux系列学习笔记
6. linux中使用u盘和光驱的命令_Linux文件操作高频使用命令
7. python定时器库_Python定时器完整示例 python定时器用法举例
8. VueX的store的简单使用心结
9. QQ登录JS SDK教程，调用openapi接口
10. 获取json配置_ASP.NET Core集成Nacos配置中心之适配多格式配置
11. php 复选框 未选,php – 在表单发布时如何获取复选框元素中未选中复选框的值？...
12. AIDL的简单使用和注意事项
13. 数据结构实验报告——线性表
14. oracle seq nextval,在oracle中使用sequence.nextval创建表
15. 学会用CUPS管理打印机
16. .Net Core开发学习(一) ——Startup 类
17. AMD64(x86_64)架构abi文档：中
18. 类似360浏览器 拖拽插件_又一个好用的能上谷歌学术的插件，收藏吧。！
19. 解决Windows10电脑时间不同步或无法更新问题
20. 祝所有程序员1024节日快乐。

热门文章

1. java sql2016驱动_微软发布用于SQL Server 的JDBC 6.0驱动下载 - IT之家
2. Springboot 通过Apollo-client加载配置的过程
3. mysql事务内_MySQL事务
4. 《人民的名义》评论分析
5. icc文件作用是什么?
6. python网络编程回顾
7. c语言宏定义多个常量,C语言几个常见的宏定义
8. vscode输入感叹号失效
9. 剑灵无双卡刀使用教程
10. 忘记IBM，联想进入赢利性增长