Linux系统的多线程编程

#多线程

线程概念

线程可以看做是一个正在运行的函数，一个进程中至少有一个函数运行，那么也就是说一个进程至少有一个线程。在函数中创建出来的线程，彼此之间是兄弟关系。posix线程是一套线程标准，而不是一套实现。

线程的标识

pthread_t数据类型的线程标识符tid。在终端使用ps axm命令查看线程信息。
pthread_equal(tid1,tid2)：比较两个线程标识，相同返回非0值，不相同返回0值。
注意：写完与线程相关的程序后，用gcc编译器编译时需要加上链接选项-pthread，即gcc –pthread 文件.c。或者可以写一个makefile文件，在其中写上LDFLAGS+=-pthread。
pthread_self()：返回当前线程的标识。

线程的创建

pthread_create(&tid，属性，函数指针，函数参数)：在当前的进程中创建一个新的线程，成功返回0，失败返回错误值。
&tid：回填一个线程标识符给pthread_t类型的tid变量中。这里要对变量取地址；
属性：写NULL取默认属性；
函数指针：创建线程就等于要同时再跑一个兄弟函数，所以我们创建兄弟函数应该是一个函数指针，这里就能直接填兄弟函数指针名。
函数参数：兄弟线程函数需要的参数的地址。
注意：线程的调用取决于调度器的策略。

线程的终止

线程终止的3种方式：
1.线程从启动例程返回，使用return；
2.线程可以被同一进程中的其他线程取消；
3.线程调用pthread_exit()函数终止该线程。
pthread_exit(函数返回值)：线程结束，并带回一个值，没有返回值就在参数中填NULL。

线程的取消

pthread_cancel(要取消的线程id号);

线程的收尸（回收资源）

pthread_join(tid，回填线程的返回值)：给一个进程收尸，并带回pthread_exit函数的参数返回值。tid是要收尸的线程id号。

线程的同步互斥

（1）互斥量

（1）初始化互斥量的两种方式：
1.函数初始化
互斥量：pthread_mutex_t mutex;
pthread_mutex_init(互斥量指针,互斥量属性指针)：初始化互斥量
属性：NULL为默认属性
2.使用宏初始化
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
（2）线程相关函数：
pthread_mutex_destroy(互斥量指针)：销毁互斥量。
pthread_mutex_lock(互斥量指针)：申请锁，若锁可用，获得锁并加锁，若不可用，阻塞；
pthread_mutex_unlock(互斥量指针)：解锁。
（3）池类算法的实现：
sched_yield()：出让调度器
注意：在临界区中，为了不造成死锁（锁住后没有进行解锁操作），多注意临界区中的跳转语句（break、continue、goto、函数调用）和死循环语句。

例、采用池类算法：用多线程筛选出30000000-30000200之间的质数，并输出所有质数。池类算法是多线程（多进程）处理数据比较好的一种算法，在以后使用多进程（多线程）的过程中比较常用。程序如下：

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

#define MIN 30000000
#define MAX MIN+200
#define TNUM 5

static int num=0;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void *pthread_start(void *arg)
{
	int n,i,flag=1;
	while(1)
	{
		pthread_mutex_lock(&mutex);
		while(num == 0)
		{
			pthread_mutex_unlock(&mutex);
			sched_yield();
			pthread_mutex_lock(&mutex);
		}
		if(num < 0)
		{
			pthread_mutex_unlock(&mutex);
			break;
		}
		n=num;
		num=0;
		pthread_mutex_unlock(&mutex);
		for(i=2;i<=n/2;i++)
		{
			if(n % i == 0)
			{
				flag=0;
				break;
			}
		}
		if(flag)
			printf("%d\n",n);
		flag=1;
	}
	pthread_exit(NULL);
}

int main(void)
{
	int i;
	pthread_t tid[TNUM];
	int res;
	for(i=0;i<TNUM;i++)
	{
		res = pthread_create(&tid[i],NULL,pthread_start,NULL);
		if(res)
		{
			printf("error!\n");
			exit(-1);
		}
	}
	
	for(i=MIN;i<=MAX;i++)
	{
		pthread_mutex_lock(&mutex);
		while(num != 0)
		{
			pthread_mutex_unlock(&mutex);
			sched_yield();
			pthread_mutex_lock(&mutex);
		}
		num=i;
		pthread_mutex_unlock(&mutex);
	}

	pthread_mutex_lock(&mutex);
	while(num != 0)
	{
		pthread_mutex_unlock(&mutex);
		sched_yield();
		pthread_mutex_lock(&mutex);
	}
	num=-1;
	pthread_mutex_unlock(&mutex);

	for(i=0;i<TNUM;i++)
	{
		pthread_join(tid[i],NULL);
	}

	pthread_mutex_destroy(&mutex);//销毁互斥量
	exit(0);
}

（4）条件变量：pthread_cond_t cond;

条件变量比前面的申请锁和解锁的函数好用一点，并且将线程轮询查看法改为了通知法，更加节约CPU资源，实现的是同样的功能。所以可以用以下函数对前面的代码进行一个优化。
使用函数初始化：
pthread_cond_t cond;
pthread_cond_init(条件变量指针，属性)：初始化条件变量；
属性：NULL为默认属性。
使用宏初始化：pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
ptherad_cond_destroy(条件变量指针)：销毁条件变量。
pthread_cond_wait(条件变量指针，互斥量指针)：解锁等待通知，被唤醒后再申请锁。这一个函数完成了三个函数的操作。
pthread_cond_broadcast(条件变量指针)：唤醒所有的等待线程。
pthread_cond_signal(条件变量指针)：唤醒任意一个等待的线程。

可以对池类算法输出质数的程序进行优化：

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

#define MIN 30000000
#define MAX MIN+200
#define PTHNUM 3

static pthread_mutex_t mutex;
static pthread_cond_t cond;
static int num=0;

void *pthread_start(void *arg)
{
	int pnum;
	int j;
	int flag;
	while(1)
	{
		pthread_mutex_lock(&mutex);
		while(num==0)
		{
			pthread_cond_wait(&cond,&mutex);
			/*
			pthread_mutex_unlock(&mutex);
			sched_yield();
			pthread_mutex_lock(&mutex);
			*/
		}
		if(num==-1)
		{
			pthread_cond_broadcast(&cond);
			pthread_mutex_unlock(&mutex);
			break;
		}
		pnum=num;
		num=0;
		pthread_cond_signal(&cond);
		pthread_mutex_unlock(&mutex);

		flag=1;
		for(j=2;j<=pnum/2;j++)
		{
			if(pnum%j==0)
			{
				flag=0;
				break;
			}
		}
		if(flag)
			printf("%d\n",pnum);
	}

	pthread_exit(NULL);
}

int main(void)
{
	pthread_t tid[PTHNUM];
	int i;
	int err;
	pthread_mutex_init(&mutex,NULL);//初始化互斥量
	pthread_cond_init(&cond,NULL);//初始化条件变量

	for(i=0;i<PTHNUM;i++)
	{
		err=pthread_create(&tid[i],NULL,pthread_start,NULL);
		if(err>0)
		{
			fprintf(stderr,"pthread_create():%s\n",strerror(err));
			exit(1);
		}
	}

	for(i=MIN;i<=MAX;i++)
	{
		pthread_mutex_lock(&mutex);
		while(num!=0)
		{
			pthread_cond_wait(&cond,&mutex);
			/*
			pthread_mutex_unlock(&mutex);
			sched_yield();
			pthread_mutex_lock(&mutex);
			*/
		}
		num=i;
		pthread_cond_signal(&cond);
		pthread_mutex_unlock(&mutex);
	}

	pthread_mutex_lock(&mutex);
	while(num>0)
	{
		pthread_cond_wait(&cond,&mutex);
		/*
		pthread_mutex_unlock(&mutex);
		sched_yield();
		pthread_mutex_lock(&mutex);
		*/
	}
	num=-1;
	pthread_cond_signal(&cond);
	pthread_mutex_unlock(&mutex);

	for(i=0;i<PTHNUM;i++)
		pthread_join(tid[i],NULL);

	pthread_mutex_destroy(&mutex);//销毁互斥量
	pthread_cond_destroy(&cond);//销毁条件变量
	exit(0);
}