Linux中线程同步，及生产者消费者模型

一、竞争与同步
    当多个线程同时访问其所共享的进程资源时，需要相互协调，以防止出现数据不一致、不完整的问题。这就叫线程同步。
    
二、互斥量、
    
    int pthread_mutex_init (pthread_mutex_t* mutex,const pthread_mutexattr_t* mutexattr);
    功能：初始化互斥量
    //亦可 pthread_mutex_t mutex =  PTHREAD_MUTEX_INITIALIZER;
​
    int pthread_mutex_lock (pthread_mutex_t* mutex);
    功能：加锁
​
    int pthread_mutex_unlock (pthread_mutex_t* mutex);
    功能：解锁
​
    int pthread_mutex_destroy (pthread_mutex_t* mutex);
    功能：销毁互斥量
    
    1) 互斥量被初始化为非锁定状态；
    2) 线程1调用pthread_mutex_lock函数，立即返回，互斥量呈锁定状态；
    3) 线程2调用pthread_mutex_lock函数，阻塞等待；
    4) 线程1调用pthread_mutex_unlock函数，互斥量呈非锁定状态；
    5) 线程2被唤醒，从pthread_mutex_lock函数中返回，互斥量呈锁定状态；
    
三、信号量
    信号量是一个计数器，用于控制访问有限共享资源的线程数。
    注意：线程使用的信号量不在pthread.h中，而是semaphore.h
    
    // 创建信号量
    int sem_init (sem_t* sem, int pshared,unsigned int value);
    sem    - 信号量ID，输出。
​    pshared - 一般取0，表示调用进程的信号量。
          非0表示该信号量可以共享内存的方式，
          为多个进程所共享(Linux暂不支持)。
    value  - 信号量初值。
​
    // 信号量减1，不够减即阻塞
    int sem_wait (sem_t* sem);
​
    // 信号量减1，不够减即返回-1，errno为EAGAIN
    int sem_trywait (sem_t* sem);
​
    // 信号量减1，不够减即阻塞，
    // 直到abs_timeout超时返回-1，errno为ETIMEDOUT
    int sem_timedwait (sem_t* sem,const struct timespec* abs_timeout);
    struct timespec {
        time_t tv_sec; // Seconds
        long  tv_nsec; // Nanoseconds [0 - 999999999]
    };
​
    // 信号量加1
    int sem_post (sem_t* sem);
​
    // 销毁信号量
    int sem_destroy (sem_t* sem);
    
    下面来用信号量做一个小例子

     图书馆有5本，创建20个线程，每个线程去借阅这本书的阅读时间（0~10）然后还书

#include
#include
#include
#include
#include
#include
sem_t sem;
pthread_t tid[20];
//int time;
void run(int time)
{
	
	//int t=*(int*)time;
	sem_wait(&sem);

	printf("我借到了一本书，要看%d秒归还！\n",time);
	sleep(time);
	printf("我看完了，还回去了！\n");
	sem_post(&sem);
}
int main()
{
	srand((unsigned)(time(NULL)));
	int ret=sem_init(&sem,0,5);
	if(0>ret)
	{
		perror("sem_init");
		return -1;
	}
	int tt[20];
	
	for(int i=0;i<20;i++)
	{
		 tt[i]=rand()%10;
		pthread_create(&tid[i],NULL,(void*)&run,(void*)tt[i]);
	}
	for(int i=0;i<20;i++)
	{
		pthread_join(tid[i],NULL);
	}
	
}

    
四、死锁
    使用两把锁保护一个资源。
    创建：锁A、锁B
    线程A    线程B
    加锁A    加锁B
    s1        s1
    加锁B    加锁A
    解锁A    解锁B
    解锁B     解锁A
    
  一个关于死锁的例子：使用互斥量实现一个死锁程序，思考如何避免死锁。
        不要连续的加锁。

#include
#include
#include
#include
int num=0;
pthread_mutex_t mutexa;
pthread_mutex_t mutexb;
void* run(void* arg)
{
	pthread_mutex_lock(&mutexa);
	num++;
	sleep(3);
	pthread_mutex_lock(&mutexb);
	pthread_mutex_unlock(&mutexa);
	pthread_mutex_unlock(&mutexb);


}
int main()
{
	pthread_mutex_init(&mutexa,NULL);
	pthread_mutex_init(&mutexb,NULL);
	pthread_t tid;
	pthread_create(malloc(sizeof(pthread_t)),NULL,run,NULL);
	//pthread_create(malloc(sizeof(pthread_t)),NULL,runB,NULL);
	pthread_mutex_lock(&mutexb);
	sleep(2);
	num++;
	pthread_mutex_lock(&mutexa);

	pthread_mutex_unlock(&mutexb);
	pthread_mutex_unlock(&mutexa);
	printf("&d\n",num);
}

    
五、生产者与消费者模型
    一线程负责生产数据，另一部分线程负责消费数据。
    问题1：如何生产的快、消费的慢，生产者容易撑死
    问题2：如果生产的慢、消费的快，消费者容易饿死
    只有把问题1、和问题2协调好，才能最大限度的提高效率。
    
    生产者快－》数据池满－》生产者暂停－》消费者全部开始消费－》数据池空－》消费者暂停－》生产者全部开始生产

一个简单的生产者消费者，在线程中的使用

#include
#include
#include
#include
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond=PTHREAD_COND_INITIALIZER;

int num=0;
void* custom(void* arg)
{
	while(1)
	{
		pthread_mutex_lock(&mutex);
		while(num==0)
		{
			printf("没货了，我休息了！\n");
			pthread_cond_wait(&cond,&mutex);
		}
		
		num--;
		printf("用了一个货，还剩%d个\n",num);
		pthread_mutex_unlock(&mutex);
		usleep(rand()%100*1000);
		
	}
}
void* producter(void* arg)
{
	//sleep(1);
	//pthread_mutex_lock(&mutex);
	//pthread_cond_wait(&cond,&mutex);
	//pthread_mutex_unlock(&mutex);
	while(1)
	{
		pthread_mutex_lock(&mutex);
		if(num>10)
		{
			printf("货满了！\n");
			pthread_mutex_unlock(&mutex);
			usleep(rand()%100*1000);
			continue;
		//	pthread_cond_signal(&cond);
		//	pthread_cond_wait(&cond,&mutex);
		}
		else
		{
			pthread_mutex_unlock(&mutex);
		}
		pthread_mutex_lock(&mutex);

		num++;
		printf("又制造了一个，已经有%d个了\n",num);
		pthread_cond_signal(&cond);
		pthread_mutex_unlock(&mutex);
		usleep(rand()%100*1000);	
		
	}
}
int main()
{
	pthread_t tid1,tid2;
	pthread_create(&tid1,NULL,custom,NULL);
	pthread_create(&tid2,NULL,producter,NULL);

	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
}

    
六、条件变量
    条件变量可以让调用线程在满足特定条件的情况下暂停。
    int pthread_cond_init (pthread_cond_t* cond,const pthread_condattr_t* attr);
    
    //亦可pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
​
    // 使调用线程睡入条件变量cond，同时释放互斥锁mutex
    int pthread_cond_wait (pthread_cond_t* cond,pthread_mutex_t* mutex);
​
    // 使调用线程睡入条件变量cond,同时释放互斥锁mutex，并在时间到了之后即使没有被唤醒，也醒过来
    int pthread_cond_timedwait (pthread_cond_t* cond,
        pthread_mutex_t* mutex,
        const struct timespec* abstime);
​
    struct timespec {
        time_t tv_sec; // Seconds
        long  tv_nsec; // Nanoseconds [0 - 999999999]
    };
​
    // 从条件变量cond中唤出一个线程，
    // 令其重新获得原先的互斥锁
    int pthread_cond_signal (pthread_cond_t* cond);
    注意：被唤出的线程此刻将从pthread_cond_wait函数中返回，
    但如果该线程无法获得原先的锁，则会继续阻塞在加锁上。
​
    // 从条件变量cond中唤出所有线程
    int pthread_cond_broadcast (pthread_cond_t* cond);
​
    // 销毁条件变量
    int pthread_cond_destroy (pthread_cond_t* cond);

*******************************************************************************************************************************************

总结：在使用线程时，我们要注意最重要的一点就是共享资源，通过使用互斥量以及条件变量，我们能够解决这个问题

否则会出现脏数据的情况，这是我们所不愿看到的，还有就是要合理的使用互斥量，避免出现死锁问题，有一个哲学家

就餐问题，其解决方法也可以用来解决死锁现象！总之在使用线程时，一定要尽量避免出现这两个问题。