`
m635674608
  • 浏览: 4934886 次
  • 性别: Icon_minigender_1
  • 来自: 南京
社区版块
存档分类
最新评论

如何合理地估算线程池大小？

    博客分类：
  • java
 
阅读更多

 这个问题虽然看起来很小，却并不那么容易回答。大家如果有更好的方法欢迎赐教，^_^

    先来一个天真的估算方法：假设要求一个系统的TPS（Transaction Per Second或者Task Per Second）至少为20，然后假设每个Transaction由一个线程完成，继续假设平均每个线程处理一个Transaction的时间为4s。那么问题转化为：

1 如何设计线程池大小，使得可以在1s内处理完20个Transaction？

    计算过程很简单，每个线程的处理能力为0.25TPS，那么要达到20TPS，显然需要20/0.25=80个线程。

    很显然这个估算方法很天真，因为它没有考虑到CPU数目。一般服务器的CPU核数为16或者32，如果有80个线程，那么肯定会带来太多不必要的线程上下文切换开销。

    再来第二种简单的但不知是否可行的方法（N为CPU总核数）：

  • 如果是CPU密集型应用，则线程池大小设置为N+1
  • 如果是IO密集型应用，则线程池大小设置为2N+1

    如果一台服务器上只部署了这一个应用并且只有这一个线程池，那么这种估算或许合理，具体还需自行测试验证。

    接下来在这个文档：服务器性能IO优化 中发现一个估算公式：

1 最佳线程数目 = （（线程等待时间+线程CPU时间）/线程CPU时间 ）* CPU数目

    比如平均每个线程CPU运行时间为0.5s，而线程等待时间（非CPU运行时间，比如IO）为1.5s，CPU核心数为8，那么根据上面这个公式估算得到：((0.5+1.5)/0.5)*8=32。这个公式进一步转化为：

1 最佳线程数目 = （线程等待时间与线程CPU时间之比 + 1）* CPU数目

    可以得出一个结论：

1 线程等待时间所占比例越高，需要越多线程。
2 线程CPU时间所占比例越高，需要越少线程。

    上一种估算方法也和这个结论相合。

    一个系统最快的部分是CPU，所以决定一个系统吞吐量上限的是CPU。增强CPU处理能力，可以提高系统吞吐量上限。但根据短板效应，真实的系统吞吐量并不能单纯根据CPU来计算。那要提高系统吞吐量，就需要从“系统短板”（比如网络延迟、IO）着手：

  • 尽量提高短板操作的并行化比率，比如多线程下载技术
  • 增强短板能力，比如用NIO替代IO

    第一条可以联系到Amdahl定律，这条定律定义了串行系统并行化后的加速比计算公式：

1 加速比=优化前系统耗时 / 优化后系统耗时

     加速比越大，表明系统并行化的优化效果越好。Addahl定律还给出了系统并行度、CPU数目和加速比的关系，加速比为Speedup，系统串行化比率（指串行执行代码所占比率）为F，CPU数目为N：

1 Speedup <= 1 / (F + (1-F)/N)

    当N足够大时，串行化比率F越小，加速比Speedup越大。

    写到这里，我突然冒出一个问题。

    是否使用线程池就一定比使用单线程高效呢？

    答案是否定的，比如Redis就是单线程的，但它却非常高效，基本操作都能达到十万量级/s。从线程这个角度来看，部分原因在于：

 

  • 多线程带来线程上下文切换开销，单线程就没有这种开销
  • 锁

    当然“Redis很快”更本质的原因在于：Redis基本都是内存操作，这种情况下单线程可以很高效地利用CPU。而多线程适用场景一般是：存在相当比例的IO和网络操作。

    所以即使有上面的简单估算方法，也许看似合理，但实际上也未必合理，都需要结合系统真实情况（比如是IO密集型或者是CPU密集型或者是纯内存操作）和硬件环境（CPU、内存、硬盘读写速度、网络状况等）来不断尝试达到一个符合实际的合理估算值。

    最后来一个“Dark Magic”估算方法（因为我暂时还没有搞懂它的原理），使用下面的类：

 

001 package pool_size_calculate;
002  
003 import java.math.BigDecimal;
004 import java.math.RoundingMode;
005 import java.util.Timer;
006 import java.util.TimerTask;
007 import java.util.concurrent.BlockingQueue;
008  
009 /**
010  * A class that calculates the optimal thread pool boundaries. It takes the
011  * desired target utilization and the desired work queue memory consumption as
012  * input and retuns thread count and work queue capacity.
013  *
014  * @author Niklas Schlimm
015  *
016  */
017 public abstract class PoolSizeCalculator {
018  
019     /**
020      * The sample queue size to calculate the size of a single {@link Runnable}
021      * element.
022      */
023     private final int SAMPLE_QUEUE_SIZE = 1000;
024  
025     /**
026      * Accuracy of test run. It must finish within 20ms of the testTime
027      * otherwise we retry the test. This could be configurable.
028      */
029     private final int EPSYLON = 20;
030  
031     /**
032      * Control variable for the CPU time investigation.
033      */
034     private volatile boolean expired;
035  
036     /**
037      * Time (millis) of the test run in the CPU time calculation.
038      */
039     private final long testtime = 3000;
040  
041     /**
042      * Calculates the boundaries of a thread pool for a given {@link Runnable}.
043      *
044      * @param targetUtilization
045      *            the desired utilization of the CPUs (0 <= targetUtilization <=
046      *            1)
047      * @param targetQueueSizeBytes
048      *            the desired maximum work queue size of the thread pool (bytes)
049      */
050     protected void calculateBoundaries(BigDecimal targetUtilization,
051             BigDecimal targetQueueSizeBytes) {
052         calculateOptimalCapacity(targetQueueSizeBytes);
053         Runnable task = creatTask();
054         start(task);
055         start(task); // warm up phase
056         long cputime = getCurrentThreadCPUTime();
057         start(task); // test intervall
058         cputime = getCurrentThreadCPUTime() - cputime;
059         long waittime = (testtime * 1000000) - cputime;
060         calculateOptimalThreadCount(cputime, waittime, targetUtilization);
061     }
062  
063     private void calculateOptimalCapacity(BigDecimal targetQueueSizeBytes) {
064         long mem = calculateMemoryUsage();
065         BigDecimal queueCapacity = targetQueueSizeBytes.divide(new BigDecimal(
066                 mem), RoundingMode.HALF_UP);
067         System.out.println("Target queue memory usage (bytes): "
068                 + targetQueueSizeBytes);
069         System.out.println("createTask() produced "
070                 + creatTask().getClass().getName() + " which took " + mem
071                 + " bytes in a queue");
072         System.out.println("Formula: " + targetQueueSizeBytes + " / " + mem);
073         System.out.println("* Recommended queue capacity (bytes): "
074                 + queueCapacity);
075     }
076  
077     /**
078      * Brian Goetz' optimal thread count formula, see 'Java Concurrency in
079      * Practice' (chapter 8.2)
080      *
081      * @param cpu
082      *            cpu time consumed by considered task
083      * @param wait
084      *            wait time of considered task
085      * @param targetUtilization
086      *            target utilization of the system
087      */
088     private void calculateOptimalThreadCount(long cpu, long wait,
089             BigDecimal targetUtilization) {
090         BigDecimal waitTime = new BigDecimal(wait);
091         BigDecimal computeTime = new BigDecimal(cpu);
092         BigDecimal numberOfCPU = new BigDecimal(Runtime.getRuntime()
093                 .availableProcessors());
094         BigDecimal optimalthreadcount = numberOfCPU.multiply(targetUtilization)
095                 .multiply(
096                         new BigDecimal(1).add(waitTime.divide(computeTime,
097                                 RoundingMode.HALF_UP)));
098         System.out.println("Number of CPU: " + numberOfCPU);
099         System.out.println("Target utilization: " + targetUtilization);
100         System.out.println("Elapsed time (nanos): " + (testtime * 1000000));
101         System.out.println("Compute time (nanos): " + cpu);
102         System.out.println("Wait time (nanos): " + wait);
103         System.out.println("Formula: " + numberOfCPU + " * "
104                 + targetUtilization + " * (1 + " + waitTime + " / "
105                 + computeTime + ")");
106         System.out.println("* Optimal thread count: " + optimalthreadcount);
107     }
108  
109     /**
110      * Runs the {@link Runnable} over a period defined in {@link #testtime}.
111      * Based on Heinz Kabbutz' ideas
112      * (http://www.javaspecialists.eu/archive/Issue124.html).
113      *
114      * @param task
115      *            the runnable under investigation
116      */
117     public void start(Runnable task) {
118         long start = 0;
119         int runs = 0;
120         do {
121             if (++runs > 5) {
122                 throw new IllegalStateException("Test not accurate");
123             }
124             expired = false;
125             start = System.currentTimeMillis();
126             Timer timer = new Timer();
127             timer.schedule(new TimerTask() {
128                 public void run() {
129                     expired = true;
130                 }
131             }, testtime);
132             while (!expired) {
133                 task.run();
134             }
135             start = System.currentTimeMillis() - start;
136             timer.cancel();
137         } while (Math.abs(start - testtime) > EPSYLON);
138         collectGarbage(3);
139     }
140  
141     private void collectGarbage(int times) {
142         for (int i = 0; i < times; i++) {
143             System.gc();
144             try {
145                 Thread.sleep(10);
146             } catch (InterruptedException e) {
147                 Thread.currentThread().interrupt();
148                 break;
149             }
150         }
151     }
152  
153     /**
154      * Calculates the memory usage of a single element in a work queue. Based on
155      * Heinz Kabbutz' ideas
156      * (http://www.javaspecialists.eu/archive/Issue029.html).
157      *
158      * @return memory usage of a single {@link Runnable} element in the thread
159      *         pools work queue
160      */
161     public long calculateMemoryUsage() {
162         BlockingQueue<Runnable> queue = createWorkQueue();
163         for (int i = 0; i < SAMPLE_QUEUE_SIZE; i++) {
164             queue.add(creatTask());
165         }
166         long mem0 = Runtime.getRuntime().totalMemory()
167                 - Runtime.getRuntime().freeMemory();
168         long mem1 = Runtime.getRuntime().totalMemory()
169                 - Runtime.getRuntime().freeMemory();
170         queue = null;
171         collectGarbage(15);
172         mem0 = Runtime.getRuntime().totalMemory()
173                 - Runtime.getRuntime().freeMemory();
174         queue = createWorkQueue();
175         for (int i = 0; i < SAMPLE_QUEUE_SIZE; i++) {
176             queue.add(creatTask());
177         }
178         collectGarbage(15);
179         mem1 = Runtime.getRuntime().totalMemory()
180                 - Runtime.getRuntime().freeMemory();
181         return (mem1 - mem0) / SAMPLE_QUEUE_SIZE;
182     }
183  
184     /**
185      * Create your runnable task here.
186      *
187      * @return an instance of your runnable task under investigation
188      */
189     protected abstract Runnable creatTask();
190  
191     /**
192      * Return an instance of the queue used in the thread pool.
193      *
194      * @return queue instance
195      */
196     protected abstract BlockingQueue<Runnable> createWorkQueue();
197  
198     /**
199      * Calculate current cpu time. Various frameworks may be used here,
200      * depending on the operating system in use. (e.g.
201      * http://www.hyperic.com/products/sigar). The more accurate the CPU time
202      * measurement, the more accurate the results for thread count boundaries.
203      *
204      * @return current cpu time of current thread
205      */
206     protected abstract long getCurrentThreadCPUTime();
207  
208 }

    然后自己继承这个抽象类并实现它的三个抽象方法，比如下面是我写的一个示例（任务是请求网络数据），其中我指定期望CPU利用率为1.0，任务队列总大小不超过100,000字节：

 

01 package pool_size_calculate;
02  
03 import java.io.BufferedReader;
04 import java.io.IOException;
05 import java.io.InputStreamReader;
06 import java.lang.management.ManagementFactory;
07 import java.math.BigDecimal;
08 import java.net.HttpURLConnection;
09 import java.net.URL;
10 import java.util.concurrent.BlockingQueue;
11 import java.util.concurrent.LinkedBlockingQueue;
12  
13 public class SimplePoolSizeCaculatorImpl extends PoolSizeCalculator {
14  
15     @Override
16     protected Runnable creatTask() {
17         return new AsyncIOTask();
18     }
19  
20     @Override
21     protected BlockingQueue<Runnable> createWorkQueue() {
22         return new LinkedBlockingQueue<Runnable>(1000);
23     }
24  
25     @Override
26     protected long getCurrentThreadCPUTime() {
27         return ManagementFactory.getThreadMXBean().getCurrentThreadCpuTime();
28     }
29      
30     public static void main(String[] args) {
31         PoolSizeCalculator poolSizeCalculator = new SimplePoolSizeCaculatorImpl();
32         poolSizeCalculator.calculateBoundaries(new BigDecimal(1.0), new BigDecimal(100000));
33     }
34  
35 }
36  
37 /**
38  * 自定义的异步IO任务
39  * @author Will
40  *
41  */
42 class AsyncIOTask implements Runnable {
43  
44     @Override
45     public void run() {
46         HttpURLConnection connection = null;
47         BufferedReader reader = null;
48         try {
49             String getURL = "http://baidu.com";
50             URL getUrl = new URL(getURL);
51  
52             connection = (HttpURLConnection) getUrl.openConnection();
53             connection.connect();
54             reader = new BufferedReader(new InputStreamReader(
55                     connection.getInputStream()));
56  
57             String line;
58             while ((line = reader.readLine()) != null) {
59                 // empty loop
60             }
61         }
62  
63         catch (IOException e) {
64  
65         } finally {
66             if(reader != null) {
67                 try {
68                     reader.close();
69                 }
70                 catch(Exception e) {
71                      
72                 }
73             }
74             connection.disconnect();
75         }
76  
77     }
78  
79 }

    得到的输出如下：

 

view source
 
print?
01 Target queue memory usage (bytes): 100000
02 createTask() produced pool_size_calculate.AsyncIOTask which took 40 bytes in a queue
03 Formula: 100000 / 40
04 * Recommended queue capacity (bytes): 2500
05 Number of CPU: 4
06 Target utilization: 1
07 Elapsed time (nanos): 3000000000
08 Compute time (nanos): 47181000
09 Wait time (nanos): 2952819000
10 Formula: 4 * 1 * (1 + 2952819000 / 47181000)
11 * Optimal thread count: 256

   推荐的任务队列大小为2500，线程数为256，有点出乎意料之外。我可以如下构造一个线程池：

 

1 ThreadPoolExecutor pool = new ThreadPoolExecutor(256, 256, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(2500));

    转载：http://my.oschina.net/feichexia/blog/210160

分享到：
| Java 获得方法调用者名称
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    如何合理估算 Java 线程池大小：综合指南.pdf

    如何合理估算 Java 线程池大小：综合指南.

    知识点估算无理数的大小.pdf

    知识点估算无理数的大小.pdf

    露营地项目投资估算明细表.pdf

    露营地项目投资估算明细表.pdf

    如何以工时估算软件项目？

    关于在设计就绪之前进行估算的一些想法。

    软件估算软件估算软件估算

    软件估算软件估算软件估算软件估算软件估算软件估算软件估算软件估算软件估算软件估算软件估算软件估算

    在SQL SERVER中估算堆大小.pdf

    在SQL SERVER中估算堆大小.pdf

    服务器配置估算.docx

    服务器配置估算全文共1页，当前为第1页。服务器配置估算全文共1页，当前为第1页。 服务器配置估算全文共1页，当前为第1页。 服务器配置估算全文共1页，当前为第1页。 前置预设条件： 以深圳标高清30万用户量核算。 ...

    项目管理之活动持续时间估算.xlsx

    估算活动持续时间是根据资源估算的结果，估算每个活动需要的工作时段的数据的过程，其作用是确定完成每个活动所需花费的时间量，为制订进度计划过程提供主要输入。估算方法主要有： ① 类比估算：根据历史项目的数据...

    常用设计编程工具 NOVEX切削数据估算.zip

    常用设计编程工具 NOVEX切削数据估算.zip常用设计编程工具 NOVEX切削数据估算.zip常用设计编程工具 NOVEX切削数据估算.zip常用设计编程工具 NOVEX切削数据估算.zip常用设计编程工具 NOVEX切削数据估算.zip常用设计...

    软件估算——“黑匣子”揭秘

    作者在深入浅出地介绍了与软件估算有关的主要概念之后，深入、全面地介绍了与软件估算有关的多种估算方法。　本书的主要内容包括：估算与计划和项目控制，以及估算与目标和承诺之间的关系；不确定性锥与估算中的误差...

    估算无理数的大小.doc

    估算无理数的大小.doc

    软件项目工作量估算方法研究与应用

    目前常用的软件项目工作量估算方法都无法简单准确地估算项目工作量。本文采用三步法对项目工作量进行估算,第一步选择一个简单的模型;第二步使用样本数据对模型常数进行标定;第三步采用类比方法对标定模型和实际项目...

    银行个人储蓄系统规模成本估算

    银行个人储蓄系统规模成本估算银行个人储蓄系统规模成本估算银行个人储蓄系统规模成本估算

    软件系统规模估算方法论介绍-功能点分析法

    本文不是泛泛的理论介绍，而是从实际应用角度出发，对功能点...基于技术视角的评估方法更多地局限于软件开发团队内部，由经验丰富的技术人员估算，经常也被称之为专家估算法。这种估算法标准很难量化和达成一致，不同

    软件成本估算方法及应用

    软件成本估算从20 世纪60 年代发展至今,在软件开发过程中一直扮演着重要角色.按照基于算法模 型的方法非基于算法模型的方法以及组合方法的分类方式,全面回顾分析了软件成本估算的各种代表性方 法,也归纳讨论了与成本...

    测试估算是什么

    测试估算是进行测试计划的基础，除了这个，我们对测试估算，还了解多少？

Magicbox
Global site tag (gtag.js) - Google Analytics