C#多线程中的互斥锁Mutex

一、简介

Mutex的突出特点是可以跨应用程序域边界对资源进行独占访问，即可以用于同步不同进程中的线程，这种功能当然这是以牺牲更多的系统资源为代价的。

主要常用的两个方法:

  • public virtual bool WaitOne() 阻止当前线程，直到当前 System.Threading.WaitHandle 收到信号获取互斥锁。
  • public void ReleaseMutex() 释放 System.Threading.Mutex 一次。

二、代码

案例一：

    class Program
    {
        private static Mutex mutex = new Mutex();
        static void Main(string[] args)
        {
            Thread[] thread = new Thread[3];
            for (int i = 0; i < 3; i++)
            {
                thread[i] = new Thread(ThreadMethod1);//方法引用
                thread[i].Name = "Thread-" + (i+1).ToString();
            }
            for (int i = 0; i < 3; i++)
            {
                thread[i].Start();
            }
            Console.ReadKey();
        }
        public static void ThreadMethod1(object val)
        {
            mutex.WaitOne();　　　　//获取锁
            for (int i = 1; i <=5; i++)
            {
                Console.WriteLine("{0}循環了{1}次", Thread.CurrentThread.Name, i);
            }
            mutex.ReleaseMutex();  //释放锁
        }
    }

运行结果：

案例二：

    class Program
    {
        private static Mutex mutex = new Mutex();
        private static int sum = 0;
        static void Main(string[] args)
        {
            Task<int> task = new Task<int>(ThreadFunction);
            task.Start();
            Console.WriteLine($"{DateTime.Now} task started!");
            Thread.Sleep(2000);//Main主線程

            Console.WriteLine($"{DateTime.Now} Get siginal in Main!");
            mutex.WaitOne();
            Console.WriteLine($"{DateTime.Now} Get siginal in main!");

            Console.WriteLine($"{DateTime.Now} Result is {task.Result}");
            Console.ReadKey();
        }
        private static int ThreadFunction()
        {
            Console.WriteLine($"{DateTime.Now} Get siginal in ThreadFunction!");
            mutex.WaitOne();　　//获取锁
            for (int i = 0; i <= 10; i++)
            {
                sum += i;
                Thread.Sleep(1000);
            }
            Console.WriteLine($"{DateTime.Now} Release mutex in ThreadFunction!");
            mutex.ReleaseMutex();　 //释放锁

            return sum;
        }
    }

运行结果：

三、总结

为避免发送多线程发生死锁，Mutex的WaitOne()和ReleaseMutex()需成对配合使用。

到此这篇关于C#互斥锁Mutex的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持我们。

赞 (0)

相关推荐

  • C#多线程中如何运用互斥锁Mutex

    互斥锁(Mutex) 互斥锁是一个互斥的同步对象,意味着同一时间有且仅有一个线程可以获取它. 互斥锁可适用于一个共享资源每次只能被一个线程访问的情况 函数: //创建一个处于未获取状态的互斥锁 Public Mutex(): //如果owned为true,互斥锁的初始状态就是被主线程所获取,否则处于未获取状态 Public Mutex(bool owned): 如果要获取一个互斥锁.应调用互斥锁上的WaitOne()方法,该方法继承于Thread.WaitHandle类 它处于等到状态直至所调用

  • C#多线程系列之进程同步Mutex类

    C#多线程系列之进程同步Mutex类

    Mutex 中文为互斥,Mutex 类叫做互斥锁.它还可用于进程间同步的同步基元. Mutex 跟 lock 相似,但是 Mutex 支持多个进程.Mutex 大约比 lock 慢 20 倍. 互斥锁(Mutex),用于多线程中防止两条线程同时对一个公共资源进行读写的机制. Windows 操作系统中,Mutex 同步对象有两个状态: signaled:未被任何对象拥有: nonsignaled:被一个线程拥有: Mutex 只能在获得锁的线程中,释放锁. 构造函数和方法 Mutex 类其构造函

  • C#中的lock、Monitor、Mutex学习笔记

    C#中的lock、Monitor、Mutex学习笔记

    线程:线程是进程的独立执行单元,每一个进程都有一个主线程,除了主线程可以包含其他的线程. 多线程的意义:多线程有助于改善程序的总体响应性,提高CPU的效率. 多线程的应用程序域是相当不稳定的,因为多个线程在同一时间内都能运行共享的功能模块.为了保护应用程序的资源不被破坏,为多线程程序提供了三种加锁的机制,分别是:Monitor类.Lock关键字和Mutex类. 1. lock lock实现的功能是:使后进入的线程不会中断当前的线程,而是等待当前线程结束后再继续执行. 应用: 复制代码 代码如下:

  • c#互斥锁Mutex类用法介绍

    什么是Mutex “mutex”是术语“互相排斥(mutually exclusive)”的简写形式,也就是互斥量.互斥量跟临界区中提到的Monitor很相似,只有拥有互斥对象的线程才具有访问资源的权限,由于互斥对象只有一个,因此就决定了任何情况下此共享资源都不会同时被多个线程所访问.当前占据资源的线程在任务处理完后应将拥有的互斥对象交出,以便其他线程在获得后得以访问资源.互斥量比临界区复杂,因为使用互斥不仅仅能够在同一应用程序不同线程中实现资源的安全共享,而且可以在不同应用程序的线程之间实现对

  • C#使用Mutex简单实现程序单实例运行的方法

    本文实例讲述了C#使用Mutex简单实现程序单实例运行的方法.分享给大家供大家参考.具体如下: [STAThread] static void Main() { bool isAppRunning = false; System.Threading.Mutex mutex = new System.Threading.Mutex(true,System.Diagnostics.Process.GetCurrentProcess().ProcessName,out isAppRunning); i

  • c# mutex互斥量的深入解析

    互斥锁(Mutex) 互斥锁是一个互斥的同步对象,意味着同一时间有且仅有一个线程可以获取它. 互斥锁可适用于一个共享资源每次只能被一个线程访问的情况  函数: //创建一个处于未获取状态的互斥锁 Public Mutex(); //如果owned为true,互斥锁的初始状态就是被主线程所获取,否则处于未获取状态 Public Mutex(bool owned); 如果要获取一个互斥锁.应调用互斥锁上的WaitOne()方法,该方法继承于Thread.WaitHandle类 它处于等到状态直至所调

  • C#中Mutex对象用法分析

    本文实例讲述了C#中Mutex对象用法.分享给大家供大家参考,具体如下: C#语言有很多值得学习的地方,这里我们就来介绍C# Mutex对象,包括介绍控制好多个线程相互之间的联系等方面. 如何控制好多个线程相互之间的联系,不产生冲突和重复,这需要用到互斥对象,即:System.Threading 命名空间中的 Mutex 类. 我们可以把Mutex看作一个出租车,乘客看作线程.乘客首先等车,然后上车,最后下车.当一个乘客在车上时,其他乘客就只有等他下车以后才可以上车.而线程与C# Mutex对象

  • C#多线程中的互斥锁Mutex

    C#多线程中的互斥锁Mutex

    一.简介 Mutex的突出特点是可以跨应用程序域边界对资源进行独占访问,即可以用于同步不同进程中的线程,这种功能当然这是以牺牲更多的系统资源为代价的. 主要常用的两个方法: public virtual bool WaitOne() 阻止当前线程,直到当前 System.Threading.WaitHandle 收到信号获取互斥锁. public void ReleaseMutex() 释放 System.Threading.Mutex 一次. 二.代码 案例一: class Program {

  • GoLang中的互斥锁Mutex和读写锁RWMutex使用教程

    目录 一.竞态条件与临界区和同步工具 (1)竞态条件 (2)临界区 (3)同步工具 二.互斥量 三.使用互斥锁的注意事项 (1)使用互斥锁的注意事项 (2)使用defer语句解锁 (3)sync.Mutex是值类型 四.读写锁与互斥锁的异同 (1)读/写互斥锁 (2)读写锁规则 (3)解锁读写锁 一.竞态条件与临界区和同步工具 (1)竞态条件 一旦数据被多个线程共享,那么就会产生冲突和争用的情况,这种情况被称为竞态条件.这往往会破坏数据的一致性. 同步的用途有两个,一个是避免多线程在同一时刻操作

  • 详解java中的互斥锁信号量和多线程等待机制

    互斥锁和信号量都是操作系统中为并发编程设计基本概念,互斥锁和信号量的概念上的不同在于,对于同一个资源,互斥锁只有0和1 的概念,而信号量不止于此.也就是说,信号量可以使资源同时被多个线程访问,而互斥锁同时只能被一个线程访问 互斥锁在java中的实现就是 ReetranLock , 在访问一个同步资源时,它的对象需要通过方法 tryLock() 获得这个锁,如果失败,返回 false,成功返回true.根据返回的信息来判断是否要访问这个被同步的资源.看下面的例子 public class Reen

  • Python实现的多线程同步与互斥锁功能示例

    Python实现的多线程同步与互斥锁功能示例

    本文实例讲述了Python实现的多线程同步与互斥锁功能.分享给大家供大家参考,具体如下: #! /usr/bin/env python #coding=utf-8 import threading import time ''' #1.不加锁 num = 0 class MyThread(threading.Thread): def run(self): global num time.sleep(1) #一定要sleep!!! num = num + 1 msg = self.name + '

  • Python多线程操作之互斥锁、递归锁、信号量、事件实例详解

    本文实例讲述了Python多线程操作之互斥锁.递归锁.信号量.事件.分享给大家供大家参考,具体如下: 互斥锁: 为什么要有互斥锁:由于多线程是并行的,如果某一线程取出了某一个数据将要进行操作,但它还没有那么快执行完操作,这时候如果另外一个线程也要操作这个数据,那么这个数据可能会因为两次操作而发生错误 import time,threading x=6 def run1(): print("run1我拿到了数据:",x) print("我现在还不想操作,先睡一下")

  • Go语言并发编程之互斥锁Mutex和读写锁RWMutex

    目录 一.互斥锁Mutex 1.Mutex介绍 2.Mutex使用实例 二.读写锁RWMutex 1.RWMutex介绍 2.RWMutex使用实例 在并发编程中,多个Goroutine访问同一块内存资源时可能会出现竞态条件,我们需要在临界区中使用适当的同步操作来以避免竞态条件.Go 语言中提供了很多同步工具,本文将介绍互斥锁Mutex和读写锁RWMutex的使用方法. 一.互斥锁Mutex 1.Mutex介绍 Go 语言的同步工具主要由 sync 包提供,互斥锁 (Mutex) 与读写锁 (R

  • Java多线程并发编程(互斥锁Reentrant Lock)

    Java 中的锁通常分为两种: 通过关键字 synchronized 获取的锁,我们称为同步锁,上一篇有介绍到:Java 多线程并发编程 Synchronized 关键字. java.util.concurrent(JUC)包里的锁,如通过继承接口 Lock 而实现的 ReentrantLock(互斥锁),继承 ReadWriteLock 实现的 ReentrantReadWriteLock(读写锁). 本篇主要介绍 ReentrantLock(互斥锁). ReentrantLock(互斥锁)

  • GO语言协程互斥锁Mutex和读写锁RWMutex用法实例详解

    sync.Mutex Go中使用sync.Mutex类型实现mutex(排他锁.互斥锁).在源代码的sync/mutex.go文件中,有如下定义: // A Mutex is a mutual exclusion lock. // The zero value for a Mutex is an unlocked mutex. // // A Mutex must not be copied after first use. type Mutex struct { state int32 sem

随机推荐