老汉谈——线程池原理

线程池

JDK1.8官方介绍：

Thread pools address two different problems: they usually provide improved performance when executing large numbers of asynchronous tasks, due to reduced per-task invocation overhead, and they provide a means of bounding and managing the resources, including threads, consumed when executing a collection of tasks. Each ThreadPoolExecutor also maintains some basic statistics, such as the number of completed tasks.

线程池解决了两个问题：它们通常在执行大量异步任务时提供改进性能问题，由于减少了每个任务的资源开销，他们提供边界和管理资源的手段，包括线程，消费在执行任务的集合。每个ThreadPoolExecutor 维持一些基本的统计数据，比如完成任务数量。

线程池的原理

• 线程池本身是不创建和启动线程的，只有任务到达时才会，即当一个任务提交到线程池时，就会创建一个线程。但可以重写动态使用方法prestartCoreThread()或prestartCoreAllThread()。
• 当线程数没有达到核心线程数corePoolSize时，就会创建一个新的线程，不需要排队。当线程数大于核心线程数corePoolSize时，就会放到workerQueue任务队列里等待。
• 当核心线程数小于等于线程总数maximunPoolSize时，如果队列中有等待的线程，则线程池会用空余的线程来执行队列的线程；否则，线程池就会采用拒绝策略来终止新的任务。
• 如果某个线程会话时间超出保持会话时间keepAliveTime时，就会终止当前线程任务，然后加入新的线程任务。可以使用setKeepAliveTime(long, java.util.concurrent.TimeUnit)动态改变参数。一般来说，这个活动策略是已经超出了corePoolSize的线程时才应用。但只要keepAliveTime非0时，就可以通过allowCoreThreadTimeOut(true)方法，使超时策略应用在核心线程中。

任务排队

-直接提交：工作队列WorkQueue默认是SychronousQueue。它继承了AbstractQueue，实现了BlockingQueue。他的处理任务容量是无边界的。
当运行的线程数大于或等于核心线程corePoolSize时，才会加入队列，但直接提交是同步阻塞的。从下图的工作原理可以看出，直接提交maximunPoolSize最好无限大即无容量大小。

/**

- Creates a {@code SynchronousQueue} with nonfair access policy. 
  */ 
  public SynchronousQueue() { 
  this(false); 
  }

/**

- Creates a {@code SynchronousQueue} with the specified fairness policy. 
  *
- @param fair if true, waiting threads contend in FIFO order for
- access; otherwise the order is unspecified. 
  */ 
  public SynchronousQueue(boolean fair) { //fair 公平性标识 
  // 公平性TrasferQueue、 非公平行TransferStack 
  transferer = fair ? new TransferQueue() : new TransferStack(); 
  }

线程池类：ThreadPoolExecutor
应用场景：交换任工作，生产者的线程消费和消费者的线程同步传递消息、时间或任务。简单的说,任务2必须依赖于任务1的信息，

-无界队列：LinkedBlockingQueue。它保证所有的超出corePoolSize的线程都放入队列里。这样创建的线程不会超出corePoolSize.,因此maximumPoolSize值就无效了。
线程池类：newFixedThreadPool

- Creates a {@code LinkedBlockingQueue} with a capacity of
- {@link Integer#MAX_VALUE}. 
  */ 
  public LinkedBlockingQueue() { 
  this(Integer.MAX_VALUE); 
  }

/**
- Creates a {@code LinkedBlockingQueue} with the given (fixed) capacity. 
  *
- @param capacity the capacity of this queue
- @throws IllegalArgumentException if {@code capacity} is not greater
- than zero 
  */ 
  public LinkedBlockingQueue(int capacity) { 
  if (capacity <= 0) throw new IllegalArgumentException(); 
  this.capacity = capacity; 
  last = head = new Node(null); 
  }

/**
- Creates a {@code LinkedBlockingQueue} with a capacity of
- {@link Integer#MAX_VALUE}, initially containing the elements of the
- given collection,
- added in traversal order of the collection's iterator. 
  *
- @param c the collection of elements to initially contain
- @throws NullPointerException if the specified collection or any
- of its elements are null 
  */ 
  public LinkedBlockingQueue(Collection c) { 
  this(Integer.MAX_VALUE); 
  final ReentrantLock putLock = this.putLock; 
  putLock.lock(); // Never contended, but necessary for visibility 
  try { 
  int n = 0; 
  for (E e : c) { 
  if (e == null) 
  throw new NullPointerException(); 
  if (n == capacity) 
  throw new IllegalStateException("Queue full"); 
  enqueue(new Node(e)); 
  ++n; 
  } 
  count.set(n); 
  } finally { 
  putLock.unlock(); 
  } 
  }

应用场景：适合任务之间互不影响

-有界队列：ArrayBlockingQueue。这是最复杂的一种。不推荐使用。当使用有限的MaximumPoolSize时，有界队列可以防止资源耗尽，但可能很难控制与调整。队列的容量是有限的。
一般使用大池小列或小池大列，前者会增加CPU使用率，但遇到不可接受的调度开销，也会降低吞吐量；后者会减少CPU使用率、操作系统资源和上下文的切换，但可能导致人工来降低吞吐量。

/**

- Creates an {@code ArrayBlockingQueue} with the given (fixed)
- capacity and default access policy. 
  *
- @param capacity the capacity of this queue
- @throws IllegalArgumentException if {@code capacity < 1} 
  */ 
  public ArrayBlockingQueue(int capacity) { 
  this(capacity, false); 
  }

/**

- Creates an {@code ArrayBlockingQueue} with the given (fixed)
- capacity and the specified access policy. 
  *
- @param capacity the capacity of this queue
- @param fair if {@code true} then queue accesses for threads blocked
- on insertion or removal, are processed in FIFO order;
- if {@code false} the access order is unspecified.
- @throws IllegalArgumentException if {@code capacity < 1} 
  */ 
  public ArrayBlockingQueue(int capacity, boolean fair) { 
  if (capacity <= 0) 
  throw new IllegalArgumentException(); 
  this.items = new Object[capacity]; 
  lock = new ReentrantLock(fair); 
  notEmpty = lock.newCondition(); 
  notFull = lock.newCondition(); 
  }

public ArrayBlockingQueue(int capacity, boolean fair, 
Collection c) { 
this(capacity, fair);

final ReentrantLock lock = this.lock;
lock.lock(); // Lock only for visibility, not mutual exclusion
try {
    int i = 0;
    try {
        for (E e : c) {
            checkNotNull(e);
            items[i++] = e;
        }
    } catch (ArrayIndexOutOfBoundsException ex) {
        throw new IllegalArgumentException();
    }
    count = i;
    putIndex = (i == capacity) ? 0 : i;
} finally {
    lock.unlock();
}

}

从上可以看出:有界队列ArrayBlockingQueue和无界队列LinkedBlockingQueue都是使用ReentrantLock重入锁，而同步队列sychoronousQueue是使用公平性TransferQueue和非共性TransferStack，即转移数据队列和转移数据栈，从数据结构便知数据的顺序。