一个并发程序开多少线程合适？文章来源：http://blog.csdn.最近在和朋友讨论的过程中，朋友说线程开得多性能好

文章来源：blog.csdn.net/greencacti/…

最近在和朋友讨论的过程中，朋友说线程开得多性能好，理由是系统中已经有成百上千的线程，并发程序开的线程越多分配到CPU的概率越高。我不认可该观点，下面来验证。

最好起CPU核心数量*2 个线程
或者 CPU核心数量*2 +2 个线程

测试场景：

硬件：HP G6(8核16流水线)

操作系统：Suse10 SP2

测试程序实现描述：

定义一个long型数组，假设有n个Entry，当有m个线程时，线程1对0~(n/m-1)中元素依次循环累加，线程2对n/m~(2n/m-1)元素依次循环累加...。最后把long型数组所有entry相加，看得到的数（此数就是所有线程对数组操作的次数）

测试结果：

Thread Num Result1 Result2 Result3

2 Threads: 186,793,032,169 186,697,212,695

4 Threads: 373,926,225,686 373,407,260,760

8 Threads: 742,705,309,211 746,706,667,311 744,690,656,181

16 Threads: 794,363,499,559

20 Threads: 794,068,481,342 793,703,559,671 794,294,479,450

测试结论：

1.当Active的线程数等于CPU流水线数时，系统性能最高；

2. 当然实际系统中有IO和网络操作时，很多时候瓶颈可能在IO；

3. 在设计系统时，要考虑到系统Active线程数，因为很多线程可能会进入block状态，不能一定认为线程数等于流水线就是性能最好；

测试程序：

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

#define ARRAY_SIZE 1000000

struct range
{
int start;
int end;
};

long array[ARRAY_SIZE];
int threadStopFlag = 0;

void *updateArray(void * ptrRange);

int main(int argc, char* argv[])
{
struct range *rangeArray[100] = {NULL};
pthread_t threadIdArray[100];
int numOfThreads = 0;
int i = 0;
int size = 0;
int error = 0;
long result = 0;

//check the number of parameters
if(2 != argc)
{
printf("usage: a.out threadnumber/n");
return -1;
}

//validate the parameter
numOfThreads = atoi(argv[1]);
if(numOfThreads > 100)
{
printf("The number of threads is greater than 100/n");
return -1;
}

//create the worker thread
size = ARRAY_SIZE / numOfThreads;
for(i=0; i< numOfThreads; i++)
{
//calculate the start and end value
rangeArray[i] = (struct range*)malloc(sizeof(struct range));
if(NULL == rangeArray[i])
{
return -1;
}

rangeArray[i]->start = i * size;
if(i != numOfThreads - 1)
{
rangeArray[i]->end = rangeArray[i]->start + size - 1;
}
else
{
rangeArray[i]->end = ARRAY_SIZE -1;
}

//create the threads
error = pthread_create(&threadIdArray[i], NULL, updateArray, (void *)rangeArray[i]);
if(error != 0)
{
printf("pthread is not created./n");
return -1;
}

}

//kill all the worker threads
sleep(300);
threadStopFlag = 1;

sleep(60);
//free the malloc memory
for(i=0; i < numOfThreads; i++)
{
free(rangeArray[i]);
rangeArray[i] = NULL;
}

//calculate the total number
for(i=0; i<ARRAY_SIZE; i++ )
{
result += array[i];
}
printf("The total number is %ld/n", result);
return 0;
}

void *updateArray(void * ptrRange)
{
struct range *arrayRange;
int pointer = 0;;
int start = 0;;
int end = 0;

arrayRange = (struct range *)ptrRange;
start = arrayRange->start;
end = arrayRange->end;
pointer = start;

while(1)
{
if(pointer > end)
{
pointer = start;
}

array[pointer] += 1;
pointer++;

if(1 == threadStopFlag)
{
pthread_exit(0);
}
}
}\