［转］比较Jmeter、Grinder和JAVA多线程本身压力测试所带来的性能开销

1. 测试环境

jmeter版本 ：jmeter 2.4

grinder的版本 ： Grinder 3

JAVA的版本：JDK 1.6

2. 测试代码

Jmeter测试代码

1. public class Sampler {
2. public void test() {
3. return;
4. }
5. }

1. public class JmeterTest extends AbstractJavaSamplerClient {
2. Sampler sampler;
3. @Override
4. public SampleResult runTest(JavaSamplerContext context) {
5. SampleResult results = new SampleResult();
6. results.sampleStart();
7. sampler.test();
8. results.sampleEnd();
9. results.setSuccessful(true);
10. return results;
11. }
12. @Override
13. public void setupTest(JavaSamplerContext arg0) {
14. sampler = new Sampler();
15. }
16. }

grinder测试代码

1. public class Sampler {
2. public void test() {
3. return;
4. }
5. }

1. # Test.py
2. #
3. # A minimal script that tests The Grinder logging facility.
4. #
5. # This script shows the recommended style for scripts, with a
6. # TestRunner class. The script is executed just once by each worker
7. # process and defines the TestRunner class. The Grinder creates an
8. # instance of TestRunner for each worker thread, and repeatedly calls
9. # the instance for each run of that thread.
10. from net.grinder.script.Grinder import grinder
11. from net.grinder.script import Test
12. from sampler import Sampler
13. test = Test(1, "Sample")
14. class TestRunner:
15. # This method is called for every run.
16. def __call__(self):
17. mySampler = test.wrap(Sampler())
18. mySampler.test()

Java本身多线程

1. public static void test(int numOfThreads, int times) throws InterruptedException, ExecutionException {
2. ExecutorService executor = Executors.newFixedThreadPool(numOfThreads);
3. final Sampler sampler = new Sampler();
4. List<Future<Long>> results = new ArrayList<Future<Long>>();
5. for (int i = 0; i < times; i++) {
6. results.add(executor.submit(new Callable<Long>() {
7. @Override
8. public Long call() throws Exception {
9. long begin = System.currentTimeMillis();
10. sampler.test();
11. long end = System.currentTimeMillis();
12. return end - begin;
13. }
14. }));
15. }
16. executor.shutdown();
17. while(!executor.awaitTermination(1, TimeUnit.SECONDS));
18. long sum = 0;
19. for (Future<Long> result : results) {
20. sum += result.get();
21. }
22. System.out.println("---------------------------------");
23. System.out.println("number of threads :" + numOfThreads + " times:" + times);
24. System.out.println("running time: " + sum + "ms");
25. System.out.println("TPS: " + (double)(100000 * 1000) / (double)(sum));
26. System.out.println();
27. }

3. 测试结果

10个线程 100000次运行

--	TPS
Jmeter	50426.10
Grinder	290275.76
Java threads	2.5E7

20个线程 100000次运行

--	TPS
Jmeter	49215.02
Grinder	225402.91
Java threads	2.5E7

50个线程 100000次运行

--	TPS
Jmeter	29312.61
Grinder	212242.13
Java threads	2.5E7

100个线程 100000次运行

--	TPS
Jmeter	29031.03
Grinder	245507.22
Java threads	2.5E7

200个线程 10000次运行(这里减少了一个0)

--	TPS
Jmeter	28039.87
Grinder	232801.77
Java threads	2.5E7

300个线程 10000次运行

--	TPS
Jmeter	27208.16
Grinder	236537.10
Java threads	1818181.81

1000个线程 10000次运行

--	TPS
Jmeter	27208.16
Grinder	236537.10
Java threads	2.5E7

4. 结论

1. 可以看出Jmeter的本身性能开销是很大的，只适合一般应用的性能测试
2. Grinder在测试的时候发现上下文切换比较严重，而可能是因为内部机制导致的开销较大的，当然如果测试memcache肯定是不适合的，但一般的应用测试基本上没有问题
3. JAVA多线程本身并发框架性能开销也是有的，但是比较低，适合要求较高的性能测试，如对redis和memcache构建的应用进行压测

转：http://blog.csdn.net/techq/article/details/6628533