ACE_linux:读写锁

1.涉及类

ACE_RW_Thread_Mutex //ACE读写锁
ACE_Read_Guard //ACE加读锁
ACE_Write_Guard //ACE加写锁
ACE_Thread_Manager //ACE线程管理

2.简介

ACE读/写锁
读/写锁与互斥体相类似。例如,获取读/写锁的线程也必须释放它。多个线程可同时获取一个读/写锁用于读,但只有一个线程可以获取该锁用于写。当互斥体保护的资源用于读远比用于写要频繁时,读/写互斥体有助于改善并发的执行。
ACE线程库提供了一个叫作ACE_RW_Mutex的类,在C++封装类中可移植地实现了读/写锁的语义。读/写锁将优先选择权给写。因而,如果有多个读和一个写在锁上等待,写将会首先获取它。

3.示例代码

 1 #include <iostream>
 2 #include "ace/Thread_Manager.h"
 3 #include "ace/Guard_T.h"
 4 #include "ace/OS_NS_time.h"
 5
 6 using namespace std;
 7 ACE_RW_Thread_Mutex  mutex;
 8
 9 ACE_THR_FUNC_RETURN ThreadFunRead(void *arg)
10 {
11     ACE_thread_t threadId=ACE_Thread_Manager::instance()->thr_self();
12
13     ACE_Read_Guard<ACE_RW_Thread_Mutex> guard(mutex);
14     cout<<"Thread ReadLock  begin  NO:"<<threadId<<endl;
15
16
17     //ACE_OS::sleep(4);
18     cout<<"Thread ReadLock  end    NO:"<<threadId<<endl;
19     return NULL;
20 }
21 ACE_THR_FUNC_RETURN ThreadFunWrite(void *arg)
22 {
23     ACE_thread_t threadId=ACE_Thread_Manager::instance()->thr_self();
24
25     ACE_Write_Guard<ACE_RW_Thread_Mutex> guard(mutex);
26     cout<<"Thread WriteLock begin  NO:"<<threadId<<endl;
27
28     ACE_OS::sleep(1);//休眠1s
29     cout<<"Thread WriteLock end    NO:"<<threadId<<endl;
30     return NULL;
31 }
32
33 int main(int argc, char *argv[])
34 {
35     //1000纳秒=1ms
36     timespec_t t;
37     t.tv_sec=0;t.tv_nsec=1000;
38
39     ACE_Thread_Manager* pThrMgr = ACE_Thread_Manager::instance();
40     //依次一读一写依次3个循环,结果显示是此读写锁写优先。即:加锁等待队列里写操作永远在读前面!
41     for(int i=0;i<4;i++)
42     {
43         pThrMgr->spawn((ACE_THR_FUNC)ThreadFunRead);
44         ACE_OS::nanosleep (&t);
45         pThrMgr->spawn((ACE_THR_FUNC)ThreadFunWrite);
46         ACE_OS::nanosleep (&t);
47     }
48     pThrMgr->wait();
49
50     return 0;
51 }

RW_lock.cpp

4.示例运行结果

$ ./tt
Thread ReadLock  begin  NO:140015069234944
Thread ReadLock  end    NO:140015069234944
Thread WriteLock begin  NO:140015058745088
Thread WriteLock end    NO:140015058745088
Thread WriteLock begin  NO:140015037765376
Thread WriteLock end    NO:140015037765376
Thread WriteLock begin  NO:140015016785664
Thread WriteLock end    NO:140015016785664
Thread WriteLock begin  NO:140014658778880
Thread WriteLock end    NO:140014658778880
Thread ReadLock  begin  NO:140015048255232
Thread ReadLock  end    NO:140015048255232
Thread ReadLock  begin  NO:140015027275520
Thread ReadLock  end    NO:140015027275520
Thread ReadLock  begin  NO:140015006295808
Thread ReadLock  end    NO:140015006295808

执行结果

5.Makefile

#bin
THE_INCLUDE      = -I./                     -I${ACE_ROOT}/

THE_LIBPATH      = -L./                     -L${ACE_ROOT}/lib/
THE_LIB = -g -D_DEBUG_ -lACE# -lxti

CFLAGS = ${THE_LIB} ${THE_INCLUDE} ${THE_LIBPATH}
CC=g++
SRC=$(wildcard *.cpp)
OBJ=$(addprefix ./, $(addsuffix .o, $(basename $(SRC))))
TARGET=tt
all: $(TARGET)
$(TARGET): $(SRC)
    $(CC) -o [email protected] $^ $(CFLAGS)
    @echo make all done
%.o: %.cpp
    $(CC) $(CFLAGS) -o [email protected] -c $<
clean:
    rm -f $(TARGET) $(OBJ)

Makefile

时间: 2024-10-19 18:54:00

ACE_linux:读写锁的相关文章

Java并发程序设计(15)并发锁之读写锁(续二)写锁降级

1.1.1. 读写锁应用之三写锁降级 ReentrantReadWriteLock还具有写锁降级的特点,而这跟可重入性有一些关系. (1)持有写锁时可以降级为读锁. (2)持有读锁时不能升级为写锁. ReentrantReadWriteLock和ReentrantLock相似的是都有一个特点,就是可重入.可重入指已经获取到锁的线程可以再次获取锁,保证lock和unlock的次数相同即可. package com.test.concurrence; import java.util.Random;

ReentrantReadWriteLock读写锁的使用2

本文可作为传智播客<张孝祥-Java多线程与并发库高级应用>的学习笔记. 这一节我们做一个缓存系统. 在读本节前 请先阅读 ReentrantReadWriteLock读写锁的使用1 第一版 public class CacheDemo { private Map<String, Object> cache = new HashMap<String, Object>(); public static void main(String[] args) { CacheDem

深入浅出 Java Concurrency (13): 锁机制 part 8 读写锁 (ReentrantReadWriteLock) (1)[转]

从这一节开始介绍锁里面的最后一个工具:读写锁(ReadWriteLock). ReentrantLock 实现了标准的互斥操作,也就是一次只能有一个线程持有锁,也即所谓独占锁的概念.前面的章节中一直在强调这个特点.显然这个特点在一定程度上面减低了吞吐量,实际上独占锁是一种保守的锁策略,在这种情况下任何“读/读”,“写/读”,“写/写”操作都不能同时发生.但是同样需要强调的一个概念是,锁是有一定的开销的,当并发比较大的时候,锁的开销就比较客观了.所以如果可能的话就尽量少用锁,非要用锁的话就尝试看能

锁,同步,可重入锁,读写锁(转)

1.synchronized 把代码块声明为 synchronized,有两个重要后果,通常是指该代码具有 原子性(atomicity)和 可见性(visibility). 1.1 原子性 原子性意味着个时刻,只有一个线程能够执行一段代码,这段代码通过一个monitor object保护.从而防止多个线程在更新共享状态时相互冲突. 1.2 可见性 可见性则更为微妙,它要对付内存缓存和编译器优化的各种反常行为.它必须确保释放锁之前对共享数据做出的更改对于随后获得该锁的另一个线程是可见的 . 作用:

linux 读写锁应用实例

转自:http://blog.csdn.net/dsg333/article/details/22113489 /*使用读写锁实现四个线程读写一段程序的实例,共创建了四个新的线程,其中两个线程用来读取数据,另外两个线程用来写入数据.在任意时刻,如果有一个线程在写数据,将阻塞所有其他线程的任何操作.*/#include <errno.h>#include <pthread.h>#include <stdio.h>#include <stdlib.h>#incl

读写锁ReadWriteLock和缓存实例

读写锁:多个读锁不互斥,读锁与些锁互斥,写锁与写锁互斥.即:读的时候不允许写,写的时候不允许读,可以同时读. synchronized关键字和普通的Lock构造的锁,会造成读与读之间的互斥,因此读写锁可提高性能. 例子1:三个线程同时对一个共享数据进行读写. import java.util.Random; import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantRea

Linux多线程实践(6) --Posix读写锁解决读者写者问题

Posix读写锁 int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr); int pthread_rwlock_destroy(pthread_rwlock_t *rwlock); int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock); int pthread_rwlock_wrlock(pthre

深入浅出 Java Concurrency (14): 锁机制 part 9 读写锁 (ReentrantReadWriteLock) (2)[转]

这一节主要是谈谈读写锁的实现. 上一节中提到,ReadWriteLock看起来有两个锁:readLock/writeLock.如果真的是两个锁的话,它们之间又是如何相互影响的呢? 事实上在ReentrantReadWriteLock里锁的实现是靠java.util.concurrent.locks.ReentrantReadWriteLock.Sync完成的.这个类看起来比较眼熟,实际上它是AQS的一个子类,这中类似的结构在CountDownLatch.ReentrantLock.Semapho

数据库读写锁的实现(C++)

一.基本概念 在数据库中,对某数据的两个基本操作为写和读,分布有两种锁控制:排它锁(X锁).共享锁(S锁). 排它锁(x锁):若事务T对数据D加X锁,则其它任何事务都不能再对D加任何类型的锁,直至T释放D上的X锁: 一般要求在修改数据前要向该数据加排它锁,所以排它锁又称为写锁. 共享锁(s锁):若事务T对数据D加S锁,则其它事务只能对D加S锁,而不能加X锁,直至T释放D上的S锁: 一般要求在读取数据前要向该数据加共享锁, 所以共享锁又称读锁. 程序所收到的请求包括以下五种:Start.End.X