实验：线程同步与互斥

任务一 创造一个多线程共同访问变量的问题
编写程序，定义一个全局变量sum，并赋值为0，在主线程中创建20个子线程，要求：
1、这些子线程完成同样的功能，每个线程循环10000次，每次对sum执行+1操作
2、所有子线程执行完之后，在主线程中打印最终的sum的值
提示：
每个线程对sum+1执行10000次，总共创建20个线程，那么这些子线程全部执行完之后，sum的值理论上应该是200000，但是，程序运行的结果并非200000（或许你的程序运行结果确实是200000，那么你可以尝试将子线程数目增加，但要注意子线程数目过多可能会导致部分线程创建失败，适当调整你的子线程数目，到能够出现竞争问题为止，即出现sum最终值不符合预期为止）。
hello.c

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

int sum = 0;

void *thrd_func(void *arg) {
    int i;
    for(i=0; i<10000; i++) {
        sum++;
    }
}

int main(){
    int ret,i;
    pthread_t tid[20];
    for(i=0; i<20; i++){
    ret = pthread_create(&tid[i], NULL,thrd_func, NULL);
    }
    for(i=0; i<20; i++){
    pthread_join(tid[i], NULL);
    }
    printf("sum = %d\n", sum);
    return 0;
}

任务二 解决多线程共同访问变量的问题
1、分析任务一，运行结果与预期不符的原因。
2、使用锁机制，解决多线程共同访问变量的问题，所使用的接口为pthread_mutex_lock();
使用方法：

先定义并初始化：pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
加锁：pthread_mutex_lock(&mutex);
解锁：pthread_mutex_unlock(&mutex);

3、修改后的代码能够正确预期的结果。
hello.c

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

pthread_mutex_t mutex;
int sum = 0;

void *thrd_func(void *arg) {
    int i;
    pthread_mutex_lock(&mutex);
    for(i=0; i<10000; i++) {
        sum++;
    }
    pthread_mutex_unlock(&mutex);
}

int main(){
    int ret,i;
    pthread_t tid[20];
    pthread_mutex_init(&mutex,NULL);
    for(i=0; i<20; i++){
    ret = pthread_create(&tid[i], NULL,thrd_func, NULL);
    }

    for(i=0; i<20; i++){
    pthread_join(tid[i], NULL);
    }
    pthread_mutex_destroy(&mutex);
    printf("sum = %d\n", sum);

    return 0;
}

任务三 使用信号量解决生产者消费者问题
编写程序，模拟生产者消费者的流程。实现思路如下：
1、分别创建N个生产者，N个消费者线程，并创建一个容纳M个商品的缓冲池（可以实现为一个数组，数组元素初始化为0，表示一个空缓冲池）。
2、生产者每次生产一个产品，将产品按顺序（从数组的起始位置顺序存放）放入到缓冲池中（修改数组元素值为1）。
3、消费者每次按顺序（从数组的起始位置顺序取产品）取产品消费（将对应位置的元素值修改为0）。
4、生产者、消费者每次生产/消费完产品之后，睡眠一个随机的时间(0-5秒之间的随机数)。
5、每次生产者/消费者修改了缓冲池的内容后，都将当前缓冲区的内容显示出来。
提示：
以某一个生产者线程为例的伪代码：
while（1）{
请求空缓冲区信号量；
请求访问缓冲区的互斥锁；
生产一个产品(修改in指针指向的数组值为1)
in指针+1；
打印缓冲区中所有的数据内容；
释放互斥锁；
释放信号量；
sleep(0-5之间的随机数)
}
hello.c

#include<stdio.h>
#include<pthread.h>
#include<stdlib.h>
#include<unistd.h>
#include<semaphore.h>
#define N 10
#define M 10

sem_t p_size;
sem_t c_size;
int buffer[M];
int p_index = 0;
int c_index = 0;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void printBuffer() {
	int i;
	for (i = 0;i < M; i++) {
		printf("%d ", buffer[i]);
	}
	printf("\n");
}

void *producer(void* arg) {
	while (1) {
		sem_wait(&p_size);
		pthread_mutex_lock(&mutex);
		buffer[p_index] = 1;
		p_index = (p_index+1) % M;
		printf("producer: ");
		printBuffer();
		pthread_mutex_unlock(&mutex);
		sem_post(&c_size);
		sleep(rand() % 6);
	}
}

void *consumer(void* arg) {
	while (1) {
		sem_wait(&c_size);
		pthread_mutex_lock(&mutex);
		buffer[c_index] = 0;
		c_index = (c_index+1) % M;
		printf("consumer: ");
		printBuffer();
		pthread_mutex_unlock(&mutex);
		sem_post(&p_size);
		sleep(rand() % 6);
	}
}


int main(int argc, char* argv[])
{

	pthread_t p[N];
	pthread_t c[N];
	
	sem_init(&p_size, 0, M);
	sem_init(&c_size, 0, 0);

	int i;
	for (i = 0;i < N; i++) {
		if (pthread_create(&p[i], NULL, &producer, NULL) != 0) {
			perror("pthread_create");
		}
		if (pthread_create(&c[i], NULL, &consumer, NULL) != 0) {
			perror("pthread_create");
		}
	}

	for (i = 0;i < N; i++) {
		if (pthread_join(p[i], NULL) != 0) {
			perror("pthread_join");
		}
		if (pthread_join(c[i], NULL) != 0) {
			perror("pthread_join");
		}
	}

    return 0;
}