Java 5.0 就开始自带线程池的实现，其中固定大小的线程池，对普通使用还是很好用的。就是 Executors.newFixedThreadPool ，指需要指定一个大小数目就可以。相对于其他几种方式，易于实现高效稳定的服务器。
 
 
 
 
 
但是好用归好用，一些需要非常细心的问题，还是需要关注的，尤其是高并发场景，7*24不间断运行场景下。本文就是把这些地方记录下来，在设计和实现时，在这些问题上务必不能马虎，因为这关系到稳定性和效率，且不易通过测试来排查。
 
 
 
 
 
（1）实现：
 
 
 
 
 
几种线程池，都是通过  ThreadPoolExecutor 来实现的，如下：
 
 
 
 
 
ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,long keepAliveTime, TimeUnit unit,BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler)  
 
 
 
 
 
 
 
newFixedThreadPool ：
 
 
 
 
 
  public static ExecutorService newFixedThreadPool(int paramInt)
  {
    return new ThreadPoolExecutor(paramInt, paramInt, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue());
  }
 
 
 
 
 
而 LinkedBlockingQueue的实现：
 
 
 
 
 
  public LinkedBlockingQueue()
  {
    this(2147483647);
  }
 
 
 
 
 
这个默认的构造函数，实际上是有一些问题的（实际是构造了一个大小为 Integer.MAX_VALUE的任务队列）。
 
 
 
 
 
（2）问题
 
 
我们设想一个场景，客户端/服务器工作模式，请求来得很快，服务器端accept之后，将Socket放到了任务队列中，读请求处理，并发送响应。客户端连接来得很快，但处理没有那么快（例如需要IO或大量数学运算），所以来了之后就都排在队列里。一直到2147483647。
 
 
 
 
 
但是实际上，如果一个新的任务排在第100甚至1000、10000，客户端都可以等待，但是如果排到了 1000,000，客户端还会等待着吗？就像你如果去银行办业务，眼看排队都排到街上了，今天肯定轮不到了，你还会继续等吗？
 
 
 
 
 
换成计算机的设计语言，客户端连接，按照约定俗成，都是有超时的，开始提交了请求自然会等待，一定时间内得不到响应就超时进入异常处理流程了，那么，服务器队列里那个Socket还有什么意义呢？
 
 
 
 
 
（3）结论
 
 
 
 
 
所以说，在设计时，队列的长度是一定要用心设计和考虑的，除了在Demo和简单测试一下的程序里，不要轻易而简单的使用newFixedThreadPool ，要想清楚它的问题，在使用时使用其它方式避免。
 
 
 
 
 
一般情况下，队列的大小遵循下面的公事：
 
 
 
 
 
 queSize <= ClientTimeOut(秒） * TPS
 
 
 
 
 
队列大小 小于等于 客户端超时 * 每秒处理的交易数
 
 
 
 
 
当然，这些数据都是估算，另外，也取决于你做的东西，对于客户端超时早就走了，服务器端还得处理这种情况是一种什么态度和需求。
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

一、背景
 
阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。这两个附加的操作支持阻塞的插入和移除方法
 
1）支持阻塞的插入方法：意思是当队列满时，队列会阻塞插入元素的线程，直到队列不满。
 
2）支持阻塞的移除方法：意思是在队列为空时，获取元素的线程会等待队列变为非空
 
阻塞队列常用于生产者和消费者的场景，生产者是向队列里添加元素的线程，消费者是从队列里取元素的线程。阻塞队列就是生产者用来存放元素、消费者用来获取元素的容器。
 
在阻塞队列不可用时，这两个附加操作提供了4种处理方式
 
 
抛出异常：是指当阻塞队列满时候，再往队列里插入元素，会抛出 IllegalStateException("Queue full") 异常。当队列为空时，从队列里获取元素时会抛出 NoSuchElementException 异常 。
 
返回特殊值：插入方法会返回是否成功，成功则返回 true。移除方法，则是从队列里拿出一个元素，如果没有则返回 null
 
一直阻塞：当阻塞队列满时，如果生产者线程往队列里 put 元素，队列会一直阻塞生产者线程，直到拿到数据，或者响应中断退出。当队列空时，消费者线程试图从队列里 take 元素，队列也会阻塞消费者线程，直到队列可用。
 
超时退出：当阻塞队列满时，队列会阻塞生产者线程一段时间，如果超过一定的时间，生产者线程就会退出。
 
 
 
如果是无界阻塞队列，队列不可能会出现满的情况，所以使用put或offer方法永远不会被阻塞，而且使用offer方法时，该方法永远返回true
 
 
二、阻塞队列
 
JDK7 提供了 7 个阻塞队列。分别是
 
 
ArrayBlockingQueue：是一个用数组实现的有界阻塞队列，此队列按照先进先出（FIFO）的原则对元素进行排序。支持公平锁和非公平锁。【注：每一个线程在获取锁的时候可能都会排队等待，如果在等待时间上，先获取锁的线程的请求一定先被满足，那么这个锁就是公平的。反之，这个锁就是不公平的。公平的获取锁，也就是当前等待时间最长的线程先获取锁】
 
LinkedBlockingQueue：一个由链表结构组成的有界队列，此队列的长度为Integer.MAX_VALUE。此队列按照先进先出的顺序进行排序。
PriorityBlockingQueue： 一个支持线程优先级排序的无界队列，默认自然序进行排序，也可以自定义实现compareTo()方法来指定元素排序规则，不能保证同优先级元素的顺序。
DelayQueue： 一个实现PriorityBlockingQueue实现延迟获取的无界队列，在创建元素时，可以指定多久才能从队列中获取当前元素。只有延时期满后才能从队列中获取元素。（DelayQueue可以运用在以下应用场景：1.缓存系统的设计：可以用DelayQueue保存缓存元素的有效期，使用一个线程循环查询DelayQueue，一旦能从DelayQueue中获取元素时，表示缓存有效期到了。2.定时任务调度。使用DelayQueue保存当天将会执行的任务和执行时间，一旦从DelayQueue中获取到任务就开始执行，从比如TimerQueue就是使用DelayQueue实现的。）
SynchronousQueue： 一个不存储元素的阻塞队列，每一个put操作必须等待take操作，否则不能添加元素。支持公平锁和非公平锁。SynchronousQueue的一个使用场景是在线程池里。Executors.newCachedThreadPool()就使用了SynchronousQueue，这个线程池根据需要（新任务到来时）创建新的线程，如果有空闲线程则会重复使用，线程空闲了60秒后会被回收。
LinkedTransferQueue： 一个由链表结构组成的无界阻塞队列，相当于其它队列，LinkedTransferQueue队列多了transfer和tryTransfer方法。
 
LinkedBlockingDeque： 一个由链表结构组成的双向阻塞队列。队列头部和尾部都可以添加和移除元素，多线程并发时，可以将锁的竞争最多降到一半。
 
 
ArrayBlockingQueue 
 
ArrayBlockingQueue是一个用数组实现的有界阻塞队列。此队列按照先进先出（FIFO）的原则对元素进行排序
 
 
items：一个Object的数组
 
tackIndex：出队列的下标
 
putIndex：入队列的下标
 
count：队列中元素的数量
 
ArrayBlockingQueue 是一个用数组实现的有界阻塞队列。此队列按照先进先出（FIFO）的原则对元素进行排序。默认情况下不保证访问者公平的访问队列，所谓公平访问队列是指阻塞的所有生产者线程或消费者线程，当队列可用时，可以按照阻塞的先后顺序访问队列，即先阻塞的生产者线程，可以先往队列里插入元素，先阻塞的消费者线程，可以先从队列里获取元素。通常情况下为了保证公平性会降低吞吐量。我们可以使用以下代码创建一个公平的阻塞队列
 
ArrayBlockingQueue fairQueue = new ArrayBlockingQueue(1000,true);
 
查看ArrayBlockingQueue 的构造函数
 
 
设置ReentrantLock的锁模式为公平锁
 
 
LinkedBlockingQueue 
 
LinkedBlockingQueue 是一个用链表实现的有界阻塞队列。此队列的默认和最大长度为 Integer.MAX_VALUE。此队列按照先进先出的原则对元素进行排序
 
 
ArrayBlockingQueue 和LinkedBlockingQueue区别
 
1：底层实现不同
 
ArrayBlockingQueue 底层使用数组来维护队列，
 
LinkedBlockingQueue 底层使用链表来维护队列，在添加和删除队列中的元素的时候，会创建和销毁节点对象，在高并发和大量数据的时候，GC压力很大。
 
2：锁的方式不同
 
ArrayBlockingQueue 获取数据和添加数据都是使用同一个锁对象，这样添加和获取就不是一个并发的过程，不过，在ArrayBlockingQueue 中使用Condition的等待/通知机制，这样使得ArrayBlockingQueue的数据写入和获取操作已经足够轻巧，以至于引入独立的锁机制，除了给代码带来额外的复杂性外，其在性能上完全占不到任何便宜
 
LinkedBlockingQueue  获取数据和添加数据使用不同的锁对象。
 
PriorityBlockingQueue
 
PriorityBlockingQueue是一个支持优先级的无界阻塞队列。默认情况下元素采取自然顺序升序排列。继承Comparable类实现compareTo()方法来指定元素排序规则，或者初始化PriorityBlockingQueue时，指定构造参数Comparator来对元素进行排序。需要注意的是不能保证同优先级元素的顺序。
 
例子 学生实体类存入PriorityBlockingQueue 队列按照年龄升序排序
 
 
结果：
 
 
DelayQueue
 
DelayQueue是一个支持延时获取元素的无界阻塞队列。队列使用PriorityQueue来实现。队列中的元素必须实现Delayed接口，在创建元素时可以指定多久才能从队列中获取当前元素。只有在延迟期满时才能从队列中提取元素
 
DelayQueue非常有用，可以将DelayQueue运用在以下应用场景。
 
·缓存系统的设计：可以用DelayQueue保存缓存元素的有效期，使用一个线程循环查询DelayQueue，一旦能从DelayQueue中获取元素时，表示缓存有效期到了。
 
·定时任务调度：使用DelayQueue保存当天将会执行的任务和执行时间，一旦从DelayQueue中获取到任务就开始执行，比如TimerQueue就是使用DelayQueue实现的
 
实现DelayQueue的三个步骤
 
第一步：继承Delayed接口
 
第二步：实现getDelay(TimeUnit unit)，该方法返回当前元素还需要延时多长时间，单位是纳秒
 
第三步：实现compareTo方法来指定元素的顺序
 
例子：使用Task类给定延迟时间，继承Delayed,并重写getDelay()方法，然后重写compareTo()方法来规定先到期的Task对象先出队列
 
 
结果
 
 
SynchronousQueue
 
SynchronousQueue是一个不存储元素的阻塞队列。每一个put操作必须等待一个take操作，否则不能继续添加元素。它支持公平访问队列。默认情况下线程采用非公平性策略访问队列。使用以下构造方法可以创建公平性访问的SynchronousQueue，如果设置为true，则等待的线程会采用先进先出的顺序访问队列
 
SynchronousQueue<E> queue = new SynchronousQueue<E>(true);
 
 
SynchronousQueue可以看成是一个传球手，负责把生产者线程处理的数据直接传递给消费者线程。队列本身并不存储任何元素，非常适合传递性场景。SynchronousQueue的吞吐量高于LinkedBlockingQueue和ArrayBlockingQueue。
 
例子 
 
 
结果
 
 
LinkedTransferQueue
 
LinkedTransferQueue是一个由链表结构组成的无界阻塞TransferQueue队列。相对于其他阻塞队列，LinkedTransferQueue多了tryTransfer和transfer方法
 
（1）transfer方法
 
如果当前有消费者正在等待接收元素（消费者使用take()方法或带时间限制的poll()方法时），transfer方法可以把生产者传入的元素立刻transfer（传输）给消费者。如果没有消费者在等待接收元素，transfer方法会将元素存放在队列的tail节点，并等到该元素被消费者消费了才返回
 
（2）tryTransfer方法
 
tryTransfer方法是用来试探生产者传入的元素是否能直接传给消费者。如果没有消费者等待接收元素，则返回false。和transfer方法的区别是tryTransfer方法无论消费者是否接收，方法立即返回，而transfer方法是必须等到消费者消费了才返回。
 
对于带有时间限制的tryTransfer（E e，long timeout，TimeUnit unit）方法，试图把生产者传入的元素直接传给消费者，但是如果没有消费者消费该元素则等待指定的时间再返回，如果超时还没消费元素，则返回false，如果在超时时间内消费了元素，则返回true
 
LinkedBlockingDeque
 
LinkedBlockingDeque是一个由链表结构组成的双向阻塞队列。所谓双向队列指的是可以从队列的两端插入和移出元素。双向队列因为多了一个操作队列的入口，在多线程同时入队时，也就减少了一半的竞争。相比其他的阻塞队列，LinkedBlockingDeque多了addFirst、addLast、offerFirst、offerLast、peekFirst和peekLast等方法，以First单词结尾的方法，表示插入、获取（peek）或移除双端队列的第一个元素。以Last单词结尾的方法，表示插入、获取或移除双端队列的最后一个元素。另外，插入方法add等同于addLast，移除方法remove等效于removeFirst。但是take方法却等同于takeFirst，不知道是不是JDK的bug，使用时还是用带有First和Last后缀的方法更清楚。在初始化LinkedBlockingDeque时可以设置容量防止其过度膨胀。另外，双向阻塞队列可以运用在“工作窃取”模式中。
 
阻塞的实现
 
ReentranLock + Condition 实现队列的阻塞，ReentranLock 是锁，Condition是条件状态，通过等待/通知机制，来实现线程之间的通信。
 
ReentranLock + Condition的等待/通知机制和Object的wait()与notify()是类似的，通过synchronized，在锁中使用wait()与notify()达到线程之间通信，在ReentranLock 的lock()和unlock()之间通过类似的await()和signal()达到线程之间的通信。
 
在阻塞队列中A调用put()方法的时候，如果队列已满，则A线程挂起，等待恢复，如果B线程调用take()后，消耗一个队列元素后，会通知put()方法中挂起的A线程，因为这个时候B线程已经消耗一个元素可以在向队列中添加元素。相反如果队列一空 B线程调用take()方法会阻塞，当A线程调用put()调用后通知take()方法中的B线程，有元素可以获取。这就是阻塞的实现过程。
 
下面查看ArrayBlockingQueue 源码来分析这一实现过程
 
ArrayBlockingQueue的成员变量
 
lock 是锁   notEmpty和notFull是表示不为空和不为满的Condition状态
 
 
构造函数初始化，默认使用非公平锁
 
 
查看put()方法
 
 
enqueue()
 
 
查看take()方法
 
 
dequeue()
 
 
 转自：https://www.jianshu.com/p/32665a52eba1

 
 package com.gary.util;  
   
 import java.util.Collection;  
 import java.util.Iterator;  
 import java.util.LinkedList;  
 import java.util.Queue;  
   
 /** 
  * 固定长度队列 
  * @author gary 
  * 
  */  
 public class LimitQueue<E> implements Queue<E>{  
     //队列长度  
     private int limit;  
       
     Queue<E> queue = new LinkedList<E>();  
       
     public LimitQueue(int limit){  
         this.limit = limit;  
     }  
       
     /** 
      * 入队 
      * @param e 
      */  
     @Override  
     public boolean offer(E e){  
         if(queue.size() >= limit){  
             //如果超出长度,入队时,先出队  
             queue.poll();  
         }  
         return queue.offer(e);  
     }  
       
     /** 
      * 出队 
      * @return 
      */  
     @Override  
     public E poll() {  
         return queue.poll();  
     }  
       
     /** 
      * 获取队列 
      * @return 
      */  
     public Queue<E> getQueue(){  
         return queue;  
     }  
       
     /** 
      * 获取限制大小 
      * @return 
      */  
     public int getLimit(){  
         return limit;  
     }  
   
     @Override  
     public boolean add(E e) {  
         return queue.add(e);  
     }  
   
     @Override  
     public E element() {  
         return queue.element();  
     }  
   
     @Override  
     public E peek() {  
         return queue.peek();  
     }  
   
     @Override  
     public boolean isEmpty() {  
         return queue.size() == 0 ? true : false;  
     }  
   
     @Override  
     public int size() {  
         return queue.size();  
     }  
   
     @Override  
     public E remove() {  
         return queue.remove();  
     }  
   
     @Override  
     public boolean addAll(Collection<? extends E> c) {  
         return queue.addAll(c);  
     }  
   
     @Override  
     public void clear() {  
         queue.clear();  
     }  
   
     @Override  
     public boolean contains(Object o) {  
         return queue.contains(o);  
     }  
   
     @Override  
     public boolean containsAll(Collection<?> c) {  
         return queue.containsAll(c);  
     }  
   
     @Override  
     public Iterator<E> iterator() {  
         return queue.iterator();  
     }  
   
     @Override  
     public boolean remove(Object o) {  
         return queue.remove(o);  
     }  
   
     @Override  
     public boolean removeAll(Collection<?> c) {  
         return queue.removeAll(c);  
     }  
   
     @Override  
     public boolean retainAll(Collection<?> c) {  
         return queue.retainAll(c);  
     }  
   
     @Override  
     public Object[] toArray() {  
         return queue.toArray();  
     }  
   
     @Override  
     public <T> T[] toArray(T[] a) {  
         return queue.toArray(a);  
     }  
   
 }  
 

  
 
 
 package com.gary.test;  
   
 import com.gary.util.LimitQueue;  
   
 public class TestQueue {  
     public static void main(String[] args) {  
         LimitQueue<String> lqueue = new LimitQueue<String>(3);  
           
         lqueue.offer("1");  
         lqueue.offer("2");  
         lqueue.offer("3");  
         lqueue.offer("4");  
           
         //1因超出队列大小限制已自动出队,输出结果为2,3,4  
         for (String string : lqueue.getQueue()) {  
             System.out.println(string);  
         }  
     }  
 }  
 

  
 
原文链接：http://gary0416.iteye.com/blog/1074762

学习不久，理解不深。有错误之处还请指正。下面是我对java数组队列的理解。
 
什么是数组队列？
 
数组队列就是利用数组存储数据的属性来改变它只有固定长度的局限性，增加了一些删除，添加数据等功能，增加了其灵活性；
 
数组队列的实现
 
数组队列实现分为两部分：
 
1.数组队列接口
 
在数组队列接口中需要定义一些抽象方法，例如删除数据，添加数据，获取数据等方法
 
若你想存储多种类型的数据你可以使用泛型，泛型可以用来指任何类型的一种数据。下面的代码使用泛型编写的，以便于添加存储自己想要的类型数据。
 
接下来创建一个接口List<E>类，用来删除数据，添加数据，获取数据等等，下面是代码。
 
public interface List<E> {
public void add(E e);//向队列末尾添加一个元素
public boolean add(int index,E e);//向指定位置添加一个元素，添加成功返回true，添加失败返回false；
public E getE(int index);//获取指定位置的元素
public E remove(int index);//删除指位置的元素
public boolean remove(E e);//删除元素
public boolean update(int index,E e);//更新指定位置的元素
public boolean update(E e,E newValue);//更新某一个元素
public boolean removeall();//移除所有元素
public int size();//获取数组队列中元素个数的总数
}
 
 
 
2.数组队列类
 
在数组队列类中继承数组队列接口，然后要定义两个重要的属性，分别是数组长度length和元素个数size；然后在重写接口中的所有方法就可以了，关键是写好添加，删除等方法；下面的代码使用泛型编写的，以便于添加存储自己想要的类型数据。
 
下面是数组队列类myArraysList<E>的代码
 
public class myArraysList<E> implements List<E>{
	private static int size=0;//定义数组队列中元素个数的初始值,为了在数组队列类中测试下面的方法是否正确，所以设置成静态
	private static int length=1;//记录数组初始长度，为了在数组队列类中测试下面的方法是否正确，所以设置成静态
	Object [] Array;//声明一个数组变量
	public myArraysList(int length){
		this.length=length;
		Array=new Object[length];//定义数组长度为length
	}
	@Override
	public void add(E e) {//向队列末尾添加一个元素
		// TODO Auto-generated method stub
		if(size<length){//元素个数小于数组长度就添加
			Array[size]=e;
			
		}
		else{
			Object[] Array1=new Object[length*2];//Array1指定义的一个新的数组
			for(int i=0;i<length;i++){
				Array1[i]=Array[i];
			}
			Array1[size]=e;
			Array=Array1;
			length=Array1.length;
		}
		size++;
	}

	@Override
	public boolean add(int index, E e) {//向指定位置添加一个元素，添加成功返回true，添加失败返回false；
		// TODO Auto-generated method stub
		if(index<0||index>=size){
			System.out.println("超过数组的size就不能添加");
			return false;
		}
		else{
			Object []Array1=new Object[size+1];//Array1指定义的一个新的数组
			for(int i=0;i<index;i++){
				Array1[i]=Array[i];
			}
			Array1[index]=e;//把要添加的元素加入指定位置
			for(int i=index;i<size;i++){
				Array1[i+1]=Array[i];
			}
			Array=Array1;
			length=Array1.length;
			size++;
		return true;
		}
		
	}

	@SuppressWarnings("unchecked")
	@Override
	public E getE(int index) {//获取指定位置的元素
		// TODO Auto-generated method stub
		if(index<0||index>=size){
			return null;
		}
		else{
		return (E)Array[index];
		}
	}

	@Override
	public E remove(int index) {//删除指位置的元素
		// TODO Auto-generated method stub
		if(index<0||index>=size){
			System.out.println("超过数组的size就不能删除");
		}
		else{
			Array[index]=null;
			for(int i=index;i<size-1;i++){
				Array[i]=Array[i+1];
			}
			size--;
		}
		return null;
	}

	@Override
	public boolean remove(E e) {//删除元素
		// TODO Auto-generated method stub
		for(int i=0;i<size;i++){
			if(Array[i]==e){
				Array[i]=null;
				for(int j=i;j<size-1;j++){
					Array[j]=Array[j+1];
				}
				size--;
			}
		}
		return true;
	}

	@Override
	public boolean update(int index, E e) {//更新指定位置的元素
		// TODO Auto-generated method stub
		if(index>=0&&index<size){
			Array[index]=e;
			}	
		return true;
	}

	@Override
	public boolean update(E e, E newValue) {//更新某一个元素
		// TODO Auto-generated method stub
		for(int i=0;i<size;i++){
			if(Array[i]==e){
				Array[i]=newValue;
			}
		}
		return true;
	}

	@Override
	public boolean removeall() {//移除所有元素
		// TODO Auto-generated method stub
		Object []Array1=new Object[0];
		Array=Array1;
		if(Array.length ==0)
			return true;
		else
			return false;
	}

	@Override
	public int size() {//获取数组队列中元素个数的总数
		// TODO Auto-generated method stub
		return size;
	}
	public static void main(String [] args){//这里主函数是为了测试上式方法的正确性
		myArraysList<String> mylist=new myArraysList<String>(length);//创建数组队列对象myArraysList
		mylist.add("wo");
		mylist.add("xihuan");
		mylist.add("ni");
		mylist.add(2, "you");
		
		for(int i=0;i<size;i++){
			Object e=mylist.getE(i);
			System.out.println("得到的元素是："+e);
		}
		mylist.remove("you");
		mylist.update(2, "i");
		//mylist.removeall();
		for(int i=0;i<size;i++){
			Object e=mylist.getE(i);
			System.out.println("得到的元素是："+e);
		}
	}
}
 
参考：https://blog.csdn.net/weixin_42621338/article/details/82080167