线程同步-读者写者问题（多线程）

0 推荐在openEuer上实现
1 描述操作系统中“读者-写者”问题，理解问题的本质，提交你理解或查找到的文本资料
2 利用多线程完成 reader 和 writer
3 在main中测试若干个 reader 和 writer 的测试，提交截图说明代码的正确性

多线程通信之读者、写者问题

读、写问题是另一个非常出名的同步问题，常常用来模拟数据库的数据查询和数据修改两种情况问题。也即，
一个数据库允许有多个访问者同时对其进行数据访问，但是对于数据的修改只能有一个。那么如何来控制这种访问多个，而修改只能一个的数据操作方式？这也涉及到线程间通信和同步问题。
数据库中存在的情况为：

读者、读者可以同时存在；
读者、写者不能同时存在，如果读者在前，则写者等待；否则所有读者等待；
写者、写者不能同时存在，先到先做，后到等待。

假设当前数据库新来了一个访问者，那么它可能的状况为以下几种：

当前数据库还没有读者、写者，那么新读者可以读；
有写者在等待，但其他读者正在读，那么新读者也可以读；
有写者在写，那么新读者等待；

假设当前数据库新来了一个写者，那么它可能的状况为以下几种：

当前数据库没有读者、写者，那么新写者可以写；
有读者在读，那新写者等待；
有写者在写，则新写者等待。

同步互斥问题 - 读者写者问题之写者优先

实现代码

代码中信号量解析

设置五个信号量，分别是 RWMutex, mutex1, mutex2, mutex3, wrt，两个全局整型变量writeCount, readCount
信号量mutex1在写者的进入区和退出区中使用，使得每次只有一个写者对其相应进入区或推出区进行操作，主要原因是进入区和退出区存在对变量writeCount的修改，每个写者其进入区中writeCount加1，退出区中writeCount减1。信号量RWMutex则是读者和写者两个之间的互斥信号量，保证每次只读或者只写。写者优先中，写者的操作应该优先于读者，则信号量一直被占用着，直到没有写者的时候才会释放，即当writeCount等于1的时候，申请信号量RWMutex，其余的写者无需再次申请，但是写者是不能同时进行写操作的，则需要设置一个信号量wrt来保证每次只有一个写者进行写操作，当写者的数量writeCount等于0的时候，则证明此时没有没有读者了，释放信号量RWMutex。信号量mutex2防止一次多个读者修改readCount。当readCount为1的时候，为阻止写者进行写操作，申请信号量wrt，则写者就无法进行写操作了。信号量mutex3的主要用处就是避免写者同时与多个读者进行竞争，读者中信号量RWMutex比mutex3先释放，则一旦有写者，写者可马上获得资源。

代码

点击查看代码

/*
* 	写者优先
*/

# include <stdio.h>
# include <stdlib.h>
# include <time.h>
# include <sys/types.h>
# include <pthread.h>
# include <semaphore.h>
# include <string.h>
# include <unistd.h>

//semaphores
sem_t RWMutex, mutex1, mutex2, mutex3, wrt;
int writeCount, readCount;


struct data {
	int id;
	int opTime;
	int lastTime;
};

//读者
void* Reader(void* param) {
	int id = ((struct data*)param)->id;
	int lastTime = ((struct data*)param)->lastTime;
	int opTime = ((struct data*)param)->opTime;

	sleep(opTime);
	printf("Thread %d: waiting to read\n", id);	

	sem_wait(&mutex3);
	sem_wait(&RWMutex);
	sem_wait(&mutex2);
	readCount++;
	if(readCount == 1)
		sem_wait(&wrt);
	sem_post(&mutex2);
	sem_post(&RWMutex);
	sem_post(&mutex3);

	printf("Thread %d: start reading\n", id);
	/* reading is performed */
	sleep(lastTime);
	printf("Thread %d: end reading\n", id);

	sem_wait(&mutex2);
	readCount--;
	if(readCount == 0)
		sem_post(&wrt);
	sem_post(&mutex2);

	pthread_exit(0);
}

//写者
void* Writer(void* param) {
	int id = ((struct data*)param)->id;
	int lastTime = ((struct data*)param)->lastTime;
	int opTime = ((struct data*)param)->opTime;

	sleep(opTime);
	printf("Thread %d: waiting to write\n", id);

	sem_wait(&mutex1);
	writeCount++;
	if(writeCount == 1){
		sem_wait(&RWMutex);
	}
	sem_post(&mutex1);

	sem_wait(&wrt);
	printf("Thread %d: start writing\n", id);
	/* writing is performed */
	sleep(lastTime);
	printf("Thread %d: end writing\n", id);
	sem_post(&wrt);

	sem_wait(&mutex1);
	writeCount--;
	if(writeCount == 0) {
		sem_post(&RWMutex);
	}
	sem_post(&mutex1);

	pthread_exit(0);
}

int main() {
	//pthread
	pthread_t tid; // the thread identifier

	pthread_attr_t attr; //set of thread attributes

	/* get the default attributes */
	pthread_attr_init(&attr);

	//initial the semaphores
    sem_init(&mutex1, 0, 1);
    sem_init(&mutex2, 0, 1);
    sem_init(&mutex3, 0, 1);
    sem_init(&wrt, 0, 1);
    sem_init(&RWMutex, 0, 1);

    readCount = writeCount = 0;

	int id = 0;
	while(scanf("%d", &id) != EOF) {

		char role;		//producer or consumer
		int opTime;		//operating time
		int lastTime;	//run time

		scanf("%c%d%d", &role, &opTime, &lastTime);
		struct data* d = (struct data*)malloc(sizeof(struct data));

		d->id = id;
		d->opTime = opTime;
		d->lastTime = lastTime;

		if(role == 'R') {
			printf("Create the %d thread: Reader\n", id);
			pthread_create(&tid, &attr, Reader, d);

		}
		else if(role == 'W') {
			printf("Create the %d thread: Writer\n", id);
			pthread_create(&tid, &attr, Writer, d);
		}
	}

	sem_destroy(&mutex1);
	sem_destroy(&mutex2);
	sem_destroy(&mutex3);
	sem_destroy(&RWMutex);
	sem_destroy(&wrt);

	return 0;
}

测试数据

1 R 3 5
2 W 4 5
3 R 5 2
4 R 6 5
5 W 7 3

结果

同步互斥问题 - 读者写者问题之读者优先

（一）问题要求

1.读者-写者问题的读写操作限制(仅读者优先或写者优先)

写-写互斥，即不能有两个写者同时进行写操作。
读-写互斥，即不能同时有一个线程在读，而另一个线程在写。
读-读允许，即可以有一个或多个读者在读。

2.读者优先的附加限制

如果一个读者申请进行读操作时已有另一个读者正在进行读操作，则该读者可直接开始读操作。
（二）读者优先实现思路

读者优先指的是除非有写者在写文件，否则读者不需要等待。所以可以用一个整型变量read_count记录当前的读者数目，用于确定是否需要释放正在等待的写者线程(当read_count=0时，表明所有的读者读完，需要释放写者等待队列中的一个写者)。每一个读者开始读文件时，必须修改read_count变量。因此需要一个互斥对象mutex来实现对全局变量read_count修改时的互斥。
  另外，为了实现写-写互斥，需要增加一个临界区对象write。当写者发出写请求时，必须申请临界区对象的所有权。通过这种方法，也可以实现读-写互斥，当read_count=1时(即第一个读者到来时)，读者线程也必须申请临界区对象的所有权。
  当读者拥有临界区的所有权时，写者阻塞在临界区对象write上。当写者拥有临界区的所有权时，第一个读者判断完“read_count==1”后阻塞在write上，其余的读者由于等待对read_count的判断，阻塞在mutex上。

实现代码

点击查看代码

/*
*   读者优先
*/

# include <stdio.h>
# include <stdlib.h>
# include <time.h>
# include <sys/types.h>
# include <pthread.h>
# include <semaphore.h>
# include <string.h>
# include <unistd.h>

//semaphores
sem_t wrt, mutex;
int readCount;

struct data {
    int id;
    int opTime;
    int lastTime;
};

//读者
void* Reader(void* param) {
    int id = ((struct data*)param)->id;
    int lastTime = ((struct data*)param)->lastTime;
    int opTime = ((struct data*)param)->opTime;

    sleep(opTime);
    printf("Thread %d: waiting to read\n", id);
    sem_wait(&mutex);
    readCount++;
    if(readCount == 1) 
        sem_wait(&wrt);
    sem_post(&mutex);

    printf("Thread %d: start reading\n", id);
    /* reading is performed */
    sleep(lastTime);
    printf("Thread %d: end reading\n", id);

    sem_wait(&mutex);
    readCount--;
    if(readCount == 0)
        sem_post(&wrt);
    sem_post(&mutex);
    pthread_exit(0);
}

//写者
void* Writer(void* param) {
    int id = ((struct data*)param)->id;
    int lastTime = ((struct data*)param)->lastTime;
    int opTime = ((struct data*)param)->opTime;

    sleep(opTime);
    printf("Thread %d: waiting to write\n", id);
    sem_wait(&wrt);

    printf("Thread %d: start writing\n", id);
    /* writing is performed */
    sleep(lastTime);
    printf("Thread %d: end writing\n", id);

    sem_post(&wrt);
    pthread_exit(0);
}

int main() {
    //pthread
    pthread_t tid; // the thread identifier

    pthread_attr_t attr; //set of thread attributes

    /* get the default attributes */
    pthread_attr_init(&attr);

    //initial the semaphores
    sem_init(&mutex, 0, 1);
    sem_init(&wrt, 0, 1);
    readCount = 0;

    int id = 0;
    while(scanf("%d", &id) != EOF) {

        char role;      //producer or consumer
        int opTime;     //operating time
        int lastTime;   //run time

        scanf("%c%d%d", &role, &opTime, &lastTime);
        struct data* d = (struct data*)malloc(sizeof(struct data));

        d->id = id;
        d->opTime = opTime;
        d->lastTime = lastTime;

        if(role == 'R') {
            printf("Create the %d thread: Reader\n", id);
            pthread_create(&tid, &attr, Reader, d);

        }
        else if(role == 'W') {
            printf("Create the %d thread: Writer\n", id);
            pthread_create(&tid, &attr, Writer, d);
        }
    }

    //信号量销毁
    sem_destroy(&mutex);
    sem_destroy(&wrt);

    return 0;
}

测试数据

1 R 3 5
2 W 4 5
3 R 5 2
4 R 6 5
5 W 7 3

结果