互斥锁(Mutex)

互斥锁(Mutex)
互斥锁是一个互斥的同步对象,意味着同一时间有且仅有一个线程可以获取它。
互斥锁可适用于一个共享资源每次只能被一个线程访问的情况

函数:
//创建一个处于未获取状态的互斥锁
Public Mutex();
//如果owned为true,互斥锁的初始状态就是被主线程所获取,否则处于未获取状态
Public Mutex(bool owned);

如果要获取一个互斥锁。应调用互斥锁上的WaitOne()方法,该方法继承于Thread.WaitHandle类
它处于等到状态直至所调用互斥锁可以被获取,因此该方法将组织住主调线程直到指定的互斥锁可用,如果不需要拥有互斥锁,用ReleaseMutex方法释放,从而使互斥锁可以被另外一个线程所获取。

Public Mutex(bool owned,name,out flag);
name为互斥量的名字,也就是说在操作系统中只有一个命名为name的互斥量mutex,如果一个线程得到这个name的互斥锁,其他线程就无法得到这个互斥锁了,必须等待那个线程对这个线程释放
参考代码实验:
代码如下:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleAppMutex
{
    class Program
    {
        /// <summary>
        /// 单实例执行测试
        /// </summary>
        /// <param name="args"></param>
        [STAThread] //指示应用程序的Com线程模型是单线程单元(STA)
        static void Main(string[] args)
        {
            string name = "Test";

            /**
             * 测试1
             * */

            bool flag = false;
            //第一个参数:true--给调用线程赋予互斥体的初始所属权
            //第一个参数:互斥体的名称
            //第三个参数:返回值,如果调用线程已被授予互斥体的初始所属权,则返回true
            System.Threading.Mutex mutex = new System.Threading.Mutex(true, name, out flag);

            if (flag)
            {
                Console.Write("Running");
            }
            else
            {
                Console.Write("Another is Running");
                System.Threading.Thread.Sleep(5000);//线程挂起5秒钟
                Environment.Exit(1);//退出程序
            }
            Console.ReadLine();

            /**
            * 测试2
            * */

            //创建单实例对象
            //System.Threading.Mutex mutex2 = new System.Threading.Mutex(false, name);

            //if (!mutex2.WaitOne(10, false)) //做单实例检测
            //{
            //    Console.Write("Another is Running");
            //    System.Threading.Thread.Sleep(5000);//线程挂起5秒钟
            //    Environment.Exit(1);//退出程序
            //}
            //else
            //{
            //    Console.Write("Running");
            //}
            //Console.ReadLine();
        }

    }
}

运行以上代码生成的应用程序第一个实例,会得到结果
Running
保持第一个运行状态,运行第二个实例,得到结果
Another is Running
以上代码中创建了一个mutex,从其参数的解释中得知,第一个调用线程将得到互斥体的初始所属权,如果不释放的话,其他的线程得不到互斥体所有权。

1.运行两个工程,同时将以上代码放入工程中,第一个工程运行,得到结果
Running
保持第一个运行状态,运行第二个工程,得到结果
Another is Running
2.将一个工程中的System.Threading.Mutex mutex = new System.Threading.Mutex(true, "Test", out flag);改为
System.Threading.Mutex mutex = new System.Threading.Mutex(true, "Test1", out flag);
然后第一个工程运行,得到结果
Running
保持第一个运行状态,运行第二个工程,得到结果
Running
则说明在系统中,mutex的name是在系统中是唯一的。

时间: 2024-11-05 13:35:38

互斥锁(Mutex)的相关文章

深入理解Solaris内核中互斥锁(mutex)与条件变量(condvar)之协同工作原理

在Solaris上写内核模块总是会用到互斥锁(mutex)与条件变量(condvar), 光阴荏苒日月如梭弹指一挥间,Solaris的大船说沉就要沉了,此刻心情不是太好(Orz).每次被年轻的有才华的同事们(比如Letty同学)问起mutex和cv怎么协同工作的,我总是不能给出一个非常清晰的解释.直到今天,看了cv_wait()的源代码之后,我终于可以给他们一个清楚明白的回答了. Solaris的源码无法被公开粘贴出来,幸好还有OpenSolaris的继承者illumos. 先贴cv_wait(

线程锁(互斥锁Mutex)

线程锁(互斥锁Mutex) 一个进程下可以启动多个线程,多个线程共享父进程的内存空间,也就意味着每个线程可以访问同一份数据,此时,如果2个线程同时要修改同一份数据,会出现什么状况? # -*- coding:utf-8 -*- import threading import time num = 100#设定一个共享变量:num=100在主线程中,我想要在子线程中修改num def run(n): global num#在函数里修改函数外变量,首先应该声明为全局变量,在每个线程中都获取这个全局变

互斥锁mutex的使用

using (var mutex = new Mutex(false, "name")) { try { mutex.WaitOne(); //do something } catch(Exception ex) { throw ex; } finally { mutex.ReleaseMutex(); } } 1.initiallyOwned表示创建mutex的线程是否拥有该互斥体.true表示创建线程拥有互斥锁,只有在创建线程中调用ReleaseMutex释放后,其他等待线程才能参

互斥锁

在单线程条件下,由于对数据操作,在同样的时间下,只有一个线程来操作.所以不用担心数据的同步问题.现代的操作系统,大都提供并发机制,虽然有时候是表面的并发.在Linux中,并发用的最多的是基于线程的并发,进程的代价太高了,这样,一个共享的数据,在同一时间内互斥锁提供一个可以在同一时间,只让一个线程访问临界资源的的操作接口.互斥锁(Mutex)是个提供线程同步的基本锁.让上锁后,其他的线程如果想要锁上,那么会被阻塞,直到锁释放后. 如果,在锁释放后,有多个线程被阻塞,那么,所有的被阻塞的线程会被设为

互斥锁 笔记

.线程访问机制 任务间的关系有两种:1,间接关系;2,直接关系. 例如1. 任务A对莫个缓冲区进行写操作.任务B从这个缓冲区进行读操作.那么A和B的关系就是直接的关系,那么实现这种直接关系的机制就是同步 2. 任务A要使用打印机,任务b也要使用打印机,那么只有在任务A使用结束的情况下才能使用打印机,所以A和B的关系是间接的关系.那么要实现这种间接的关系的机制是互斥. 在linux中实现线程间的互斥和同步的主要的机制是:信号量和互斥锁 互斥锁 mutex 是一种简单的加锁的方法来控制对共享资源的存

linux c学习笔记----互斥锁属性

转自:http://lobert.iteye.com/blog/1762844 互斥锁属性 使用互斥锁(互斥)可以使线程按顺序执行.通常,互斥锁通过确保一次只有一个线程执行代码的临界段来同步多个线程.互斥锁还可以保护单线程代码. 要更改缺省的互斥锁属性,可以对属性对象进行声明和初始化.通常,互斥锁属性会设置在应用程序开头的某个位置,以便可以快速查找和轻松修改.表 4–1 列出了用来处理互斥锁属性的函数. 表 4–1 互斥锁属性例程 操作 相关函数说明 初始化互斥锁属性对象 pthread_mut

自旋锁与互斥锁

自旋锁(spinlock)与互斥锁(mutex)是并发编程中两个重要的概念.它们的主要作用是:对共享资源加锁以阻止数据的并发访问,从而保证数据一致性.但是它们也有一些不同点.本文主要介绍这些不同点,并说明我们什么时候该用自旋锁,什么时候该用互斥锁. 理论基础 理论上,当一个线程尝试去获取一个互斥锁,但由于该互斥锁已经被其它线程获取而没有成功时,它会立刻进入休眠状态,从而让出CPU时间,允许其它线程运行.它将持续休眠直到最终被唤醒,唤醒的条件是之前获取到该互斥锁的线程释放了互斥锁: 对比一下,当一

互斥锁不在一个线程内引发的问题

本实验创建了3个进程,为了更好的描述线程之间的并行执行, 让3个线程共用同一个执行函数.每个线程都有5次循环(可以看成5个小任务), 每次循环之间会随机等待1-10s的时间,意义在于模拟每个任务的到达时间是随机的,并没有任何特定的规律.使用互斥锁mutex完成互斥访问 1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <pthread.h> 4 5 #define THREAD_NUMBER 3 //线程数 6

基于(Redis | Memcache)实现分布式互斥锁

设计一个缓存系统,不得不要考虑的问题就是:缓存穿透.缓存击穿与失效时的雪崩效应. 缓存击穿 缓存穿透是指查询一个一定不存在的数据,由于缓存是不命中时被动写的,并且出于容错考虑,如果从存储层查不到数据则不写入缓存,这将导致这个不存在的数据每次请求都要到存储层去查询,失去了缓存的意义.在流量大时,可能DB就挂掉了,要是有人利用不存在的key频繁攻击我们的应用,这就是漏洞. 解决方案 有很多种方法可以有效地解决缓存穿透问题,最常见的则是采用布隆过滤器,将所有可能存在的数据哈希到一个足够大的bitmap

线程的互斥锁

一.竞争与同步 当多个线程同时访问其所共享的进程资源时,需要相互协调,以防止出现数据不一致.不完整的问题.这就叫线程同步. 二.互斥量 int pthread_mutex_init (pthread_mutex_t* mutex,const pthread_mutexattr_t* mutexattr); 功能:初始化互斥量 //亦可 pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;? int pthread_mutex_lock (pthre