`

读写锁

 
阅读更多 
#include <pthread.h>
#include <iostream>
#include <unistd.h>
using namespace std;

pthread_rwlock_t g_mutex = PTHREAD_RWLOCK_INITIALIZER;
int g_num = 0;
int g_loopNum = 10000;
int g_usleepTime = 1;

void* testRead1(void*)
{
    for(int i=0;i<g_loopNum;i++)
    {
        int ret = pthread_rwlock_rdlock(&g_mutex);
        if(ret!=0){
            cout << "read1 lock fail,num:" << g_num << endl;
        }else{
            pthread_rwlock_unlock(&g_mutex);
        }
        usleep(g_usleepTime);
    }
    pthread_detach(pthread_self());
    return 0;
}

void* testRead2(void*)
{
    for(int i=0;i<g_loopNum;i++)
    {
        int ret = pthread_rwlock_rdlock(&g_mutex);
        if(ret!=0){
            cout << "read2 lock fail,num:" << g_num << endl;
        }else{
            pthread_rwlock_unlock(&g_mutex);
        }
        usleep(g_usleepTime);
    }
    pthread_detach(pthread_self());
    return 0;
}

void* testWrite1(void*)
{
    int failTime = 0;
    for(int i=0;i<g_loopNum;i++)
    {
        int wrRet = pthread_rwlock_trywrlock(&g_mutex);
        if(wrRet!=0)
        {
            failTime++;
            cout << "testWrite1 lock fail:" << failTime <<",curr num:" << g_num << endl;
        }else
        {
            g_num++;
            pthread_rwlock_unlock(&g_mutex);
            usleep(g_usleepTime);
        }
    }
    pthread_detach(pthread_self());
    return 0;
}

void* testWrite2(void*)
{
    int failTime = 0;
    for(int i=0;i<g_loopNum;i++)
    {
        int wrRet = pthread_rwlock_trywrlock(&g_mutex);
        if(wrRet!=0)
        {
            failTime++;
            cout << "testWrite2 lock fail:" << failTime << ",curr num:" << g_num << endl;
        }else
        {
            g_num++;
            pthread_rwlock_unlock(&g_mutex);
            usleep(g_usleepTime);
        }
    }
    pthread_detach(pthread_self());
    return 0;
}

int main()
{
    pthread_t pidRead1,pidRead2,pidWrite1,pidWrite2;
    pthread_create(&pidWrite1,NULL,testWrite1,NULL);
    pthread_create(&pidWrite2,NULL,testWrite2,NULL);
    pthread_create(&pidRead1,NULL,testRead1,NULL);
    pthread_create(&pidRead2,NULL,testRead2,NULL);
    sleep(10);
}

testWrite2 lock fail:1,curr num:691
testWrite2 lock fail:2,curr num:1062
testWrite1 lock fail:1,curr num:2446
testWrite1 lock fail:2,curr num:2484
testWrite1 lock fail:3,curr num:2756
testWrite2 lock fail:3,curr num:3248
testWrite1 lock fail:4,curr num:3530
testWrite2 lock fail:4,curr num:4423
testWrite1 lock fail:5,curr num:4468
testWrite2 lock fail:5,curr num:4800
testWrite2 lock fail:6,curr num:4897
testWrite2 lock fail:7,curr num:5192
testWrite1 lock fail:6,curr num:5845
testWrite2 lock fail:8,curr num:6079
testWrite2 lock fail:9,curr num:6502
testWrite1 lock fail:7,curr num:6599
testWrite1 lock fail:8,curr num:6819
testWrite1 lock fail:9,curr num:7036
testWrite2 lock fail:10,curr num:7040
testWrite2 lock fail:11,curr num:7191
testWrite2 lock fail:12,curr num:7494
testWrite2 lock fail:13,curr num:7880
testWrite2 lock fail:14,curr num:9012
testWrite1 lock fail:10,curr num:9553
testWrite2 lock fail:15,curr num:9625
testWrite2 lock fail:16,curr num:9950
testWrite2 lock fail:17,curr num:11153
testWrite2 lock fail:18,curr num:11424
testWrite1 lock fail:11,curr num:12201
testWrite1 lock fail:12,curr num:13457
testWrite2 lock fail:19,curr num:14725
testWrite2 lock fail:20,curr num:16254
testWrite2 lock fail:21,curr num:16941
testWrite2 lock fail:22,curr num:17758
testWrite2 lock fail:23,curr num:17862
testWrite1 lock fail:13,curr num:17959
testWrite1 lock fail:14,curr num:18219


读也trylock的话 
#include <pthread.h>
#include <iostream>
#include <unistd.h>
using namespace std;

pthread_rwlock_t g_mutex = PTHREAD_RWLOCK_INITIALIZER;
int g_num = 0;
int g_loopNum = 10000;
int g_usleepTime = 1;

void* testRead1(void*)
{
    int failTime = 0;
    for(int i=0;i<g_loopNum;i++)
    {
        int ret = pthread_rwlock_tryrdlock(&g_mutex);
        if(ret!=0){
            failTime++;
            cout << "read1 lock fail:" << failTime << ",curr num:" << g_num << endl;
        }else{
            pthread_rwlock_unlock(&g_mutex);
        }
        usleep(g_usleepTime);
    }
    pthread_detach(pthread_self());
    return 0;
}

void* testRead2(void*)
{
    int failTime = 0;
    for(int i=0;i<g_loopNum;i++)
    {
        int ret = pthread_rwlock_tryrdlock(&g_mutex);
        if(ret!=0){
            failTime++;
            cout << "read2 lock fail:" << failTime << ",curr num:" << g_num << endl;
        }else{
            pthread_rwlock_unlock(&g_mutex);
        }
        usleep(g_usleepTime);
    }
    pthread_detach(pthread_self());
    return 0;
}

void* testWrite1(void*)
{
    int failTime = 0;
    for(int i=0;i<g_loopNum;i++)
    {
        int wrRet = pthread_rwlock_trywrlock(&g_mutex);
        if(wrRet!=0)
        {
            failTime++;
            cout << "testWrite1 lock fail:" << failTime <<",curr num:" << g_num << endl;
        }else
        {
            g_num++;
            pthread_rwlock_unlock(&g_mutex);
            usleep(g_usleepTime);
        }
    }
    pthread_detach(pthread_self());
    return 0;
}

void* testWrite2(void*)
{
    int failTime = 0;
    for(int i=0;i<g_loopNum;i++)
    {
        int wrRet = pthread_rwlock_trywrlock(&g_mutex);
        if(wrRet!=0)
        {
            failTime++;
            cout << "testWrite2 lock fail:" << failTime << ",curr num:" << g_num << endl;
        }else
        {
            g_num++;
            pthread_rwlock_unlock(&g_mutex);
            usleep(g_usleepTime);
        }
    }
    pthread_detach(pthread_self());
    return 0;
}

int main()
{
    pthread_t pidRead1,pidRead2,pidWrite1,pidWrite2;
    pthread_create(&pidWrite1,NULL,testWrite1,NULL);
    pthread_create(&pidWrite2,NULL,testWrite2,NULL);
    pthread_create(&pidRead1,NULL,testRead1,NULL);
    pthread_create(&pidRead2,NULL,testRead2,NULL);
    sleep(10);
}


read1 lock fail:1,curr num:2174
read1 lock fail:2,curr num:2536
read1 lock fail:3,curr num:2838
testWrite1 lock fail:1,curr num:2848
testWrite2 lock fail:1,curr num:3269
testWrite1 lock fail:2,curr num:3688
read1 lock fail:4,curr num:3872
testWrite2 lock fail:2,curr num:4053
testWrite2 lock fail:3,curr num:4106
read1 lock fail:5,curr num:4569
read1 lock fail:6,curr num:5755
read1 lock fail:7,curr num:6095
testWrite1 lock fail:3,curr num:6095
read1 lock fail:8,curr num:6154
testWrite2 lock fail:4,curr num:6526
read2 lock fail:1,curr num:6801
testWrite1 lock fail:4,curr num:6939
testWrite1 lock fail:5,curr num:7649
read1 lock fail:9,curr num:7786
read1 lock fail:10,curr num:7958
testWrite1 lock fail:6,curr num:8069
read1 lock fail:11,curr num:9853
read1 lock fail:12,curr num:10167
testWrite2 lock fail:5,curr num:10335
read1 lock fail:13,curr num:10699
testWrite1 lock fail:7,curr num:10735
testWrite1 lock fail:8,curr num:11027
read2 lock fail:read1 lock fail:2,curr num:1149914,curr num:
11499
testWrite2 lock fail:6testWrite1 lock fail:,curr num:9,curr num:1189611896

testWrite1 lock fail:10,curr num:11896
testWrite2 lock fail:7,curr num:11897
read2 lock fail:3,curr num:12133
read1 lock fail:15,curr num:12395
read1 lock fail:16,curr num:12813
testWrite2 lock fail:8,curr num:13051
testWrite1 lock fail:11,curr num:13084
read2 lock fail:4,curr num:13818
read1 lock fail:17,curr num:13831
read1 lock fail:18,curr num:14321
testWrite2 lock fail:9,curr num:14570
read1 lock fail:19,curr num:15401
testWrite2 lock fail:10,curr num:15527
testWrite1 lock fail:12,curr num:15633
read1 lock fail:20,curr num:16261
read1 lock fail:21,curr num:16539
testWrite1 lock fail:13,curr num:16811
read2 lock fail:5,curr num:17187
testWrite1 lock fail:14,curr num:17318
read1 lock fail:22,curr num:18077
testWrite2 lock fail:11,curr num:18108
testWrite1 lock fail:15,curr num:18109
read1 lock fail:23,curr num:18357
read1 lock fail:24,curr num:18759
testWrite1 lock fail:16,curr num:19338
分享到：
| trylock
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    WINDOWS读写锁实现

    在Windows操作系统中，读写锁（Read-Write Lock）是一种多线程同步原语，它允许多个线程同时读取共享资源，但在写入时仅允许一个线程访问。这提高了并发性能，尤其是在读操作远多于写操作的场景下。本篇文章将深入...

    windows和linux读写锁C++实现

    在多线程编程中，读写锁是一种非常重要的同步机制，它允许多个读线程同时访问共享资源，但只允许一个写线程独占资源，从而提高了并发性能。本话题将详细探讨在Windows和Linux环境下，如何使用C++来实现读写锁。 ...

    易语言线程安全之原子锁与读写锁

    本文将深入探讨易语言中的原子锁与读写锁。 原子操作是一种不可分割的操作，它在执行过程中不会被其他线程中断。在易语言中，原子操作常用于更新计数器、标志位等简单数据类型的场景，避免了线程间的竞态条件。例如...

    windows 读写锁 （基于关键区的读写锁类 及自动锁）

    其中，读写锁（Read-Write Lock，简称RWLock）是一种高效的线程同步机制，适用于大量读取操作和少量写入操作的情况。在本文中，我们将深入探讨基于关键区的Windows读写锁类及其自动锁的实现原理和改进点。 读写锁的...

    java 读写锁代码

    Java 读写锁是Java并发编程中的一种重要机制，它为多线程环境下的数据访问提供了更为精细的控制。在Java的`java.util.concurrent.locks`包中，`ReentrantReadWriteLock`类实现了读写锁的功能。这个锁允许多个读取者...

    C#使用读写锁三行代码简单解决多线程并发的问题

    为了解决这个问题，我们可以利用C#中的读写锁（ReaderWriterLockSlim）来实现线程同步。本文通过三行代码展示了如何使用读写锁解决多线程并发写入文件的冲突。 读写锁的核心在于，它允许多个线程同时读取资源，但只...

    linux写优先的读写锁设计

    linux写优先的读写锁设计 在 Linux 操作系统中，有两种基本机制来实现数据互斥，即信号量（semaphore）和自旋锁（spinlock）。本文将讨论一种特殊的自旋锁变种，即读写锁（read-write lock），它允许多个进程同时...

    linux下实现高性能读写锁（read/write lock）

    在Linux系统中，读写锁（Read/Write Locks，简称rwlocks）是一种多线程同步机制，它允许多个线程同时进行读操作，但只允许一个线程执行写操作。这种锁的设计目的是提高并发性能，特别是当读操作远多于写操作时。在...

    C#解决SQlite并发异常问题的方法(使用读写锁)

    本文实例讲述了C#解决SQlite并发异常问题的方法。分享给大家供大家参考，...作者利用读写锁（ReaderWriterLock），达到了多线程安全访问的目标。 using System; using System.Collections.Generic; using System.Text;

    同步 读写锁 readwriteLock

    ### 同步机制中的读写锁 (Read-Write Lock) #### 概述 在多线程编程中，读写锁是一种特殊的同步机制，用于解决读者写者问题。它允许多个线程同时读取共享资源，但只允许一个线程写入资源。这种机制通过将读操作和...

    读写锁实现例子

    在这个例子中，我们讨论了如何使用读写锁（Read-Write Lock）来实现多线程环境中的并发访问控制。读写锁是一种高级的同步机制，它允许多个线程同时读取共享资源，但只允许一个线程进行写操作。这在数据读取远比写入...

    操作系统实验--读写锁

    操作系统中的读写锁是一种多线程同步机制，用于在并发环境中高效地管理共享资源的访问。在计算机系统中，特别是当多个线程需要同时访问同一数据时，读写锁能够提供一种策略，允许多个线程同时读取资源，但只允许一个...

    基于zookeeper实现的分布式读写锁

    本文将深入探讨基于Zookeeper实现的分布式读写锁，并利用Zkclient客户端进行操作。Zookeeper是一个分布式服务协调框架，它提供了一种简单且高效的方式来实现分布式锁。 **一、Zookeeper简介** Zookeeper是由Apache...

    易语言读写锁1.2模块源码

    易语言读写锁1.2模块源码例程程序调用API函数实现读写锁功能的操作。点评：读写锁实际是一种特殊的锁，它把对共享资源的访问者划分成读者和写者，读者只对共享资源进行读访问，写者则对共享资源进行写操作。这种锁相...

    读写锁_读写锁_

    读写锁是多线程编程中的一个重要概念，用于提高并发访问数据时的效率。在并发环境中，如果多个线程同时读取数据，通常不会产生冲突，而写入数据时则可能引发问题。读写锁正是为了解决这个问题，它允许多个读取线程...

    简单读写锁实例代码

    在C++编程中，读写锁（Read-Write Lock）是一种多线程同步机制，它允许多个线程同时读取共享资源，但只允许一个线程写入。这种锁机制提高了对共享数据的并发访问效率，是并发编程中常用的一种工具。本实例将通过代码...

    读写锁源代码（C#编写）

    读写锁是多线程编程中的一个重要概念，它在C#中被广泛应用于提高并发访问数据的效率。本文将深入探讨C#中的读写锁及其使用，帮助你理解和掌握这一关键技能。 首先，读写锁提供了对共享资源的细粒度控制。在C#中，`...

    mysql读写锁演示案例

    ### MySQL读写锁知识点详解 #### 一、读写锁概念与特征 在数据库系统中，锁机制是一种非常重要的并发控制手段，它主要用于确保多用户同时访问数据时的一致性和完整性。MySQL作为一款广泛使用的开源关系型数据库...

    标准C写的线程池和读写锁

    在IT领域，线程池和读写锁是两种重要的多线程编程技术，尤其是在Linux操作系统中。本项目提供了一个标准C语言实现的线程池，同时整合了读写锁的实现，这对于提升程序的并发性能和资源管理具有重要意义。 线程池是一...

    linux 读写锁应用实例

    inux 读写锁应用实例 /*使用读写锁实现四个线程读写一段程序的实例，共创建了四个新的线程，其中两个线程用来读取数据，另外两个线程用来写入数据。在任意时刻，如果有一个线程在写数据，将阻塞所有其他线程的任何...

Magicbox
Global site tag (gtag.js) - Google Analytics