作业8.2 线程同步互斥机制——互斥锁

题目一：定义一个全局变量，char str[] = “123456”，要求定义两个线程：线程A， 线程B

1.要求A线程循环打印全局字符串str；
2.要求B线程循环倒置全局字符串str：将str中的内容倒置为"654321"，再倒置为"123456"…
注意：是倒置不是倒着打印
4.要求A线程打印出的str字符串内容为：123456或者654321。
不允许出现乱序，例如：623451 653451，，，

实现代码

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

//临界资源（共享资源）
char str[] = "1234567";

pthread_mutex_t mutex; 	//互斥锁

void* callBack_print(void* arg)
{
    
	while(1)
	{
    
		/***临界区*****/
		pthread_mutex_lock(&mutex); 	//上锁 

		printf("%s\n", str);

		pthread_mutex_unlock(&mutex); 	//解锁
		/***临界区*****/
	}
	pthread_exit(NULL);
}

void* callBack_reserve(void* arg)
{
    
	int i = 0;
	while(1)
	{
    
		/***临界区*****/
		pthread_mutex_lock(&mutex); 	//上锁

		for(i=0; i<strlen(str)/2; i++)
		{
    
			char temp = str[i];
			str[i] = str[strlen(str)-1-i];
			str[strlen(str)-1-i] = temp;
		}

		pthread_mutex_unlock(&mutex); 	//解锁
		/***临界区*****/
	}
	pthread_exit(NULL);
}

int main(int argc, const char *argv[])
{
    
	//创建互斥锁，并初始化
	if(pthread_mutex_init(&mutex, NULL) != 0)
	{
    
		perror("pthread_mutex_init");
		return -1;
	}
	printf("mutex_init success\n");

	pthread_t tid1, tid2;
	//创建一个线程，循环打印
	if(pthread_create(&tid1, NULL, callBack_print, NULL) != 0)
	{
    
		perror("pthread_create");
		return -1;
	}

	//创建一个线程，循环倒置
	if(pthread_create(&tid2, NULL, callBack_reserve, NULL) != 0)
	{
    
		perror("pthread_create");
		return -1;
	}

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

	//销毁互斥锁
	pthread_mutex_destroy(&mutex);	

	return 0;
}

运行结果

题目二：要求用两个线程拷贝一张图片，A线程拷贝前半部分，B线程拷贝后半部分

不允许使用sleep函数，不允许使用flag

实现代码

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#define MSG_ERR(msg) do{
       \ fprintf(stderr,"line: %d ", __LINE__); \ perror(msg);\ }while(0)


off_t size;

pthread_mutex_t mutex; 	//互斥锁

void* callBack_A(void* arg)
{
    	
	int* fd=(int*)arg;
	char* buf1=(char*)malloc(size/2);
	/***临界区*****/
	pthread_mutex_lock(&mutex); 	//上锁 

	while(read(fd[0],buf1,size/2)>0)
	{
    
		write(fd[1],buf1,size/2);
	}
	pthread_mutex_unlock(&mutex); 	//解锁
	/***临界区*****/
	free(buf1);
	buf1=NULL;
	
	pthread_exit(NULL);
}

void* callBack_B(void* arg)
{
    
	int* fd=(int*)arg;
	char* buf2=(char*)malloc(size/2+1);
	ssize_t c;
	/***临界区*****/
	pthread_mutex_lock(&mutex); 	//上锁

	while((c=read(fd[0],buf2,size/2+1))>0)
	{
    
		write(fd[1],buf2,c);
	}

	pthread_mutex_unlock(&mutex); 	//解锁
	/***临界区*****/
	free(buf2);
	buf2=NULL;
	pthread_exit(NULL);
}


int main(int argc, const char *argv[])
{
    
	int fd1=open("/home/ubuntu/图片/sllh.jpg",O_RDONLY);
	if(fd1<0)
	{
    
		MSG_ERR("open");
		return -1;
	}
	int fd2=open("./sllh.jpg",O_WRONLY|O_CREAT|O_TRUNC,0777);
	if(fd2<0)
	{
    
		MSG_ERR("open");
		return -1;
	}
	int fd[2];
	fd[0]=fd1;
	fd[1]=fd2;
	size=lseek(fd1,0,SEEK_END);
	lseek(fd1,0,SEEK_SET);
	//创建互斥锁，并初始化
	if(pthread_mutex_init(&mutex, NULL) != 0)
	{
    
		perror("pthread_mutex_init");
		return -1;
	}
	printf("mutex_init success\n");
	pthread_t tid1, tid2;
	//创建一个线程A，拷贝前半部分
	if(pthread_create(&tid1, NULL, callBack_A,(void*)fd)!= 0)
	{
    
		perror("pthread_create");
		return -1;
	}
	
	//创建一个线程B，拷贝后半部分
	if(pthread_create(&tid2, NULL, callBack_B,(void*)fd)!= 0)
	{
    
		perror("pthread_create");
		return -1;
	}

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

	//销毁互斥锁
	pthread_mutex_destroy(&mutex);	

	return 0;
}

运行结果

将/home/ubuntu/图片/sllh.jpg拷贝到当前目录