关于多线程mutex 或者锁的问题

问题描述

关于多线程mutex 或者锁的问题

Object1 a;
Object2 b;
Object3 c;

handle mutexa;
handle mutexb;
handle mutexc;
handle mutexd;

void threadfunction1()
{
mutexa.acquire();
op(a); // 对对象a的读写操作
mutexa.release();

 mutexb.acquire();
 op(b);  // 对对象b的读写操作
 mutexb.release();

 commonFun();

}

void threadfucntion2()
{
mutexa.acquire();
op(a); // 对对象a的读写操作
mutexa.release();

 mutexd.acquire();  // 这里用的是 mutexd,跟threadfun1不同
 op(b);  // 对对象b的读写操作
 mutexd.release();

commonFun();

}

void commonFun()
{
mutex.acquire();
printf(“1111111n”);
printf(“2222222n”);
printf(“3333333n”);
printf(“4444444n”);
op(c); // 对对象c的读写操作
mutex.release();
}

void main()
{
thread1; // 调用的是function1;
thread2; // 调用的是function1;
.
.
thread50; // 调用的是function1;

    //-------------
    thread51;  // 调用的是function2;
thread52; // 调用的是function2;
    .
    .
    thread100;  // 调用的是function2;
start();

}

以上的这段代码,关于对象b,是否成功被保护了?
问题2. 每个进程中访问临界资源的那段代码称为临界区(Critical Section),根据临界区的概念,commonfun 属于临界区,还有哪些代码是临界区?
问题3.commonfun中的输出语句 会是
1111
2222
3333
4444
1111
2222
3333
4444

还是 会出现乱序情况
1111
1111
2222
3333
3333

解决方案

1、没有。用的不是同一个mutex。
2、完全不是一个概念:临界区(Critical section)与互斥体(Mutex)的区别
3、应该是有序的。不过你用的是哪个 mutext?

时间: 2024-09-17 04:52:48

关于多线程mutex 或者锁的问题的相关文章

python多线程threading.Lock锁用法实例_python

本文实例讲述了python多线程threading.Lock锁的用法实例,分享给大家供大家参考.具体分析如下: python的锁可以独立提取出来 复制代码 代码如下: mutex = threading.Lock() #锁的使用 #创建锁 mutex = threading.Lock() #锁定 mutex.acquire([timeout]) #释放 mutex.release() 锁定方法acquire可以有一个超时时间的可选参数timeout.如果设定了timeout,则在超时后通过返回值

Java多线程:“JUC锁”04之公平锁(二)

概要 前面一章,我们学习了"公平锁"获取锁的详细流程:这里,我们再来看看"公平锁 "释放锁的过程.内容包括: 参考代码 释放公平锁(基于JDK1.7.0_40) "公平锁"的获取过程请参考"Java多线程系列--"JUC锁"03之 公平锁 (一)",锁的使用示例请参考"Java多线程系列--"JUC锁"02之 互斥锁 ReentrantLock". 注意: (01)

Java多线程:“JUC锁”02之互斥锁ReentrantLock

ReentrantLock介绍 ReentrantLock是一个可重入的互斥锁,又被称为"独占锁". 顾名思义,ReentrantLock锁在同一个时间点只能被一个线程锁持有:而可重入的意思是, ReentrantLock锁,可以被单个线程多次获取. ReentrantLock分为"公平锁"和"非 公平锁".它们的区别体现在获取锁的机制上是否公平."锁"是为了保护竞争资源, 防止多个线程同时操作线程而出错,ReentrantL

Java多线程:“JUC锁”01之框架

根据锁的添加到Java中的时间,Java中的锁,可以分为"同步锁"和 "JUC包中的锁". 同步锁 即通过synchronized关键字来进行同步,实现对竞争资源的互斥访问的锁.Java 1.0版本中就已经支 持同步锁了. 同步锁的原理是,对于每一个对象,有且仅有一个同步锁:不同的线程能共同访问该同步锁.但是, 在同一个时间点,该同步锁能且只能被一个线程获取到.这样,获取到同步锁的线程就能进行CPU调度, 从而在CPU上执行:而没有获取到同步锁的线程,必须进行等待,

多线程中递归锁的实现.

在上一篇文章中,我已经阐述了多线程中简单锁的实现,可在结束的时候,我就提了那么一个问题,那就是如果在一个链表中进行插入时,要进行查询的操作,如果只是简单的锁,是没法实现的.所以"递归锁"就浮现于世了. 可能有些人看到递归这两个字,有点傻了眼,其实也没什么的,简单的介绍,就是进行简单的计数而已.刚开始引用锁的时候,就产生它,当在锁没有解开的时候,还要继续用锁,就简单的加一,解开一把就减一,当计数为零时,就把锁销毁掉.下面用程序来简单的阐述一下,递归锁是怎么实现的: 1.递归锁接口的定义.

大神帮忙看看下面多线程中关于锁的使用存在的问题

问题描述 大神帮忙看看下面多线程中关于锁的使用存在的问题 #include <stdio.h> #include <process.h> #include <windows.h> #include <string> class IAnimalActionObserver { public: IAnimalActionObserver(){} virtual ~IAnimalActionObserver(){} virtual void OnAnimalEat

Java多线程:“JUC锁”03之公平锁(一)

基本概念 本章,我们会讲解"线程获取公平锁"的原理:在讲解之前,需要了解几个基本概念.后 面的内容,都是基于这些概念的:这些概念可能比较枯燥,但从这些概念中,能窥见"java锁 "的一些架构,这对我们了解锁是有帮助的. 1. AQS        -- 指AbstractQueuedSynchronizer类. AQS 是java中管理"锁"的抽象类,锁的许多公共方法都是在这个类中实现.AQS是独占锁(例如, ReentrantLock)和共享锁

Python中多线程及程序锁浅析_python

Python中多线程使用到Threading模块.Threading模块中用到的主要的类是Thread,我们先来写一个简单的多线程代码: 复制代码 代码如下: # coding : uft-8 __author__ = 'Phtih0n' import threading class MyThread(threading.Thread):     def __init__(self):         threading.Thread.__init__(self)     def run(sel

多线程 java 同步 锁-java中多线程访问同步问题

问题描述 java中多线程访问同步问题 public class SyschronizedSample{ private int value; public synchronized int get(){ return value;} public synchronized void set(int value) { this.value=value; } } 以上的代码中,要使得访问value时具有线程安全,所以在set和get方法中都加了synchronized同步语句,如果只在set方法前