PriorityBlockingQueue 和 Executors.newCachedThreadPool()
1、PriorityBlockingQueue里面存储的对象必须是实现Comparable接口。
2、队列通过这个接口的compare方法确定对象的优先级priority。
规则是：当前和其他对象比较，如果compare方法返回负数，那么在队列里面的优先级就比较高。
下面的测试可以说明这个断言：
查看打印结果，比较take出来的Entity和left的entity，比较他们的priority
public class TestPriorityQueue { static Random r=new Random(47); public static void main(String args[]){ final PriorityBlockingQueue q = new PriorityBlockingQueue(); ExecutorService se = Executors.newCachedThreadPool();
final int qTime = r.nextInt(100);
//execute producer se.execute(new Runnable(){ public void run() { int i=0; while(true){ q.put(new PriorityEntity(r.nextInt(10), i++)); //优先级，索引 try { TimeUnit.MILLISECONDS.sleep(qTime); } catch (InterruptedException e) { e.printStackTrace(); } } } }); //execute consumer se.execute(new Runnable(){ public void run() { while(true){ try {
int rTime = r.nextInt(500);
//打印进队和出队的时间可以看到队列一直在累积 System.out.println(qTime + "： " rTime + " --take-- "+q.take()+" left: "+q.size()+" -- ["+q.toString()+"]"); try { TimeUnit.MILLISECONDS.sleep(rTime); } catch (InterruptedException e) { e.printStackTrace(); } } catch (InterruptedException e) { e.printStackTrace(); } } } }); //try { // TimeUnit.SECONDS.sleep(5); //} catch (InterruptedException e) { // e.printStackTrace(); //} System.out.println("shutdown"); } } class PriorityEntity implements Comparable<PriorityEntity> { private int priority; private int index=0; public PriorityEntity(int _priority,int _index) { this.priority = _priority; this.index=_index; } public String toString(){ return "# [index="+index+" priority="+priority+"]"; } //数字小，优先级高 public int compareTo(PriorityEntity o) { return this.priority > o.priority ? 1 : this.priority < o.priority ? -1 : 0; } //数字大，优先级高 // public int compareTo(PriorityTask o) { // return this.priority < o.priority ? 1 : this.priority > o.priority ? -1 : 0; // } }
理解 newCachedThreadPool()
1、创建线程池的根源：
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)
2、使用场景：
2.1、耗时较短的任务。
2.2、任务处理速度 > 任务提交速度 ，这样才能保证不会不断创建新的进程，避免内存被占满。newCachedThreadPool可以看成newFixedThreadPool(无穷大),虽然无法限制线程总数,但是可以减少不必要的线程创建和销毁上的消耗,
3、取名为cached-threadpool的原因在于线程池中的线程是被线程池缓存了的，也就是说，线程没有任务要执行时，便处于空闲状态，处于空闲状态的线程并不会被立即销毁（会被缓存住），只有当空闲时间超出一段时间(默认为60s)后，线程池才会销毁该线程（相当于清除过时的缓存）。新任务到达后，线程池首先会让被缓存住的线程（空闲状态）去执行任务，如果没有可用线程（无空闲线程），便会创建新的线程。
4、
看一段测试代码：
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class newCachedThreadPoolTest {
public static void main(String[] args) { ExecutorService executorService = Executors.newCachedThreadPool(); for (int i = 1; i < 10000; i++) executorService.submit(new task()); } } class task implements Runnable { @Override public void run() { try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } } }
运行结果为：Exception in thread "main" java.lang.OutOfMemoryError: unable to create new native thread
可以看出来是堆外内存溢出，因为我们新建的线程都在工作（代码中用sleep表示在工作中），newCachedThreadPool 只会重用空闲并且可用的线程，所以上述代码只能不停地创建新线程，在 64-bit JDK 1.7 中 -Xss 默认是 1024k，也就是 1M，那就是需要 10000*1M = 10G 的堆外内存空间来给线程使用，但是我的机器总共就 8G 内存，不够创建新的线程，所以就 OOM 了。
所以这个newCachedThreadPool 大家一般不用就是这样的原因，因为它的最大值是在初始化的时候设置为Integer.MAX_VALUE，一般来说机器都没那么大内存给它不断使用。当然知道可能出问题的点，就可以去重写一个方法限制一下这个最大值，但是出于后期维护原因，一般来说用 newFixedThreadPool 也就足够了。
Java如何依据cpu核数设置合适的线程数
newFixedThreadPool 定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()获取cpu核心数。
executorservice pool = executors.newfixedthreadpool(runtime.getruntime().availableprocessors()*10);一般建议每cpu不超过25个线程，当然多一点也没什么问题，不过就费点线程资源.
java.lang.Runtime.availableProcessors() 方法返回到Java虚拟机的可用的处理器数量。此值可能会改变在一个特定的虚拟机调用。应用程序可用处理器的数量是敏感的，因此偶尔查询该属性，并适当地调整自己的资源使用情况.
