多线程读写锁机制

  1 #include <stdio.h>
  2 #include <pthread.h>
  3 #include <stdio.h>
  4 #include <errno.h>
  5 #include <stdlib.h>
  6 static pthread_rwlock_t rwlock;
  7 #define WORK_SIZE 1024
  8 char work_area[WORK_SIZE];
  9 int time_to_exit=0;
 10
 11 void *thread_function_read_o(void *arg);
 12 void *thread_function_read_t(void *arg);
 13 void *thread_function_write_o(void *arg);
 14 void *thread_function_write_t(void *arg);
 15
 16 int main(int argc, char *argv[])
 17 {
 18     int res;
 19     pthread_t a_thread,b_thread,c_thread,d_thread;
 20     void *thread_result;
 21     res=pthread_rwlock_init(&rwlock,NULL);
 22     if(res!=0)
 23         exit(EXIT_FAILURE);
 24     res=pthread_create(&a_thread,NULL,thread_function_read_o,NULL);
 25     if(res!=0)
 26         exit(EXIT_FAILURE);
 27     res=pthread_create(&b_thread,NULL,thread_function_read_t,NULL);
 28     if(res!=0)
 29         exit(EXIT_FAILURE);
 30     res=pthread_create(&c_thread,NULL,thread_function_write_o,NULL);
 31     if(res!=0)
 32         exit(EXIT_FAILURE);
 33     res=pthread_create(&d_thread,NULL,thread_function_write_t,NULL);
 34     if(res!=0)
 35         exit(EXIT_FAILURE);
 36     res=pthread_join(a_thread,&thread_result);
 37     if(res!=0)
 38         exit(EXIT_FAILURE);
 39     res=pthread_join(b_thread,&thread_result);
 40     if(res!=0)
 41         exit(EXIT_FAILURE);
 42     res=pthread_join(c_thread,&thread_result);
 43     if(res!=0)
 44         exit(EXIT_FAILURE);
 45     res=pthread_join(d_thread,&thread_result);
 46     pthread_rwlock_destroy(&rwlock);
 47     return 0;
 48 }
 49 void *thread_function_read_o(void *arg)
 50 {
 51     printf("thread read one try to get lock\n");
 52     pthread_rwlock_rdlock(&rwlock);
 53     while(strncmp("end",work_area,3)!=0)
 54     {
 55         printf("this is thread read one.");
 56         printf("the characters is %s\n",work_area);
 57         pthread_rwlock_unlock(&rwlock);
 58         sleep(2);
 59         pthread_rwlock_rdlock(&rwlock);
 60         while(work_area[0]==‘\0‘)
 61         {
 62             pthread_rwlock_unlock(&rwlock);
 63             sleep(2);
 64             pthread_rwlock_rdlock(&rwlock);
 65         }
 66     }
 67     pthread_rwlock_unlock(&rwlock);
 68     time_to_exit=1;
 69     pthread_exit(0);
 70 }
 71 void *thread_function_read_t(void *arg)
 72 {
 73     printf("thread read two try to get lock\n");
 74     pthread_rwlock_rdlock(&rwlock);
 75     while(strncmp("end",work_area,3)!=0)
 76     {
 77         printf("this is thread read two.");
 78         printf("the characters is %s\n",work_area);
 79         pthread_rwlock_unlock(&rwlock);
 80         sleep(5);
 81         pthread_rwlock_rdlock(&rwlock);
 82         while(work_area[0]==‘\0‘)
 83         {
 84             pthread_rwlock_unlock(&rwlock);
 85             sleep(5);
 86             pthread_rwlock_rdlock(&rwlock);
 87         }
 88
 89     }
 90     pthread_rwlock_unlock(&rwlock);
 91     time_to_exit=1;
 92     pthread_exit(0);
 93 }
 94
 95 void *thread_function_write_o(void *arg)
 96 {
 97     printf("this is write thread one try to get lock\n");
 98     while(!time_to_exit)
 99     {
100         pthread_rwlock_wrlock(&rwlock);
101         printf("this is write thread one.\nInput some text. Enter ‘end‘ to finish\n");
102         fgets(work_area,WORK_SIZE,stdin);
103         pthread_rwlock_unlock(&rwlock);
104         sleep(15);
105     }
106     pthread_rwlock_unlock(&rwlock);
107     pthread_exit(0);
108 }
109
110 void *thread_function_write_t(void *arg)
111 {
112     printf("this is write thread two try to get lock\n");
113     while(!time_to_exit)
114     {
115         pthread_rwlock_wrlock(&rwlock);
116         printf("this is write thread two.\nInput some text. Enter ‘end‘ to finish\n");
117         fgets(work_area,WORK_SIZE,stdin);
118         pthread_rwlock_unlock(&rwlock);
119         sleep(20);
120     }
121     pthread_rwlock_unlock(&rwlock);
122     pthread_exit(0);
123 }

多线程读写锁机制

时间: 2024-11-05 13:46:44

多线程读写锁机制的相关文章

读写锁机制

在以前的一篇博文Linux多线程编程初探中,只提到了用于线程同步的互斥锁.条件变量,而没有提及读写锁(read-write lock). 本文主要整理自以下文章: 读写锁(read-write lock)机制-----多线程同步问题的解决 请用普通的互斥锁编程实现一个读写锁 读写锁 读写锁比mutex有更高的适用性,可以多个线程同时占用读模式的读写锁,但是只能一个线程占用写模式的读写锁. 1)当读写锁是写加锁状态时, 在这个锁被解锁之前, 所有试图对这个锁加锁的线程都会被阻塞. 2)当读写锁在读

java多线程-读写锁

Java5 在 java.util.concurrent 包中已经包含了读写锁.尽管如此,我们还是应该了解其实现背后的原理. 读/写锁的 Java 实现(Read / Write Lock Java Implementation) 读/写锁的重入(Read / Write Lock Reentrance) 读锁重入(Read Reentrance) 写锁重入(Write Reentrance) 读锁升级到写锁(Read to Write Reentrance) 写锁降级到读锁(Write to

笔记2 linux多线程 读写锁

//read write lock #include<stdio.h> #include<unistd.h> #include<pthread.h> struct test { char a[10]; char b[10]; char c[10]; }yb = {"111","222","33333"}; static int j=0; pthread_rwlock_t mutex_1; void Print1

Linux程序设计学习笔记----多线程编程线程同步机制之互斥量(锁)与读写锁

互斥锁通信机制 基本原理 互斥锁以排他方式防止共享数据被并发访问,互斥锁是一个二元变量,状态为开(0)和关(1),将某个共享资源与某个互斥锁逻辑上绑定之后,对该资源的访问操作如下: (1)在访问该资源之前需要首先申请互斥锁,如果锁处于开状态,则申请得到锁并立即上锁(关),防止其他进程访问资源,如果锁处于关,则默认阻塞等待. (2)只有锁定该互斥锁的进程才能释放该互斥锁. 互斥量类型声明为pthread_mutex_t数据类型,在<bits/pthreadtypes.h>中有具体的定义. 互斥量

读写锁(read-write lock)机制-----多线程同步问题的解决

读写锁(read-write lock)一 综述    在一些程序中存在读者写者问题,也就是说,对某些资源的访问会  存在两种可能的情况,一种是访问必须是排它行的,就是独占的意思,这称作写操作:另一种情况就是访问方式可以是共享的,就是说可以有多个线程同时去访问某个资源,这种就称作读操作.这个问题模型是从对文件的读写操作中引申出来的.    读写锁比起mutex具有更高的适用性,具有更高的并行性,可以有多个线程同时占用读模式的读写锁,但是只能有一个线程占用写模式的读写锁,读写锁的三种状态:1.当读

【C/C++多线程编程之九】pthread读写锁

多线程编程之读写锁 Pthread是 POSIX threads 的简称,是POSIX的线程标准.  pthread读写锁把对共享资源的访问者分为读者和写者,读者只对共享资源进行读访问,写者只对共享资源进行写操作.在互斥机制,读者和写者都需要独立独占互斥量以独占共享资源,在读写锁机制下,允许同时有多个读者读访问共享资源,只有写者才需要独占资源.相比互斥机制,读写机制由于允许多个读者同时读访问共享资源,进一步提高了多线程的并发度.                   1.读写锁机制:      

c++ 读写锁

#ifndef THREAD_UTIL_H #define THREAD_UTIL_H #include <pthread.h> namespace spider { class AutoLock { pthread_mutex_t * _lock; public: AutoLock(pthread_mutex_t * lock) { _lock = lock; pthread_mutex_lock(_lock); } ~AutoLock() { pthread_mutex_unlock(_l

读写锁详解

1. 综述 在一些程序中存在读者写者问题,也就是说,对某些资源的访问会存在两种可能的情况,一种是访问必须是排它行的,就是独占的意思,这称作写操作:另一种情况就是访问方式可以是共享的,就是说可以有多个线程同时去访问某个资源,这种就称作读操作.这个问题模型是从对文件的读写操作中引申出来的.    读写锁比起mutex具有更高的适用性,具有更高的并行性,可以有多个线程同时占用读模式的读写锁,但是只能有一个线程占用写模式的读写锁,读写锁的三种状态: (1)当读写锁是写加锁状态时,在这个锁被解锁之前,所有

动手实现读写锁

排他锁的弊端 在多个线程之间共享数据,普遍做法是加锁读写,也就是同一个时刻只有一个线程能够读或者写,以保证数据一致性,即线程安全.例如下面的代码是普遍的做法 1 void Read() 2 { 3 Lock(mutex); 4 5 // 读取数据 6 7 UnLock(mutex); 8 } 9 10 void Write() 11 { 12 Lock(mutex); 13 14 // 写入数据 15 16 UnLock(mutex); 17 } 读写锁的设计 这样的锁是具有排他性的,会在一定程