linux互斥锁

使用互斥锁或者信号量，实现一个简单的生产者消费者模型 一个线程每秒生产3个苹果，另一个线程每秒消费8个苹果

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>
#include <semaphore.h>
#include <wait.h>
#include <signal.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <semaphore.h>
#include <sys/msg.h>
#include <sys/shm.h>
#include <sys/un.h>

typedef struct saockaddr_in addr_in_t;
typedef struct sockaddr addr_t;
typedef struct sockaddr_un addr_un_t;

int apple = 0;
int orange = 0;

pthread_mutex_t apple_mutex;//定义关于苹果的互斥锁
pthread_cond_t apple_cond;//苹果相关的条件变量

pthread_mutex_t orange_mutex;//定义关于橘子的互斥锁
pthread_cond_t orange_cond;//橘子相关的条件变量

void* apple1(void* arg){
	while(1){
	pthread_mutex_lock(&apple_mutex);
	pthread_cond_wait(&apple_cond,&apple_mutex);
	apple -= 5;
	printf("The first apple consumer consumed 5 apples,Now the number of apples is:%d\n",apple);
	pthread_mutex_unlock(&apple_mutex);
	sleep(1);
	}
}

void* apple2(void* arg){
	while(1){
	pthread_mutex_lock(&apple_mutex);
	pthread_cond_wait(&apple_cond,&apple_mutex);
	apple -= 5;
	printf("The second apple consumer consumed 5 apples,Now the number of apples is:%d\n",apple);
	pthread_mutex_unlock(&apple_mutex);
	sleep(1);
	}
}

void* orange1(void* arg){
	while(1){
	pthread_mutex_lock(&orange_mutex);
	pthread_cond_wait(&orange_cond,&orange_mutex);
	orange -= 3;
	printf("The first orange consumer consumed 3 oranges,Now the number of oranges is:%d\n",orange);
	pthread_mutex_unlock(&orange_mutex);
	sleep(1);
	}
}

void*orange2(void* arg){
	while(1){
	pthread_mutex_lock(&orange_mutex);
	pthread_cond_wait(&orange_cond,&orange_mutex);
	orange -= 3;
	printf("The second orange consumer consumed 3 oranges,Now the number of oranges is:%d\n",orange);
	pthread_mutex_unlock(&orange_mutex);
	sleep(1);
	}
}
int main(int argc, const char *argv[])
{
	pthread_mutex_init(&apple_mutex,0);
	pthread_cond_init(&apple_cond,0);

	pthread_mutex_init(&orange_mutex,0);
	pthread_cond_init(&orange_cond,0);

	pthread_t apple_id1;
	pthread_create(&apple_id1,0,apple1,0);
	pthread_detach(apple_id1);

	pthread_t apple_id2;
	pthread_create(&apple_id2,0,apple2,0);
	pthread_detach(apple_id2);

	pthread_t orange_id1;
	pthread_create(&orange_id1,0,orange1,0);
	pthread_detach(orange_id1);

	pthread_t orange_id2;
	pthread_create(&orange_id2,0,orange2,0);
	pthread_detach(orange_id2);

	while(1){
	int num = rand()%2;//随机值0、1，0代表苹果 1代表橘子
		if(num == 0){
			pthread_mutex_lock(&apple_mutex);
			apple += 8;
			printf("The producer produced 8 apples,Now the number of apples is:%d\n",apple);
			if(apple >= 8){
			pthread_cond_signal(&apple_cond);
			}
			pthread_mutex_unlock(&apple_mutex);
			sleep(1);
		}else {
			pthread_mutex_lock(&orange_mutex);
			orange += 5;
			printf("The producer produced 5 oranges,Now the number of oranges is:%d\n",orange);
			if(orange >= 5){
			pthread_cond_signal(&orange_cond);
			}
			pthread_mutex_unlock(&orange_mutex);
			sleep(1);
		}
	}
	pthread_join(apple_id1,0);
	pthread_join(apple_id2,0);
	pthread_join(orange_id1,0);
	pthread_join(orange_id2,0);
	return 0;
}
ubu

有一个盘子，盘子里面最多放3个苹果，5个橘子 2个生产者线程，一个每秒放1个苹果，另一个每秒2个橘子 放了苹果就不能放橘子，放了橘子就不能放苹果 2个消费者线程，1号消费者线程每秒消费2个苹果，2号消费者线程，每秒消费3个橘子

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>
#include <semaphore.h>
#include <wait.h>
#include <signal.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <semaphore.h>
#include <sys/msg.h>
#include <sys/shm.h>
#include <sys/un.h>

typedef struct saockaddr_in addr_in_t;
typedef struct sockaddr addr_t;
typedef struct sockaddr_un addr_un_t;

int apple = 0;
int orange = 0;

pthread_mutex_t apple_mutex;
pthread_cond_t apple_cond;

pthread_mutex_t orange_mutex;
pthread_cond_t orange_cond;

pthread_mutex_t production_apple;
pthread_cond_t apple_procond;

pthread_mutex_t production_orange;
pthread_cond_t orange_prococnd;

pthread_mutex_t all_mutex;

void* apple1(void* arg){
	while(1){
		//sleep(2);
		pthread_mutex_lock(&apple_mutex);
		pthread_cond_wait(&apple_cond,&apple_mutex);
		while(apple>=2){
		apple -=2;
		printf("消费者消费了两个苹果，现在苹果剩余:%d\n",apple);
		}
		pthread_mutex_unlock(&apple_mutex);
		sleep(1);
	}
}
void* orange1(void* arg){
	while(1){
		//sleep(2);
		pthread_mutex_lock(&orange_mutex);

		pthread_cond_wait(&orange_cond,&orange_mutex);
		while(orange >=3){
			orange-=3;
		printf("消费者消费了三个橘子，现在橘子剩余:%d\n",orange);
		}
		pthread_mutex_unlock(&orange_mutex);
		sleep(1);
	}
}
void* pro_apple(void* arg){
	while(1){
		pthread_mutex_lock(&all_mutex);
		pthread_mutex_lock(&apple_mutex);
		if(apple>=0 && apple<3){
		apple += 1;
		printf("生产者生产了1个苹果，现在苹果剩余:%d\n",apple);
		}
		
		pthread_cond_signal(&apple_cond);
		
		pthread_mutex_unlock(&apple_mutex);
		pthread_mutex_unlock(&all_mutex);
		sleep(1);
	}

}
void* pro_orange(void* arg){
	while(1){
		pthread_mutex_lock(&all_mutex);
		pthread_mutex_lock(&orange_mutex);
		if(orange>=0&&orange<4){
		orange += 2;
		printf("生产证生产了2个橘子，现在橘子剩余:%d\n",orange);
		}
		pthread_cond_signal(&orange_cond);
		
		pthread_mutex_unlock(&orange_mutex);
		pthread_mutex_unlock(&all_mutex);
	}
}
int main(int argc, const char *argv[])
{
	pthread_mutex_init(&all_mutex,0);
		
	pthread_mutex_init(&apple_mutex,0);
	pthread_cond_init(&apple_cond,0);

	pthread_mutex_init(&orange_mutex,0);
	pthread_cond_init(&orange_cond,0);
	
	pthread_mutex_init(&production_apple,0);
	pthread_cond_init(&apple_procond,0);

	pthread_mutex_init(&production_orange,0);
	pthread_cond_init(&orange_prococnd,0);

	pthread_t apple_id;
	pthread_create(&apple_id,0,apple1,0);
	pthread_detach(apple_id);

	pthread_t orange_id;
	pthread_create(&orange_id,0,orange1,0);
	pthread_detach(apple_id);

	pthread_t apple_proid;
	pthread_create(&apple_proid,0,pro_apple,0);
	pthread_detach(apple_proid);

	pthread_t orange_proid;
	pthread_create(&orange_proid,0,pro_orange,0);
	pthread_detach(orange_proid);

	pthread_join(apple_proid,0);
	pthread_join(orange_proid,0);
	pthread_join(apple_id,0);
	pthread_join(orange_id,0);
	return 0;
}