C/C++多线程怎么单线程还慢

方兆国

我这两天看Java多线程编程,顺便把程序改成了C/C++多线程的,然后发现debug版本的运行速度还没有单线程的和java版的快,而且差距不小；
release版的目前还没有出现过结果……

这是什么情况

天不再蓝

cpu单核的？

方兆国

天不再蓝 发表于 2013-07-19 16:42
cpu单核的？

Intel i5 430M 虚拟四核

方兆国

C语言版源代码

1. 
   
2. #include <pthread.h>
   
3. #include <stdio.h>
   
4. #include <malloc.h>
   
5. #include <math.h>
   
6. #include <time.h>
   
7. 
   
8. typedef struct {
   
9.         int id;
   
10.         long lower;
    
11.         long upper;
    
12.         int total;
    
13. } Message;
    
14. 
    
15. int flag[4] = { 0, 0, 0, 0 };  //用于确定线程是否执行完毕
    
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. void *countPrimeInRange(void* mess) {
    
31.         long i = 0;
    
32.         Message* message = (Message*) mess;
    
33.         for (i = message->lower; i < message->upper; i++) {
    
34.                 if (isPrime(i)) {
    
35.                         message->total++;
    
36.                 }
    
37.         }
    
38.         flag[message->id] = 1;
    
39.         return NULL;
    
40. }
    
41. 
    
42. int countPrime(long number) {
    
43.         int total = 0;
    
44.         pthread_t thread[4];
    
45.         Message *message[4];
    
46.         long start = 0, end = 0;
    
47.         long range = number / 4;
    
48.         int i = 0;
    
49.         for (i = 0; i < 4; i++) {
    
50.                 message[i] = (Message*) malloc(sizeof(Message));
    
51.         }
    
52.         for (i = 0; i < 4; i++) {
    
53.                 start = 0 + range * i;
    
54.                 if (i < 3) {
    
55.                         end = start + range;
    
56.                 } else {
    
57.                         end = number;
    
58.                 }
    
59.                 message[i]->id = i;
    
60.                 message[i]->lower = start;
    
61.                 message[i]->upper = end;
    
62.                 message[i]->total = 0;
    
63.                 pthread_create(&thread[i], NULL, countPrimeInRange,
    
64.                                 (void*) (message[i]));
    
65.         }
    
66.         i = 0;
    
67.         while (i < 4) {
    
68.                 if (1 == flag[i]) {
    
69.                         total += message[i]->total;
    
70.                         i++;
    
71.                 }
    
72.         }
    
73.         return total;
    
74. }
    
75. 
    
76. int main(int argc, char *argv[]) {
    
77.         time_t start, end;
    
78.         time(&start);
    
79.         int sum = countPrime(10000000);
    
80.         time(&end);
    
81.         printf("0-10000000之间有%ld个素数\n", sum);
    
82.         printf("程序运行时间%d秒\n", end - start);
    
83.         return 0;
    
84. }
    

复制代码

方兆国

Boost版源代码

Main函数所在文件

1. #include "ConcurrentPrimeFinder.h"
   
2. 
   
3. #include <stdio.h>
   
4. #include <time.h>
   
5. 
   
6. int main(int argc, char *argv[]) {
   
7.         time_t start, end;
   
8.         ConcurrentPrimeFinder finder;
   
9.         time(&start);
   
10.         int sum = finder.countPrime(10000000);
    
11.         time(&end);
    
12.         printf("0-10000000之间有%ld个素数\n", sum);
    
13.         printf("程序运行时间%d秒\n", end - start);
    
14.         return 0;
    
15. }
    

复制代码

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. 
    
13. class ConcurrentPrimeFinder {
    
14. public:
    
15.         ConcurrentPrimeFinder();
    
16.         virtual ~ConcurrentPrimeFinder();
    
17.         int countPrime(long number);
    
18. 
    
19. private:
    
20.         int poolsize;
    
21. };
    
22. 
    
23. #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 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. }
    

复制代码

方兆国

这两个都是一个问题，debug版运行缓慢，release版，就像进入死循环了

littledick

volatile
lock
asynchronous

方兆国

回复 7# littledick


    刚刚发现一个很严峻的问题,连main函数开头的printf都执行不了

方兆国

littledick 发表于 2013-07-19 17:01
volatile
lock
asynchronous

真的非常感谢你,你说的三个单词,我用了第一个就解决问题了,那个变量i被编译器优化了,因此一直是死循环出不来

yulihua49

方兆国 发表于 2013-07-19 16:40
我这两天看Java多线程编程,顺便把程序改成了C/C++多线程的,然后发现debug版本的运行速度还没有单线程的和ja ...

这只是你的个例，不能作为普遍的结论。
一般多线程的设计，要依据业务性质，在某些可并行的瓶颈环节设置多线程，才能获得好的效果。

for (i = 2; i <= sqrt(number); i++) {

你能不能先把ｓｑｒｔ求出来，别每次循环做？