Java多线程效率-素数计算

方兆国

下面是经过优化的Java多线程运行的结果，线程数从1-39

1. 
   
2. JavaPure 1Mix线程实现：
   
3. Number of primes under 10000000 is  664579
   
4. Time taken is 27.441059013 s
   
5. 
   
6. JavaPure 2Mix线程实现：
   
7. Number of primes under 10000000 is  664579
   
8. Time taken is 15.002512164 s
   
9. 
   
10. JavaPure 3Mix线程实现：
    
11. Number of primes under 10000000 is  664579
    
12. Time taken is 14.666844501 s
    
13. 
    
14. JavaPure 4Mix线程实现：
    
15. Number of primes under 10000000 is  664579
    
16. Time taken is 10.94517485 s
    
17. 
    
18. JavaPure 5Mix线程实现：
    
19. Number of primes under 10000000 is  664579
    
20. Time taken is 10.898218614 s
    
21. 
    
22. JavaPure 6Mix线程实现：
    
23. Number of primes under 10000000 is  664579
    
24. Time taken is 10.920853457 s
    
25. 
    
26. JavaPure 7Mix线程实现：
    
27. Number of primes under 10000000 is  664579
    
28. Time taken is 11.044363006 s
    
29. 
    
30. JavaPure 8Mix线程实现：
    
31. Number of primes under 10000000 is  664579
    
32. Time taken is 10.770187893 s
    
33. 
    
34. JavaPure 9Mix线程实现：
    
35. Number of primes under 10000000 is  664579
    
36. Time taken is 10.744386465 s
    
37. 
    
38. JavaPure 10Mix线程实现：
    
39. Number of primes under 10000000 is  664579
    
40. Time taken is 10.678533515 s
    
41. 
    
42. JavaPure 11Mix线程实现：
    
43. Number of primes under 10000000 is  664579
    
44. Time taken is 10.672157318 s
    
45. 
    
46. JavaPure 12Mix线程实现：
    
47. Number of primes under 10000000 is  664579
    
48. Time taken is 10.654416373 s
    
49. 
    
50. JavaPure 13Mix线程实现：
    
51. Number of primes under 10000000 is  664579
    
52. Time taken is 10.673098418 s
    
53. 
    
54. JavaPure 14Mix线程实现：
    
55. Number of primes under 10000000 is  664579
    
56. Time taken is 10.874618216 s
    
57. 
    
58. JavaPure 15Mix线程实现：
    
59. Number of primes under 10000000 is  664579
    
60. Time taken is 10.919771963 s
    
61. 
    
62. JavaPure 16Mix线程实现：
    
63. Number of primes under 10000000 is  664579
    
64. Time taken is 10.735419301 s
    
65. 
    
66. JavaPure 17Mix线程实现：
    
67. Number of primes under 10000000 is  664579
    
68. Time taken is 10.700124453 s
    
69. 
    
70. JavaPure 18Mix线程实现：
    
71. Number of primes under 10000000 is  664579
    
72. Time taken is 10.784798483 s
    
73. 
    
74. JavaPure 19Mix线程实现：
    
75. Number of primes under 10000000 is  664579
    
76. Time taken is 10.903189502 s
    
77. 
    
78. JavaPure 20Mix线程实现：
    
79. Number of primes under 10000000 is  664579
    
80. Time taken is 10.721297829 s
    
81. 
    
82. JavaPure 21Mix线程实现：
    
83. Number of primes under 10000000 is  664579
    
84. Time taken is 10.691479292 s
    
85. 
    
86. JavaPure 22Mix线程实现：
    
87. Number of primes under 10000000 is  664579
    
88. Time taken is 10.649655172 s
    
89. 
    
90. JavaPure 23Mix线程实现：
    
91. Number of primes under 10000000 is  664579
    
92. Time taken is 10.646989932 s
    
93. 
    
94. JavaPure 24Mix线程实现：
    
95. Number of primes under 10000000 is  664579
    
96. Time taken is 10.739623451 s
    
97. 
    
98. JavaPure 25Mix线程实现：
    
99. Number of primes under 10000000 is  664579
    
100. Time taken is 10.714967826 s
     
101. 
     
102. JavaPure 26Mix线程实现：
     
103. Number of primes under 10000000 is  664579
     
104. Time taken is 10.703481252 s
     
105. 
     
106. JavaPure 27Mix线程实现：
     
107. Number of primes under 10000000 is  664579
     
108. Time taken is 10.658188017 s
     
109. 
     
110. JavaPure 28Mix线程实现：
     
111. Number of primes under 10000000 is  664579
     
112. Time taken is 10.696676172 s
     
113. 
     
114. JavaPure 29Mix线程实现：
     
115. Number of primes under 10000000 is  664579
     
116. Time taken is 10.730198419 s
     
117. 
     
118. JavaPure 30Mix线程实现：
     
119. Number of primes under 10000000 is  664579
     
120. Time taken is 10.634209912 s
     
121. 
     
122. JavaPure 31Mix线程实现：
     
123. Number of primes under 10000000 is  664579
     
124. Time taken is 10.650298271 s
     
125. 
     
126. JavaPure 32Mix线程实现：
     
127. Number of primes under 10000000 is  664579
     
128. Time taken is 10.652929998 s
     
129. 
     
130. JavaPure 33Mix线程实现：
     
131. Number of primes under 10000000 is  664579
     
132. Time taken is 10.662882191 s
     
133. 
     
134. JavaPure 34Mix线程实现：
     
135. Number of primes under 10000000 is  664579
     
136. Time taken is 10.700259414 s
     
137. 
     
138. JavaPure 35Mix线程实现：
     
139. Number of primes under 10000000 is  664579
     
140. Time taken is 10.700409772 s
     
141. 
     
142. JavaPure 36Mix线程实现：
     
143. Number of primes under 10000000 is  664579
     
144. Time taken is 10.724275562 s
     
145. 
     
146. JavaPure 37Mix线程实现：
     
147. Number of primes under 10000000 is  664579
     
148. Time taken is 10.705531019 s
     
149. 
     
150. JavaPure 38Mix线程实现：
     
151. Number of primes under 10000000 is  664579
     
152. Time taken is 10.709783176 s
     
153. 
     
154. JavaPure 39Mix线程实现：
     
155. Number of primes under 10000000 is  664579
     
156. Time taken is 10.645592322 s
     

复制代码

方兆国

不过十经过优化的还是没有经过优化的，制造的线程数超过CPU可以执行的线程数后，程序的效率变化不是很大，趋于一个稳定的值，线程之间切换造成的性能损失也不明显
。

经过优化的类和没有经过优化的运行效率差别不是很大，仅仅不到0.5s左右的差别

方兆国

用C语言和C++试了一下这个例子,发现C语言和C++完全玩爆Java

方兆国

C语言单线程版

1. #include <stdio.h>
   
2. #include <time.h>
   
3. 
   
4. int main(int argc, char *argv[]) {
   
5.         time_t start, end;
   
6.         time(&start);
   
7.         int sum = countPrime(10000000);
   
8.         time(&end);
   
9.         printf("0-10000000之间有%ld个素数\n", sum);
   
10.         printf("程序运行时间%d秒\n", end - start);
    
11.         return 0;
    
12. }
    
13. 
    
14. 
    
15. #include <math.h>
    
16. 
    
17. int isPrime(long number) {
    
18.         if (1 >= number) {
    
19.                 return 0;
    
20.         }
    
21.         long i;
    
22.         for (i = 2; i <= sqrt(number); i++) {
    
23.                 if (0 == number % i) {
    
24.                         return 0;
    
25.                 }
    
26.         }
    
27.         return 1;
    
28. }
    
29. 
    
30. int countPrime(long number) {
    
31.         int total = 0;
    
32.         long i;
    
33.         for (i = 2; i < number; i++) {
    
34.                 if (isPrime(i)) {
    
35.                         total++;
    
36.                 }
    
37.         }
    
38.         return total;
    
39. }
    

复制代码

运行结果

1. 0-10000000之间有664579个素数
   
2. 程序运行时间9秒
   

复制代码

方兆国

1. #include <stdio.h>
   
2. #include <time.h>
   
3. 
   
4. int main(int argc, char *argv[]) {
   
5.         time_t start, end;
   
6.         time(&start);
   
7.         int sum = countPrime(10000000);
   
8.         time(&end);
   
9.         printf("0-10000000之间有%ld个素数\n", sum);
   
10.         printf("程序运行时间%d秒\n", end - start);
    
11.         return 0;
    
12. }
    
13. 
    
14. 
    
15. 
    
16. /*
    
17. * ConcurrentPrimeFinder.c
    
18. *
    
19. *  Created on: 2013年7月19日
    
20. *      Author: root
    
21. */
    
22. 
    
23. #include <pthread.h>
    
24. #include <stdio.h>
    
25. #include <malloc.h>
    
26. #include <math.h>
    
27. 
    
28. typedef struct {
    
29.         int id;
    
30.         long lower;
    
31.         long upper;
    
32.         int total;
    
33. } Message;
    
34. 
    
35. int flag[4] = { 0, 0, 0, 0 };
    
36. 
    
37. int isPrime(long number) {
    
38.         if (1 >= number) {
    
39.                 return 0;
    
40.         }
    
41.         long i;
    
42.         for (i = 2; i <= sqrt(number); i++) {
    
43.                 if (0 == number % i) {
    
44.                         return 0;
    
45.                 }
    
46.         }
    
47.         return 1;
    
48. }
    
49. 
    
50. void *countPrimeInRange(void* mess) {
    
51.         long i = 0;
    
52.         Message* message = (Message*) mess;
    
53.         for (i = message->lower; i < message->upper; i++) {
    
54.                 if (isPrime(i)) {
    
55.                         message->total++;
    
56.                 }
    
57.         }
    
58.         flag[message->id] = 1;
    
59.         return NULL;
    
60. }
    
61. 
    
62. int countPrime(long number) {
    
63.         int total = 0;
    
64.         pthread_t thread[4];
    
65.         Message *message[4];
    
66.         long start = 0, end = 0;
    
67.         long range = number / 4;
    
68.         int volatile i = 0;
    
69.         for (i = 0; i < 4; i++) {
    
70.                 message[i] = (Message*) malloc(sizeof(Message));
    
71.         }
    
72.         for (i = 0; i < 4; i++) {
    
73.                 start = range * i;
    
74.                 if (i < 3) {
    
75.                         end = start + range;
    
76.                 } else {
    
77.                         end = number;
    
78.                 }
    
79.                 message[i]->id = i;
    
80.                 message[i]->lower = start;
    
81.                 message[i]->upper = end;
    
82.                 message[i]->total = 0;
    
83.                 pthread_create(&thread[i], NULL, countPrimeInRange,
    
84.                                 (void*) (message[i]));
    
85.         }
    
86.         i = 0;
    
87.         while (i < 4) {
    
88.                 if (1 == flag[i]) {
    
89.                         total += message[i]->total;
    
90.                         i++;
    
91.                 }
    
92.         }
    
93.         return total;
    
94. }
    

复制代码

运行结果

1. 0-10000000之间有664579个素数
   
2. 程序运行时间5秒
   

复制代码

方兆国

1. /*
   
2. * Main.c
   
3. *
   
4. *  Created on: 2013年7月19日
   
5. *      Author: root
   
6. */
   
7. 
   
8. #include "ConcurrentPrimeFinder.h"
   
9. 
   
10. #include <stdio.h>
    
11. #include <time.h>
    
12. 
    
13. int main(int argc, char *argv[]) {
    
14.         time_t start, end;
    
15.         ConcurrentPrimeFinder finder;
    
16.         time(&start);
    
17.         int sum = finder.countPrime(10000000);
    
18.         time(&end);
    
19.         printf("0-10000000之间有%ld个素数\n", sum);
    
20.         printf("程序运行时间%d秒\n", end - start);
    
21.         return 0;
    
22. }
    

复制代码

1. /*
   
2. * ConcurrentPrimeFinder.h
   
3. *
   
4. *  Created on: 2013年7月19日
   
5. *      Author: root
   
6. */
   
7. 
   
8. #ifndef CONCURRENTPRIMEFINDER_H_
   
9. #define CONCURRENTPRIMEFINDER_H_
   
10. 
    
11. #include <boost/thread.hpp>
    
12. #include <stdio.h>
    
13. 
    
14. class ConcurrentPrimeFinder {
    
15. public:
    
16.         ConcurrentPrimeFinder();
    
17.         virtual ~ConcurrentPrimeFinder();
    
18.         int countPrime(long number);
    
19. 
    
20. private:
    
21.         int poolsize;
    
22. };
    
23. 
    
24. #endif /* CONCURRENTPRIMEFINDER_H_ */
    

复制代码

1. /*
   
2. * ConcurrentPrimeFinder.cpp
   
3. *
   
4. *  Created on: 2013年7月19日
   
5. *      Author: root
   
6. */
   
7. 
   
8. #include "ConcurrentPrimeFinder.h"
   
9. 
   
10. ConcurrentPrimeFinder::ConcurrentPrimeFinder() {
    
11.         poolsize = 4;
    
12. 
    
13. }
    
14. 
    
15. ConcurrentPrimeFinder::~ConcurrentPrimeFinder() {
    
16. }
    
17. 
    
18. bool isPrime(long number) {
    
19.         if (1 >= number) {
    
20.                 return false;
    
21.         }
    
22.         long i;
    
23.         for (i = 2; i <= sqrt(number); i++) {
    
24.                 if (0 == number % i) {
    
25.                         return false;
    
26.                 }
    
27.         }
    
28.         return true;
    
29. }
    
30. 
    
31. void countPrimeInRange(long int lower, long int upper, int *total, bool *flag) {
    
32.         long i = 0;
    
33.         for (i = lower; i < upper; i++) {
    
34.                 if (isPrime(i)) {
    
35.                         (*total)++;
    
36.                 }
    
37.         }
    
38.         *flag = true;
    
39. }
    
40. 
    
41. int ConcurrentPrimeFinder::countPrime(long number) {
    
42.         using namespace boost;
    
43.         int total = 0, sum[4] = { 0 };
    
44.         bool flag[4] = { false };
    
45.         long start = 0, end = 0;
    
46.         long range = number / poolsize;
    
47.         int volatile i = 0;
    
48.         for (i = 0; i < poolsize; i++) {
    
49.                 start = range * i;
    
50.                 if (i < poolsize - 1) {
    
51.                         end = start + range;
    
52.                 } else {
    
53.                         end = number;
    
54.                 }
    
55.                 thread mythread(
    
56.                                 bind(&countPrimeInRange, start, end, &(sum[i]), &(flag[i])));
    
57.         }
    
58.         i = 0;
    
59.         while (i < poolsize) {
    
60.                 if (flag[i]) {
    
61.                         total += sum[i];
    
62.                         i++;
    
63.                 }
    
64.         }
    
65.         return total;
    
66. }
    

复制代码

运行结果

1. 0-10000000之间有664579个素数
   
2. 程序运行时间5秒
   

复制代码

pitonas

1.     0-10000000之间有664579个素数
   
2.     程序运行时间5秒

复制代码

5秒

方兆国

pitonas 发表于 2013-07-26 15:24
5秒

你的电脑能运行几秒

pitonas

方兆国 发表于 2013-07-26 11:34
你的电脑能运行几秒

我感觉我的电脑真是slow啊！   

方兆国

换台新电脑吧~\(≧▽≦)/~