多线程（二）：更复杂一点的程序

本代码实现统计给定整型数组中素数的个数，其中传递给线程的参数是一个结构。

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

int num = 0;

typedef struct myTestType
{
	int threadID;
	int threadNum;
	int dataNum;

	int *input;
	int *output;
	int *index;
	pthread_mutex_t *pMutIndex;
}myTest;

int calculate(int input) {
	int i;
	int output = 0;
	for(i=2; i<input/2; i++) {
		if(input % i == 0) {
			output = 1;
			break;
		}
	}
	if(output == 0)
	{
		num++;
		sleep(1);
	}
	return output;
}

void thread(myTest * pMyTest) {
	printf("Begin threadID=%u run!\n", pMyTest->threadID);
	int index, input, output;
	int threadID = pMyTest->threadID;
	int dataNum = pMyTest->dataNum;
	pthread_mutex_lock(pMyTest->pMutIndex);
	index = pMyTest->index[0];
	pMyTest->index[0]++;
	pthread_mutex_unlock(pMyTest->pMutIndex);
	while(index < dataNum) {
		input = pMyTest->input[index];
		output = calculate(input);
		printf("index=%3u, input=%8u, output=%2u, threadID=%2u\n", index, input, output, threadID);
		pMyTest->output[index] = output;
		pthread_mutex_lock(pMyTest->pMutIndex);
		index = pMyTest->index[0];
		pMyTest->index[0]++;
		pthread_mutex_unlock(pMyTest->pMutIndex);
	}
	pthread_exit(NULL);
}

int main(void) {
	int i, ret;
	int threadNum = 2;
	myTest * pMyTest = (myTest *)malloc(sizeof(myTest));
	pMyTest->dataNum = 100;
	pMyTest->input = (int *)malloc(sizeof(int)*pMyTest->dataNum);
	pMyTest->output = (int *)malloc(sizeof(int)*pMyTest->dataNum);
	for(i=0; i<pMyTest->dataNum;++i) {
		if(i % 4 == 0)
			pMyTest->input[i] = (1 << (i%30)) + 1;
		else
			pMyTest->input[i] = (7 << (i%16)) + 1;
	}
	pMyTest->index = (int *)calloc(1, sizeof(int));

	pMyTest->pMutIndex = (pthread_mutex_t*)malloc(sizeof(pthread_mutex_t));
	pthread_mutex_init(pMyTest->pMutIndex, NULL);

	pMyTest->threadNum = threadNum;
	myTest * inMyTest = (myTest *)malloc(sizeof(myTest)*threadNum);
	for(i=0; i<threadNum; ++i) {
		memcpy(inMyTest+i, pMyTest, sizeof(myTest));
		(inMyTest+i)->threadID = i;
	}
	pthread_t * tid = (pthread_t*)malloc(sizeof(pthread_t)*threadNum);
	printf("Begin create pthread.\n");
	for(i=0; i<threadNum; ++i) {
		ret = pthread_create(tid+i, NULL, (void *)thread, (myTest *)(inMyTest+i));
		if(ret != 0) {
			printf("Create pthread error.\n");
			return 0;
		}
	}
	for(i=0; i<threadNum; i++)
		pthread_join(tid[i], NULL);
	printf("素数个数：%d\n", num);
	free(tid);
	free(inMyTest);
	pthread_mutex_destroy(pMyTest->pMutIndex);
	free(pMyTest->pMutIndex);
	free(pMyTest->input);
	free(pMyTest->output);
	free(pMyTest->index);
	free(pMyTest);
	return 0;
}

其他代码都是老师给的。实现素数个数的统计使用了一个全局变量，只加了三行代码，我认为比较方便。答案代码中给myTest结构中添加了一个类似int * index的变量来统计素数个数，虽然看起来代码比使用全局变量繁琐，但问了一下助教，助教说全局变量效率比较低，占内存神马的，文章最后给出了不使用全局变量的方法。

不过说实话我不觉得把threadNum和dataNum放在结构里有多大意义，一个#define就可以搞定了。不过后来想了想，如果设置成define的话，就不能在程序中动态指定线程数和数据量的值了，通过这两个地方，我发现我还是考虑得有点少...

这次跟前两次的简单代码比较，多了些东西。

首先，在创建线程前，进行了一些额外的工作，这些工作在前面两次的简单代码中均没有。有两个指向myTest的指针，其中inMyTest分配了threadNum个myTest大小的内存空间，可以通过(inMyTest+i)分别对各个myTest操作。

memcpy用于在内存中进行拷贝。原型为void *memcpy(void*dest, const void *src, size_t n);由src指向地址为起始地址的连续n个字节的数据复制到以destin指向地址为起始地址的空间内。如果把inMyTest比作一个可以容纳threadNum个小方块的长条形盒子的话，那么pMyTest就代表一个一个小方块，memcpy函数的执行过程就是把这些小方块放到盒子里的过程。在执行memcpy之前，需要对pMyTest进行分配内存、初始化这一系列工作。

说实话，我第一次见这种产生随机数（算是随机数吧...）的方法，移位~

其实复杂参数和简单参数的传递都差不多一样，只是这个例子中把指针传进去了而已。

pthread_mutex_lock和pthread_mutex_unlock涉及到互斥锁。夹在这两行的代码只能被一个线程所使用（以防搞乱数据）。但是有可能发生死锁，这里先不考虑。执行pthread_mutex_init时可以指定互斥锁的属性，有以下四种：

PTHREAD_MUTEX_TIMED_NP，这是缺省值，也就是普通锁。当一个线程加锁以后，其余请求锁的线程将形成一个等待队列，并在解锁后按优先级获得锁。这种锁策略保证了资源分配的公平性。

PTHREAD_MUTEX_RECURSIVE_NP，嵌套锁，允许同一个线程对同一个锁成功获得多次，并通过多次unlock解锁。如果是不同线程请求，则在加锁线程解锁时重新竞争。

PTHREAD_MUTEX_ERRORCHECK_NP，检错锁，如果同一个线程请求同一个锁，则返回EDEADLK，否则与PTHREAD_MUTEX_TIMED_NP类型动作相同。这样就保证当不允许多次加锁时不会出现最简单情况下的死锁。

PTHREAD_MUTEX_ADAPTIVE_NP，适应锁，动作最简单的锁类型，仅等待解锁后重新竞争。

顺便说一句，calloc和malloc均为分配内存然后返回首地址，但两者还是有区别的。一个是参数，malloc只接受分配空间大小一个参数，而calloc接受两个参数，分别为元素的数目和每个元素的大小。另外一个是calloc会自动初始化所分配的内存空间（视类型而定，比如把指针初始化为NULL，把int类型初始化为0）。

下面是不使用全局变量实现统计素数个数的代码：

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


typedef struct myTestType
{
	int threadID;
	int threadNum;
	int dataNum;

	int *input;
	int *output;
	int *index;
	int *primeNum;
	pthread_mutex_t *pMutIndex;
}myTest;

int calculate(int input) {
	int i;
	int output = 0;
	for(i=2; i<input/2; i++) {
		if(input % i == 0) {
			output = 1;
			break;
		}
	}
	if(output == 0)
	{
		sleep(1);
	}
	return output;
}

void thread(myTest * pMyTest) {
	printf("Begin threadID=%u run!\n", pMyTest->threadID);
	int index, input, output;
	int threadID = pMyTest->threadID;
	int dataNum = pMyTest->dataNum;
	pthread_mutex_lock(pMyTest->pMutIndex);
	index = pMyTest->index[0];
	pMyTest->index[0]++;
	pthread_mutex_unlock(pMyTest->pMutIndex);
	while(index < dataNum) {
		input = pMyTest->input[index];
		output = calculate(input);
		printf("index=%3u, input=%8u, output=%2u, threadID=%2u\n", index, input, output, threadID);
		pMyTest->output[index] = output;
		pthread_mutex_lock(pMyTest->pMutIndex);
		index = pMyTest->index[0];
		pMyTest->index[0]++;
		if(output == 0) {
			pMyTest->primeNum[0]++;
		}
		pthread_mutex_unlock(pMyTest->pMutIndex);
	}
	pthread_exit(NULL);
}

int main(void) {
	int i, ret;
	int threadNum = 2;
	myTest * pMyTest = (myTest *)malloc(sizeof(myTest));
	pMyTest->dataNum = 100;
	pMyTest->input = (int *)malloc(sizeof(int)*pMyTest->dataNum);
	pMyTest->output = (int *)malloc(sizeof(int)*pMyTest->dataNum);
	for(i=0; i<pMyTest->dataNum;++i) {
		if(i % 4 == 0)
			pMyTest->input[i] = (1 << (i%30)) + 1;
		else
			pMyTest->input[i] = (7 << (i%16)) + 1;
	}
	pMyTest->index = (int *)calloc(1, sizeof(int));
	pMyTest->primeNum = (int *)calloc(1, sizeof(int));

	pMyTest->pMutIndex = (pthread_mutex_t*)malloc(sizeof(pthread_mutex_t));
	pthread_mutex_init(pMyTest->pMutIndex, NULL);

	pMyTest->threadNum = threadNum;
	myTest * inMyTest = (myTest *)malloc(sizeof(myTest)*threadNum);
	for(i=0; i<threadNum; ++i) {
		memcpy(inMyTest+i, pMyTest, sizeof(myTest));
		(inMyTest+i)->threadID = i;
	}
	pthread_t * tid = (pthread_t*)malloc(sizeof(pthread_t)*threadNum);
	printf("Begin create pthread.\n");
	for(i=0; i<threadNum; ++i) {
		ret = pthread_create(tid+i, NULL, (void *)thread, (myTest *)(inMyTest+i));
		if(ret != 0) {
			printf("Create pthread error.\n");
			return 0;
		}
	}
	for(i=0; i<threadNum; i++)
		pthread_join(tid[i], NULL);
	printf("素数个数：%d\n", pMyTest->primeNum[0]);
	free(tid);
	free(inMyTest);
	pthread_mutex_destroy(pMyTest->pMutIndex);
	free(pMyTest->pMutIndex);
	free(pMyTest->input);
	free(pMyTest->output);
	free(pMyTest->index);
	free(pMyTest->primeNum);
	free(pMyTest);
	return 0;
}