[C++知识库]多线程编程

1. 简单的多线程

（1）pthread_create(pthread_t *restrict tidp,const pthread_attr_t *restrict attr,void *(*start_rtn)(void **),void *restrict arg)

tidp：线程ID指向的内存单元

attr：默认为NULL，线程属性

void *(*start)rtn)(void *)：线程执行的函数

arg：默认为NULL，函数所需要的参数

（2）pthread_join（pthread_t thread,void **value_ptr）

thread：线程，当该线程运行结束后，主线程才会结束，主线程在等待该线程运行结束的时候处于阻塞状态。

pthread_join(thread1,NULL);

pthread_join(thread2,NULL);

主线程会等待thread1和thread2都结束后才停止，主线程因为当thread1调用pthread_join时已经被阻塞，所以即使thread2比thread1先停止，主线程也要先等thread1运行结束后，才能继续运行，便发现thread2已经运行停止，于是才会把自己终止。

value_ptr：线程终止后的返回状态

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

void print_message(void *ptr)
{
	for(int i=0;i<5;i++)
		printf("%s:%d\n",(char *)ptr,i);
}

int main()
{
	int tmp1,tmp2;
	void *retval;
	pthread_t thread1,thread2;
	char *message1 = "this is thread1";
	char *message2 = "this is thread2";
	int ret_thrd1,ret_thrd2;
	ret_thrd1 = pthread_create(&thread1,NULL,(void *)&print_message,(void *)message1);
	ret_thrd2 = pthread_create(&thread2,NULL,(void *)&print_message,(void *)message2);
	if(ret_thrd1!=0)
		printf("线程1创建失败\n");
	else
		printf("线程1创建成功\n");
	if(ret_thrd2!=0)
		printf("线程2创建失败\n");
	else
		printf("线程2创建成功\n");

	tmp1 = pthread_join(thread1,&retval);
	if(tmp1!=0)
		printf("can not join with thread1\n");

	printf("thread1 end\n");


	tmp2 = pthread_join(thread2,&retval);
	if(tmp2!=0)
		printf("can not join with thread2\n");

	printf("thread2 end\n");

}

运行：gcc -std=c99 pthread.c -o a -lpthread

2. 加锁

为了防止多个线程对某一公共资源的同时访问，因此需要加锁，每次只能有一个线程获取到公共资源。当某个线程获取到资源后便加锁，保证其他线程无法进来，使用结束后解锁，释放资源的使用权。

加锁：pthread_mutex_lock(pthread_mutex_t *mutex)

解锁：pthread_mutex_unlock(pthread_mutex_t *mutex)

成功都返回0

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

int shareid = 0;

void increase_num(void);

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

int main()
{
	int ret;
	pthread_t thrd1,thrd2,thrd3;

	ret = pthread_create(&thrd1,NULL,(void *)increase_num,NULL);
	ret = pthread_create(&thrd2,NULL,(void *)increase_num,NULL);
	ret = pthread_create(&thrd3,NULL,(void *)increase_num,NULL);

	pthread_join(thrd1,NULL);
	pthread_join(thrd2,NULL);
	pthread_join(thrd3,NULL);

	printf("shareid = %d\n",shareid);

	return 0;
}

void increase_num(void)
{
	long i,tmp;
	for(i=0;i<100000;i++)
	{
		if(pthread_mutex_lock(&mutex)!=0)
		{
			perror("pthread_mutex_lock\n");
			exit(EXIT_FAILURE);
		}
		tmp = shareid;
		tmp = tmp+1;
		shareid = tmp;
		if(pthread_mutex_unlock(&mutex)!=0)
		{
			perror("pthread_mutex_unlock");
			exit(EXIT_FAILURE);
		}
	}
}

3. 信号量

信号量用于公共资源有多个时，典型的为生产者-消费者问题，可以增加资源，也会消耗资源。

（1）sem_init(sem_t *sem,int pshared ,unsigned int value)

pshared：当pshared为0，信号量被进程内的线程共享，那么该信号量应该是全局变量或堆内变量，以确保各个线程都可以访问到。非0代表信号量被进程之间共享。

value：信号量的初始值

（2）sem_post（sem_t *sem)

将信号量的值加1

（3）sem_wait(sem_t *sem)

将信号量的值减1

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

#define MAXSIZE 10

int stack[MAXSIZE];
int size = 0;
sem_t sem;

void provide_data(void)
{
	int i;
	for(i=0;i<MAXSIZE;i++)
	{
		stack[i]=i;
		sem_post(&sem);
	}
}

void handle_data(void)
{
	int i;
	while((i=size++)<MAXSIZE)
	{
		sem_wait(&sem);
		printf("乘法:%d * %d = %d \n",stack[i],stack[i],stack[i]*stack[i]);
		sleep(1);
	}
}

int main(void)
{
	pthread_t provider,handler;
	sem_init(&sem,0,0);
	pthread_create(&provider,NULL,(void *)handle_data,NULL);
	pthread_create(&handler,NULL,(void *)provide_data,NULL);
	pthread_join(provider,NULL);
	pthread_join(handler,NULL);
	sem_destroy(&sem);
	return 0;
}