互斥量trylock与lock

最新推荐文章于 2024-01-13 13:26:03 发布
最新推荐文章于 2024-01-13 13:26:03 发布
阅读量811 收藏
点赞数
分类专栏： linux 多线程 文章标签： mutex 多线程基础 linux基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011324001/article/details/20381233
版权

代码1： 

#include<stdio.h>
#include<pthread.h>

pthread_mutex_t     mutex;
int                 num = 3;

void* thr_fn1(void* arg)
{
    pthread_mutex_lock(&mutex);
    printf("mutex locked by thread 1.\n");

    int i;
    for(i = 0; i != 5; ++i)
    {
        num += 1;
        printf("thread 1: %d\n", num);
        if (i == 2) {
            sleep(3);
        }
    }

    printf("mutex unlocked by thread 1.\n");
    pthread_mutex_unlock(&mutex);

    return ((void*)0);
}

void* thr_fn2(void* arg)
{

    sleep(2);
    pthread_mutex_lock(&mutex);
    printf("mutex locked by thread 2.\n");

    int i;
    for(i = 0; i != 5; ++i)
    {
        num += 1;
        printf("thread 2: %d\n", num);
    }

    printf("mutex unlocked by thread 2.\n");
    pthread_mutex_unlock(&mutex);

    return ((void*)0);
}

int main()
{
    int         err;
    pthread_t   tid1, tid2;
    void        *tret;

    pthread_mutex_init(&mutex, NULL);

    pthread_create(&tid1, NULL, thr_fn1, NULL);

    pthread_create(&tid2, NULL, thr_fn2, NULL);
    
    pthread_join(tid2, tret);
    pthread_join(tid1, tret);

    pthread_mutex_destroy(&mutex);

    return 0;
}


运行结果：

mutex locked by thread 1.
thread 1: 4
thread 1: 5
thread 1: 6
thread 1: 7
thread 1: 8
mutex unlocked by thread 1.
mutex locked by thread 2.
thread 2: 9
thread 2: 10
thread 2: 11
thread 2: 12
thread 2: 13
mutex unlocked by thread 2.


代码2：

#include<stdio.h>
#include<pthread.h>

pthread_mutex_t     mutex;
int                 num = 3;

void* thr_fn1(void* arg)
{
    pthread_mutex_trylock(&mutex);
    printf("mutex locked by thread 1.\n");

    int i;
    for(i = 0; i != 5; ++i)
    {
        num += 1;
        printf("thread 1: %d\n", num);
        if (i == 2) {
            sleep(3);
        }
    }

    printf("mutex unlocked by thread 1.\n");
    pthread_mutex_unlock(&mutex);

    return ((void*)0);
}

void* thr_fn2(void* arg)
{

    sleep(2);
    pthread_mutex_trylock(&mutex);
    printf("mutex locked by thread 2.\n");

    int i;
    for(i = 0; i != 5; ++i)
    {
        num += 1;
        printf("thread 2: %d\n", num);
    }

    printf("mutex unlocked by thread 2.\n");
    pthread_mutex_unlock(&mutex);

    return ((void*)0);
}

int main()
{
    int         err;
    pthread_t   tid1, tid2;
    void        *tret;

    pthread_mutex_init(&mutex, NULL);

    pthread_create(&tid1, NULL, thr_fn1, NULL);

    pthread_create(&tid2, NULL, thr_fn2, NULL);
    
    pthread_join(tid2, tret);
    pthread_join(tid1, tret);

    pthread_mutex_destroy(&mutex);

    return 0;
}



运行结果：

mutex locked by thread 1.
thread 1: 4
thread 1: 5
thread 1: 6
mutex locked by thread 2.
thread 2: 7
thread 2: 8
thread 2: 9
thread 2: 10
thread 2: 11
mutex unlocked by thread 2.
thread 1: 12
thread 1: 13
mutex unlocked by thread 1.


原因是：

lock函数和tryLock函数都是用于锁定对象，但他们之间有一定的区别：

lock函数是阻塞的，因为它调用WaitForSingleObject函数时传递的第二个参数是INFINITE，表示无限等待下去，所以是阻塞的。

tryLock函数时非阻塞的，调用后立即返回。因为它调用WaitForSingleObject函数时传递的第二个参数是0，表示不等待，立即返回。

调用lock或者tryLock后，都需要调用unlock来解锁。


另：

【转】WaitForSingleObject函数用法

用户模式的线程同步机制效率高，如果需要考虑线程同步问题，应该首先考虑用户模式的线程同步方法。
　　但是，用户模式的线程同步有限制，对于多个进程之间的线程同步，用户模式的线程同步方法无能为力。这时，只能考虑使用内核模式。

　　Windows提供了许多内核对象来实现线程的同步。对于线程同步而言，这些内核对象有两个非常重要的状态：“已通知”状态，“未通知”状态（也有翻译为：受信状态，未受信状态）。Windows提供了几种内核对象可以处于已通知状态和未通知状态：进程、线程、作业、文件、控制台输入/输出/错误流、事件、等待定时器、信号量、互斥对象。

　　你可以通知一个内核对象，使之处于“已通知状态”，然后让其他等待在该内核对象上的线程继续执行。你可以使用Windows提供的API函数，等待函数来等待某一个或某些内核对象变为已通知状态。

　　你可以使用WaitForSingleObject函数来等待一个内核对象变为已通知状态：

DWORD WaitForSingleObject(
HANDLE hObject, //指明一个内核对象的句柄
DWORD dwMilliseconds //等待时间
);


　　该函数需要传递一个内核对象句柄，该句柄标识一个内核对象，如果该内核对象处于未通知状态，则该函数导致线程进入阻塞状态；如果该内核对象处于已通知状态，则该函数立即返回WAIT_OBJECT_0。第二个参数指明了需要等待的时间（毫秒），可以传递INFINITE指明要无限期等待下去，如果第二个参数为0，那么函数就测试同步对象的状态并立即返回。如果等待超时，该函数返回WAIT_TIMEOUT。如果该函数失败，返回WAIT_FAILED。可以通过下面的代码来判断： 

DWORD dw = WaitForSingleObject(hProcess, 5000); //等待一个进程结束
switch (dw)
{
    case WAIT_OBJECT_0:
    // hProcess所代表的进程在5秒内结束
    break;
    case WAIT_TIMEOUT:
    // 等待时间超过5秒
    break;
    case WAIT_FAILED:
    // 函数调用失败，比如传递了一个无效的句柄
    break;
}


　　
还可以使用WaitForMulitpleObjects函数来等待多个内核对象变为已通知状态：

DWORD WaitForMultipleObjects(
DWORD dwCount, //等待的内核对象个数
CONST HANDLE* phObjects, //一个存放被等待的内核对象句柄的数组
BOOL bWaitAll, //是否等到所有内核对象为已通知状态后才返回
DWORD dwMilliseconds //等待时间
);


　　该函数的第一个参数指明等待的内核对象的个数，可以是0到MAXIMUM_WAIT_OBJECTS（64）中的一个值。phObjects参数是一个存放等待的内核对象句柄的数组。bWaitAll参数如果为TRUE，则只有当等待的所有内核对象为已通知状态时函数才返回，如果为FALSE，则只要一个内核对象为已通知状态，则该函数返回。第四个参数和WaitForSingleObject中的dwMilliseconds参数类似。

　　该函数失败，返回WAIT_FAILED；如果超时，返回WAIT_TIMEOUT；如果bWaitAll参数为TRUE，函数成功则返回WAIT_OBJECT_0，如果bWaitAll为FALSE，函数成功则返回值指明是哪个内核对象收到通知。

　　可以如下使用该函数：

HANDLE h[3]; //句柄数组
//三个进程句柄
h[0] = hProcess1;
h[1] = hProcess2;
h[2] = hProcess3;
DWORD dw = WaitForMultipleObjects(3, h, FALSE, 5000); //等待3个进程结束
switch (dw)
{
case WAIT_FAILED:
// 函数呼叫失败
break;
case WAIT_TIMEOUT:
// 超时
break;
case WAIT_OBJECT_0 + 0:
// h[0]（hProcess1）所代表的进程结束
break;
case WAIT_OBJECT_0 + 1:
// h[1]（hProcess2）所代表的进程结束
break;
case WAIT_OBJECT_0 + 2:
// h[2]（hProcess3）所代表的进程结束
break;
}


　　
你也可以同时通知一个内核对象，同时等待另一个内核对象，这两个操作以原子的方式进行：

DWORD SignalObjectAndWait(
HANDLE hObjectToSignal, //通知的内核对象
HANDLE hObjectToWaitOn, //等待的内核对象
DWORD dwMilliseconds, //等待的时间
BOOL bAlertable); //与IO完成端口有关的参数，暂不讨论


　　该函数在内部使得hObjectToSignal参数所指明的内核对象变成已通知状态，同时等待hObjectToWaitOn参数所代表的内核对象。dwMilliseconds参数的用法与WaitForSingleObject函数类似。
　　该函数返回如下：WAIT_OBJECT_0，WAIT_TIMEOUT，WAIT_FAILED，WAIT_IO_COMPLETION。

　　等你需要通知一个互斥内核对象并等待一个事件内核对象的时候，可以这么写：

ReleaseMutex(hMutex);
WaitForSingleObject(hEvent, INFINITE);


　　可是，这样的代码不是以原子的方式来操纵这两个内核对象。因此，可以更改如下： 

SignalObjectAndWait(hMutex, hEvent, INFINITE, FALSE);
明天太远_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
redisson lock和tryLock 分布式锁简单练习
01-10
redisson lock和tryLock 分布式锁简单练习
test try lock java
09-19
演示如何通过java nio设计lock
Java内置锁：深度解析lock和trylock
最新发布
科技互联网领域深度探索者，乐于分享与写作。
01-13 1732
lock和tryLock是两种获取锁的方式，它们在处理并发问题时有所不同，lock是阻塞性的，确保只有一个线程能访问被锁资源，但可能导致线程长时间等待；而tryLock非阻塞性，若锁被占用则立即返回失败，避免了长时间等待，但需要更复杂的逻辑处理未能获锁的情况。
Mutex的lock(), tryLock()区别
把握自己。
09-03 8978
lock函数和tryLock函数都是用于锁定对象，但他们之间有一定的区别： lock函数是阻塞的，因为它调用WaitForSingleObject函数时传递的第二个参数是INFINITE，表示无限等待下去，所以是阻塞的。 tryLock函数时非阻塞的，调用后立即返回。因为它调用WaitForSingleObject函数时传递的第二个参数是0，表示不等待，立即返回。 调用lock或者t
Linux线程同步之互斥锁和读写锁
Selenitic_G的博客
12-19 571
Linux线程同步之互斥锁和读写锁
13 C++11 线程同步之互斥锁
Snow__Sunny的博客
10-27 760
C++11 互斥锁
Lock总结.doc
12-25
java多线程之lock。 Lock的基本用法如下，为了防止异常退出时没有释放锁，一般都在拿到锁后立马try，try住所有临界区的代码，然后finally释放锁。
Lock_TryLock.rar
05-22
本示例是基于QT多线程互锁的示例，介绍了QMutex lock,trylock以及QMutexLocker的用法区别。
await-lock:互斥锁用于异步功能
05-02
等候锁 互斥锁用于异步功能用法import AwaitLock from 'await-lock' ;let lock = new AwaitLock ( ) ;async function runSerialTaskAsync ( ) { await lock . acquireAsync ( ) ; try { // IMPORTANT: Do not return...
Linux——什么是互斥与互斥锁
weixin_61857742的博客
01-28 1186
所谓互斥，其实就是在某一时刻只能有一个线程访问临界区，且完整的使用临界资源没有其他线程打扰，即原子性。简单来说就是当前线程使用完临界资源后其他线程才能来使用。互斥锁通俗来讲就是用来完成互斥行为的对象，锁住的范围一般就是临界区。需要互斥操作的多线程共享一个互斥锁，当一个线程获得互斥锁后，其他线程会阻塞等待，直到当前线程归还互斥锁后，其他线程争抢互斥锁，谁获得了谁能进入临界区执行代码。
lock接口的lock()和tryLock()区别
小雨的光的博客
11-09 7898
正文开始前先把lock接口的源码摆出来（精简后的，特意保留了部分注释） public interface Lock { /** * Acquires the lock. */ void lock(); /** * Acquires the lock unless the current thread is * {@linkpl...
lock ，tryLock lockInterruptibly 区别
浩子的博客
03-29 1923
ReentrantLock 锁有好几种，除了常用的lock ，tryLock ，其中有个lockInterruptibly 。 先把API粘贴上来 lock public void lock() 获取锁。 如果该锁没有被另一个线程保持，则获取该锁并立即返回，将锁的保持计数设置为 1。 如果当前线程已经保持该锁，则将保持计数加 1，并且该方法立即返回。 如果该锁被另一个线程保持，则出于线程调
Lock锁中lock()与tryLock()的区别
Morning Sunshine的IT技术博客
08-30 4798
Lock锁中lock()与tryLock()的区别 在ReentrantLock 中， Lock()方法： 　　lock()方法是一个无条件的锁，与synchronize意思差不多，直接去获取锁。成功了就ok了，失败了就进入阻塞等待了。不同的是lock锁是可重入锁。 另一个方法 tryLock()方法： 　　当获取锁时，只有当该锁资源没有被其他线程持有时才可以获取到，成功获取到锁资源之后，会立即返回true； 　　当获取锁时，如果有其他的线程正在持有该锁，无可用锁资源，则...
lock接口lock和tryLock的区别
Xiaoqiu的博客
01-29 1341
https://www.cnblogs.com/wenbochang/p/11317571.html 推荐优先使用trylock
linux c pthread_mutex_lock和pthread_mutex_trylock对比
johnsonchengwu的专栏
10-10 2554
1. 需要用到的函数 pthread_mutex_lock phtread_mutex_trylock pthread_mutex_unlock
Lock的tryLock()方法
热门推荐
松门一枝花
11-21 1万+
概述 tryLock()方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false，这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。 代码 @Test public void testTryLock() { Lock lock = new ReentrantLock(); new Threa
java中的Lock和tryLock方法的详解
yinbucheng的博客
06-10 9233
Lock接口还提供了另一种方法来获取锁，即tryLock()方法。跟lock()方法最大的不同是：线程使用tryLock()不能获取锁，tryLock()会立即返回，它不会将线程置入休眠。tryLock()方法返回一个布尔值，true表示线程获取了锁，false表示没有获取锁。  ReentrantLock类也允许使用递归调用。如果一个线程获取了锁并且进行了递归调用，它将继续持有这个锁，因此调用
qt qmutex tryLock怎么用
06-09
QMutex::tryLock()函数是QMutex类的成员函数，用于尝试获取互斥量锁。如果锁可用，则获取锁并返回true，否则返回false。 下面是一个示例代码： ``` QMutex mutex; if (mutex.tryLock()) { // 获取锁成功，执行操作 ... mutex.unlock(); // 释放锁 } else { // 获取锁失败，执行其他操作 ... } ``` 在这个例子中，我们首先创建了一个QMutex对象mutex，然后在代码块中使用了tryLock()函数来尝试获取锁。如果获取锁成功，则执行一些操作，最后使用unlock()函数释放锁。如果获取锁失败，则执行其他操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值