你好,游客 登录 注册 搜索
背景:
阅读新闻

Linux多线程编程——读者优先、写者优先问题

[日期:2017-05-27] 来源:Linux社区  作者:erbing [字体: ]

读者优先描述

如果读者来:

1) 无读者、写着,新读者可以读;

2) 无写者等待,但有其他读者正在读,新读者可以读;

3) 有写者等待,但有其他读者正在读,新读者可以读;

4) 有写者写,新读者等

如果写者来:

1) 无读者,新写者可以写;

2) 有读者,新写者等待;

3) 有其他写者写或等待,新写者等待

写者优先描述

如果读者来:

1) 无读者、写者,新读者可以读;

2) 无写者等待,但有其他读者正在读,新读者可以读;

3) 有写者等待,但有其他读者正在读,新读者等;

4) 有写者写,新读者等

如果写者来:

1) 无读者,新写者可以写;

2) 有读者,新写者等待;

3) 有其他写者或等待,新写者等待

信号量和互斥锁的区别

  • 互斥量用于线程的互斥,信号量用于线程的同步。
    这是互斥量和信号量的根本区别,也就是互斥和同步之间的区别。
    互斥:是指某一资源同时只允许一个访问者对其进行访问,具有唯一性和排它性。但互斥无法限制访问者对资源的访问顺序,即访问是无序的。
    同步:是指在互斥的基础上(大多数情况),通过其它机制实现访问者对资源的有序访问。在大多数情况下,同步已经实现了互斥,特别是所有写入资源的情况必定是互斥的。少数情况是指可以允许多个访问者同时访问资源
  • 互斥量值只能为0/1,信号量值可以为非负整数。
    也就是说,一个互斥量只能用于一个资源的互斥访问,它不能实现多个资源的多线程互斥问题。信号量可以实现多个同类资源的多线程互斥和同步。当信号量为单值信号量是,也可以完成一个资源的互斥访问。
  • 互斥量的加锁和解锁必须由同一线程分别对应使用,信号量可以由一个线程释放,另一个线程得到。

读者优先

使用互斥锁来确保同一时间只能一个进程写文件,实现互斥。使用信号量来实现访问资源的同步。

首先,写者的代码应该是这样一种形式,才能保证同一时刻只有一个写者修改数据。

考虑到写者对读者的影响是:当任何读者想读时,写者都必须被阻塞;并且,读者阻塞了写者并停止阻塞之前,后续的任何写者都会读者优先于执行。这就如同有一个读者队列,当第一个读者入队时,写者完全被阻塞,直到最后一个读者离开队列。

据此,可以用 readerCnt来统计读者的数量,而用信号量 sem_read来互斥各线程对 readerCnt的访问。

/*
*  多线程,读者优先
*/

#include "stdio.h"
#include <stdlib.h>
#include <pthread.h>
#include<semaphore.h>


#define N_WRITER 30 //写者数目
#define N_READER 5 //读者数目
#define W_SLEEP  1 //控制写频率
#define R_SLEEP  1 //控制读频率


pthread_t wid[N_WRITER],rid[N_READER];
pthread_mutex_t mutex_write;//同一时间只能一个人写文件,互斥
sem_t sem_read;//同一时间只能有一个人访问 readerCnt
int data = 0;
int readerCnt = 0;
void write()
{
    int rd = rand();
    printf("write %d\n",rd);
    data = rd;
}
void read()
{
    printf("read %d\n",data);
}
void * writer(void * in)
{
//    while(1)
//    {
        pthread_mutex_lock(&mutex_write);
        printf("写线程id%d进入数据集\n",pthread_self());
        write();
        printf("写线程id%d退出数据集\n",pthread_self());
        pthread_mutex_unlock(&mutex_write);
        sleep(W_SLEEP);
//    }
    pthread_exit((void *) 0);
}

void * reader (void * in)
{
//    while(1)
//    {
        sem_wait(&sem_read);
        readerCnt++;
        if(readerCnt == 1){
            pthread_mutex_lock(&mutex_write);
        }
        sem_post(&sem_read);
        printf("读线程id%d进入数据集\n",pthread_self());
        read();
        printf("读线程id%d退出数据集\n",pthread_self());   
        sem_wait(&sem_read);
        readerCnt--;
        if(readerCnt == 0){
            pthread_mutex_unlock(&mutex_write);
        }
        sem_post(&sem_read);
        sleep(R_SLEEP);
//    }
    pthread_exit((void *) 0);
}

int main()
{
    printf("多线程,读者优先\n");   
    pthread_mutex_init(&mutex_write,NULL);
    sem_init(&sem_read,0,1);
    int i = 0;
    for(i = 0; i < N_WRITER; i++)
    {
        pthread_create(&wid[i],NULL,writer,NULL);
    }
        for(i = 0; i < N_READER; i++)
    {
        pthread_create(&rid[i],NULL,reader,NULL);
    }
    sleep(1);
    return 0;
}

读者优先

为了更明显的看到效果,在main函数中创建了20个写者和5个读者。注意编译时要加上-lpthread指定库。

写者优先

写者优先与读者优先的不同是:如果读者来,有写者等待,但有其他读者正在读,新读者等。

使用两个互斥锁mutex_writemutex_read和两个信号量sem_readsem_write来确保访问资源的互斥和同步。

 

#include "stdio.h"
#include <stdlib.h>
#include <pthread.h>
#include<semaphore.h>

 

#define N_WRITER 5 //写者数目
#define N_READER 20 //读者数目
#define W_SLEEP 1 //控制写频率
#define R_SLEEP  0.5 //控制读频率

 


pthread_t wid[N_WRITER],rid[N_READER];
int data = 0;
int readerCnt = 0, writerCnt = 0;
pthread_mutex_t sem_read;
pthread_mutex_t sem_write;
pthread_mutex_t mutex_write;
pthread_mutex_t mutex_read;

 

void write()
{
    int rd = rand();
    printf("write %d\n",rd);
    data = rd;
}
void read()
{
    printf("read %d\n",data);
}
void * writer(void * in)
{
//    while(1)
//    {
        sem_wait(&sem_write);
        {//临界区,希望修改 writerCnt,独占 writerCnt
            writerCnt++;
            if(writerCnt == 1){
                //阻止后续的读者加入待读队列
                pthread_mutex_lock(&mutex_read);
            }
        }
        sem_post(&sem_write);
       
       
        pthread_mutex_lock(&mutex_write);
        {//临界区,限制只有一个写者修改数据
            printf("写线程id%d进入数据集\n",pthread_self());
            write();
            printf("写线程id%d退出数据集\n",pthread_self());       
        }
        pthread_mutex_unlock(&mutex_write);
       
        sem_wait(&sem_write);
        {//临界区,希望修改 writerCnt,独占 writerCnt
            writerCnt--;
            if(writerCnt == 0){
                //阻止后续的读者加入待读队列
                pthread_mutex_unlock(&mutex_read);
            }
        }
        sem_post(&sem_write);
        sleep(W_SLEEP);
//    }
    pthread_exit((void *) 0);
}

 

void * reader (void * in)
{
//    while(1)
//    {
        //假如写者锁定了mutex_read,那么成千上万的读者被锁在这里
            pthread_mutex_lock(&mutex_read);//只被一个读者占有
            {//临界区
                sem_wait(&sem_read);//代码段 1
                {//临界区
                    readerCnt++;
                    if(readerCnt == 1){
                        pthread_mutex_lock(&mutex_write);
                    }
                }
                sem_post(&sem_read);
            }
            pthread_mutex_unlock(&mutex_read);//释放时,写者将优先获得mutex_read
        printf("读线程id%d进入数据集\n",pthread_self());
        read();
        printf("读线程id%d退出数据集\n",pthread_self());
        sem_wait(&sem_read);//代码段2
        {//临界区
            readerCnt--;
            if(readerCnt == 0){
                pthread_mutex_unlock(&mutex_write);//在最后一个并发读者读完这里开始禁止写者执行写操作
            }
        }
        sem_post(&sem_read);
       
        sleep(R_SLEEP);
//    }
    pthread_exit((void *) 0);
}

 

int main()
{
    printf("多线程,写者优先\n");
    pthread_mutex_init(&mutex_write,NULL);
    pthread_mutex_init(&mutex_read,NULL);
    sem_init(&sem_write,0,1);
    sem_init(&sem_read,0,1);
int i = 0;
    for(i = 0; i < N_READER; i++)
    {
        pthread_create(&rid[i],NULL,reader,NULL);
    }
    for(i = 0; i < N_WRITER; i++)
    {
        pthread_create(&wid[i],NULL,writer,NULL);
    }
    sleep(1);   
    return 0;
}

 

写者优先

本文永久更新链接地址http://www.linuxidc.com/Linux/2017-05/144292.htm

 

linux
相关资讯       Linux多线程编程 
本文评论   查看全部评论 (0)
表情: 表情 姓名: 字数

       

评论声明
  • 尊重网上道德,遵守中华人民共和国的各项有关法律法规
  • 承担一切因您的行为而直接或间接导致的民事或刑事法律责任
  • 本站管理人员有权保留或删除其管辖留言中的任意内容
  • 本站有权在网站内转载或引用您的评论
  • 参与本评论即表明您已经阅读并接受上述条款