这个问题尽管看起来很小，却并不那么容易答复。
大家如果有更好的办法欢送赐教，先来一个天真的估算办法：
假如要求一个零碎的TPS（Transaction Per Second或者Task Per Second）至多为20，而后假如每个Transaction由一个线程实现，持续假如均匀每个线程解决一个Transaction的工夫为4s。
那么问题转化为：如何设计线程池大小，使得能够在1s内解决完20个Transaction？
计算过程很简略，每个线程的解决能力为0.25TPS，那么要达到20TPS，显然须要20/0.25=80个线程。
很显然这个估算办法很天真，因为它没有思考到CPU数目。个别服务器的CPU核数为16或者32，如果有80个线程，那么必定会带来太多不必要的线程上下文切换开销。
再来第二种简略的但不知是否可行的办法（N为CPU总核数）：
- 如果是CPU密集型利用，则线程池大小设置为N+1
- 如果是IO密集型利用，则线程池大小设置为2N+1
如果一台服务器上只部署这一个利用并且只有这一个线程池，那么这种估算或者正当，具体还需自行测试验证。
接下来在这个文档：服务器性能IO优化 中发现一个估算公式：
最佳线程数目 = （（线程等待时间+线程CPU工夫）/线程CPU工夫 ）* CPU数目
比方均匀每个线程CPU运行工夫为0.5s，而线程等待时间（非CPU运行工夫，比方IO）为1.5s，CPU外围数为8，那么依据下面这个公式估算失去：((0.5+1.5)/0.5)*8=32。这个公式进一步转化为：
最佳线程数目 = （线程等待时间与线程CPU工夫之比 + 1）* CPU数目
能够得出一个论断：线程等待时间所占比例越高，须要越多线程。线程CPU工夫所占比例越高，须要越少线程。
上一种估算办法也和这个论断相合。
一个零碎最快的局部是CPU，所以决定一个零碎吞吐量下限的是CPU。加强CPU解决能力，能够进步零碎吞吐量下限。但依据短板效应，实在的零碎吞吐量并不能单纯依据CPU来计算。那要进步零碎吞吐量，就须要从“零碎短板”（比方网络提早、IO）着手：
- 尽量进步短板操作的并行化比率，比方多线程下载技术
- 加强短板能力，比方用NIO代替IO
第一条能够分割到Amdahl定律，这条定律定义了串行零碎并行化后的减速比计算公式：
减速比=优化前零碎耗时 / 优化后零碎耗时
减速比越大，表明零碎并行化的优化成果越好。Addahl定律还给出了零碎并行度、CPU数目和减速比的关系，减速比为Speedup，零碎串行化比率（指串行执行代码所占比率）为F，CPU数目为N：
Speedup <= 1 / (F + (1-F)/N)当N足够大时，串行化比率F越小，减速比Speedup越大。
写到这里，我忽然冒出一个问题。
是否应用线程池就肯定比应用单线程高效呢？
答案是否定的，比方Redis就是单线程的，但它却十分高效，基本操作都能达到十万量级/s。从线程这个角度来看，局部起因在于：
- 多线程带来线程上下文切换开销，单线程就没有这种开销
- 锁
当然“Redis很快”更实质的起因在于：Redis根本都是内存操作，这种状况下单线程能够很高效地利用CPU。而多线程实用场景个别是：存在相当比例的IO和网络操作。
所以即便有下面的简略估算办法，兴许看似正当，但实际上也未必正当，都须要联合零碎真实情况（比方是IO密集型或者是CPU密集型或者是纯内存操作）和硬件环境（CPU、内存、硬盘读写速度、网络情况等）来一直尝试达到一个符合实际的正当估算值。
最初来一个“Dark Magic”估算办法（因为我临时还没有搞懂它的原理），应用上面的类：
package threadpool;import java.math.BigDecimal;import java.math.RoundingMode;import java.util.Timer;import java.util.TimerTask;import java.util.concurrent.BlockingQueue;/** * A class that calculates the optimal thread pool boundaries. It takes the * desired target utilization and the desired work queue memory consumption as * input and retuns thread count and work queue capacity. * * @author Niklas Schlimm */public abstract class PoolSizeCalculator { /** * The sample queue size to calculate the size of a single {@link Runnable} * element. */ private final int SAMPLE_QUEUE_SIZE = 1000; /** * Accuracy of test run. It must finish within 20ms of the testTime * otherwise we retry the test. This could be configurable. */ private final int EPSYLON = 20; /** * Control variable for the CPU time investigation. */ private volatile boolean expired; /** * Time (millis) of the test run in the CPU time calculation. */ private final long testtime = 3000; /** * Calculates the boundaries of a thread pool for a given {@link Runnable}. * * @param targetUtilization the desired utilization of the CPUs (0 <= targetUtilization <= * 1) * @param targetQueueSizeBytes * the desired maximum work queue size of the thread pool (bytes) */ protected void calculateBoundaries(BigDecimal targetUtilization, BigDecimal targetQueueSizeBytes) { calculateOptimalCapacity(targetQueueSizeBytes); Runnable task = creatTask(); start(task); start(task); // warm up phase long cputime = getCurrentThreadCPUTime(); start(task); // test intervall cputime = getCurrentThreadCPUTime() - cputime; long waittime = (testtime * 1000000) - cputime; calculateOptimalThreadCount(cputime, waittime, targetUtilization); } private void calculateOptimalCapacity(BigDecimal targetQueueSizeBytes) { long mem = calculateMemoryUsage(); BigDecimal queueCapacity = targetQueueSizeBytes.divide(new BigDecimal(mem), RoundingMode.HALF_UP); System.out.println("Target queue memory usage (bytes): " + targetQueueSizeBytes); System.out.println("createTask() produced " + creatTask().getClass().getName() + " which took " + mem + " bytes in a queue"); System.out.println("Formula: " + targetQueueSizeBytes + " / " + mem); System.out.println("* Recommended queue capacity (bytes): " + queueCapacity); } /** * Brian Goetz' optimal thread count formula, see 'Java Concurrency in * * Practice' (chapter 8.2) * * * @param cpu * * cpu time consumed by considered task * * @param wait * * wait time of considered task * * @param targetUtilization * * target utilization of the system */ private void calculateOptimalThreadCount(long cpu, long wait, BigDecimal targetUtilization) { BigDecimal waitTime = new BigDecimal(wait); BigDecimal computeTime = new BigDecimal(cpu); BigDecimal numberOfCPU = new BigDecimal(Runtime.getRuntime() .availableProcessors()); BigDecimal optimalthreadcount = numberOfCPU.multiply(targetUtilization) .multiply(new BigDecimal(1).add(waitTime.divide(computeTime, RoundingMode.HALF_UP))); System.out.println("Number of CPU: " + numberOfCPU); System.out.println("Target utilization: " + targetUtilization); System.out.println("Elapsed time (nanos): " + (testtime * 1000000)); System.out.println("Compute time (nanos): " + cpu); System.out.println("Wait time (nanos): " + wait); System.out.println("Formula: " + numberOfCPU + " * " + targetUtilization + " * (1 + " + waitTime + " / " + computeTime + ")"); System.out.println("* Optimal thread count: " + optimalthreadcount); } /** * * Runs the {@link Runnable} over a period defined in {@link #testtime}. * * Based on Heinz Kabbutz' ideas * * (http://www.javaspecialists.eu/archive/Issue124.html). * * * * @param task * * the runnable under investigation */ public void start(Runnable task) { long start = 0; int runs = 0; do { if (++runs > 5) { throw new IllegalStateException("Test not accurate"); } expired = false; start = System.currentTimeMillis(); Timer timer = new Timer(); timer.schedule(new TimerTask() { public void run() { expired = true; } }, testtime); while (!expired) { task.run(); } start = System.currentTimeMillis() - start; timer.cancel(); } while (Math.abs(start - testtime) > EPSYLON); collectGarbage(3); } private void collectGarbage(int times) { for (int i = 0; i < times; i++) { System.gc(); try { Thread.sleep(10); } catch (InterruptedException e) { Thread.currentThread().interrupt(); break; } } } /** * Calculates the memory usage of a single element in a work queue. Based on * Heinz Kabbutz' ideas * (http://www.javaspecialists.eu/archive/Issue029.html). * * @return memory usage of a single {@link Runnable} element in the thread * pools work queue */ public long calculateMemoryUsage() { BlockingQueue queue = createWorkQueue(); for (int i = 0; i < SAMPLE_QUEUE_SIZE; i++) { queue.add(creatTask()); } long mem0 = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory(); long mem1 = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory(); queue = null; collectGarbage(15); mem0 = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory(); queue = createWorkQueue(); for (int i = 0; i < SAMPLE_QUEUE_SIZE; i++) { queue.add(creatTask()); } collectGarbage(15); mem1 = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory(); return (mem1 - mem0) / SAMPLE_QUEUE_SIZE; } /** * Create your runnable task here. * * @return an instance of your runnable task under investigation */ protected abstract Runnable creatTask(); /** * Return an instance of the queue used in the thread pool. * * @return queue instance */ protected abstract BlockingQueue createWorkQueue(); /** * Calculate current cpu time. Various frameworks may be used here, * depending on the operating system in use. (e.g. * http://www.hyperic.com/products/sigar). The more accurate the CPU time * measurement, the more accurate the results for thread count boundaries. * * @return current cpu time of current thread */ protected abstract long getCurrentThreadCPUTime();}而后本人继承这个抽象类并实现它的三个形象办法，比方上面是我写的一个示例（工作是申请网络数据），其中我指定冀望CPU利用率为1.0（即100%），工作队列总大小不超过100,000字节：
package threadpool;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.lang.management.ManagementFactory;import java.math.BigDecimal;import java.net.HttpURLConnection;import java.net.URL;import java.util.concurrent.BlockingQueue;import java.util.concurrent.LinkedBlockingQueue;public class SimplePoolSizeCaculatorImpl extends PoolSizeCalculator { @Override protected Runnable creatTask() { return new AsyncIOTask(); } @Override protected BlockingQueue createWorkQueue() { return new LinkedBlockingQueue(1000); } @Override protected long getCurrentThreadCPUTime() { return ManagementFactory.getThreadMXBean().getCurrentThreadCpuTime(); } public static void main(String[] args) { PoolSizeCalculator poolSizeCalculator = new SimplePoolSizeCaculatorImpl(); poolSizeCalculator.calculateBoundaries(new BigDecimal(1.0), new BigDecimal(100000)); }}/** * 自定义的异步IO工作 * @author Will * */class AsyncIOTask implements Runnable { public void run() { HttpURLConnection connection = null; BufferedReader reader = null; try { String getURL = "http://baidu.com"; URL getUrl = new URL(getURL); connection = (HttpURLConnection) getUrl.openConnection(); connection.connect(); reader = new BufferedReader(new InputStreamReader( connection.getInputStream())); String line; while ((line = reader.readLine()) != null) { // empty loop } } catch (IOException e) { } finally { if(reader != null) { try { reader.close(); } catch(Exception e) { } } connection.disconnect(); } }}失去如下输入：
Target queue memory usage (bytes): 100000createTask() produced threadpool.AsyncIOTask which took 40 bytes in a queueFormula: 100000 / 40* Recommended queue capacity (bytes): 2500Number of CPU: 8Target utilization: 1Elapsed time (nanos): 3000000000Compute time (nanos): 280801800Wait time (nanos): 2719198200Formula: 8 * 1 * (1 + 2719198200 / 280801800)* Optimal thread count: 88举荐的工作队列大小为2500，线程数为88。顺次为根据，咱们就能够结构这样一个线程池：
ThreadPoolExecutor pool = new ThreadPoolExecutor(88, 88, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(2500));能够将这个文件打包成可执行的jar文件，这样就能够拷贝到测试/正式环境上执行。
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>threadpool</groupId> <artifactId>dark-magic</artifactId> <version>1.0-SNAPSHOT</version> <packaging>jar</packaging> <name>dark_magic</name> <url>http://maven.apache.org</url> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> </properties> <dependencies> </dependencies> <build> <finalName>dark-magic</finalName> <plugins> <plugin> <artifactId>maven-assembly-plugin</artifactId> <configuration> <appendAssemblyId>false</appendAssemblyId> <descriptorRefs> <descriptorRef>jar-with-dependencies</descriptorRef> </descriptorRefs> <archive> <manifest> <!-- 此处指定main办法入口的class --> <mainClass>threadpool.SimplePoolSizeCaculatorImpl</mainClass> </manifest> </archive> </configuration> <executions> <execution> <id>make-assembly</id> <phase>package</phase> <goals> <goal>assembly</goal> </goals> </execution> </executions> </plugin> </plugins> </build></project>起源：
www.cnblogs.com/cjsblog/p/9068886.html
参考：
http://ifeve.com/how-to-calcu...\
http://www.importnew.com/1738...\
https://www.cnblogs.com/cheri...
近期热文举荐：
1.Java 15 正式公布， 14 个新个性，刷新你的认知！！
2.终于靠开源我的项目弄到 IntelliJ IDEA 激活码了，真香！
3.我用 Java 8 写了一段逻辑，共事直呼看不懂，你试试看。。
4.吊打 Tomcat ，Undertow 性能很炸！！
5.《Java开发手册（嵩山版）》最新公布，速速下载！
感觉不错，别忘了顺手点赞+转发哦！