Mutex 进程间互斥

最新推荐文章于 2024-08-23 03:12:47 发布
最新推荐文章于 2024-08-23 03:12:47 发布
阅读量259 收藏
点赞数
文章标签： c# runtime
原文链接：http://www.cnblogs.com/xiaochun126/p/5133322.html
版权

学习Mutex的心得，不一定对，先记录一下。

同步技术分为两大类，锁定和信号同步。

锁定分为：Lock、Monitor

信号同步分为：AutoResetEvent、ManualResetEvent、Semaphore以及Mutex。他们都继承自WaitHandle，

                   AutoResetEvent、ManualResetEvent在内存中维护一个布尔型变量，如果为false则阻塞，如果为true则解除阻塞

                   Semaphore在内存中维护一个整型变量，如果为0则阻塞，如果大于0则解除阻塞，每解除一个阻塞其值减一

AutoResetEvent、ManualResetEvent、Semaph提供单进程内的线程同步

Mutex提供跨应用程序域的线程阻塞和解除的能力，主要用于互斥访问。

 

下面是一个使用Mutex进行互斥访问的演示例子。   

软件打开时，如果接收到输入则创建一个互斥锁，并持有锁，直到再次接收到输入，然后释放锁，如果再次输入又创建锁，  如此循环。          

假设app1创建一个互斥锁，然后持有锁，并对共享资源进行操作，那么app2就不能再次创建互斥锁，据此就能判断共享资源释放被别的进程占用。

如果app1使用完了共享资源，释放了互斥锁，则app2就可以创建互斥锁，据此可以判断共享资源可以被访问了。

以下是app1代码

1、Mutex用于进程间的同步

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

namespace MutexApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            new App1Class().write();
        }
    }

    class App1Class
    {

        public void write()
        {
            while (true)
            {
                Console.WriteLine("please input a word to create mutex");
                Console.WriteLine("");
                Console.ReadLine();
                //创建一个互斥锁，如果创建成功，则isCreate返回true
                if (create())
                {
                    Console.WriteLine("Application1 get the mutex 'test'");
                    Console.WriteLine("");

                    Console.WriteLine("please input a word to dispose mutex");
                    Console.WriteLine("");

                    //随便输入一个word，释放互斥锁
                    Console.ReadLine();
                    dispose();
                    Console.WriteLine("Application1 dispose mutex 'test'");
                    Console.WriteLine("");

                }
            }
        }

        System.Threading.Mutex mutext = null;
        private bool create()
        {
            bool isCreate = false;
            //如果进程中没有名字为test的mutex，则创建成功isCreate为true，第一个参数如果为true，则指定创建mutex的线程拥有此mutex。
            mutext = new System.Threading.Mutex(true, "test", out isCreate);
            if (!isCreate)
            {
                mutext.Dispose();
                mutext = null;
                GC.Collect();
                GC.WaitForPendingFinalizers();
            }
            return isCreate;
        }

        private void dispose()
        {
            mutext.ReleaseMutex();
            mutext.Dispose();
            mutext = null;
            GC.Collect();
            GC.WaitForPendingFinalizers();
        }

    }
}

2、app2 代码

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

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            new App2Class().write();
        }
    }

    class App2Class
    {

        public void write()
        {
            while (true)
            {
                Console.WriteLine("please input a word to create mutex");
                Console.WriteLine("");
                Console.ReadLine();
                //创建一个互斥锁，如果创建成功，则isCreate返回true
                if (create())
                {
                    Console.WriteLine("Application2 get the mutex 'test'");
                    Console.WriteLine("");

                    Console.WriteLine("please input a word to dispose mutex");
                    Console.WriteLine("");

                    //随便输入一个word，释放互斥锁
                    Console.ReadLine();
                    dispose();
                    Console.WriteLine("Application2 dispose mutex 'test'");
                    Console.WriteLine("");

                }
            }
        }

        System.Threading.Mutex mutext = null;
        private bool create()
        {
            bool isCreate = false;
            mutext = new System.Threading.Mutex(true, "test", out isCreate);
            if (!isCreate)
            {
                mutext.Dispose();
                mutext = null;
                GC.Collect();
                GC.WaitForPendingFinalizers();
            }
            return isCreate;
        }

        private void dispose()
        {
            mutext.ReleaseMutex();
            mutext.Dispose();
            mutext = null;
            GC.Collect();
            GC.WaitForPendingFinalizers();
        }

    }
}

　　

结果图：

 3、但是在实际应用中多用于单例模式，用于判断应用程序是否被创建。

            //单例模式
            bool bCreatedNew;
            System.Threading.Mutex mutex = new System.Threading.Mutex(false, Application.ProductName, out bCreatedNew);
            if (!bCreatedNew)
            {
               //如果已经创建，则获取应用程序的句柄，并显示出来，或者提示已经运行
                IntPtr hwnd = SingleProcess.FindWindow(null,Global.fromTitle);                            
                SingleProcess.ShowWin(hwnd);
                //SingleProcess.Singling("消息中心服务器");
                //MessageBox.Show("打开失败，已有消息中心服务正在运行！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }

　

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Windows.Forms;

namespace WcfAlarmCenter
{
    public class SingleProcess
    {
        //根据主窗体句柄显示窗体
        public static void ShowWin(IntPtr hwnd)
        {
            ShowWindow(hwnd, SW_RESTORE);
            SwitchToThisWindow(hwnd, true);

            Rect windowRec;
            GetWindowRect(hwnd, out windowRec);
            System.Drawing.Rectangle rect = System.Windows.Forms.SystemInformation.VirtualScreen;
            SetWindowPos(hwnd, HWND_TOP, (rect.Width - (windowRec.Right - windowRec.Left)) / 2,
                (rect.Height - (windowRec.Bottom - windowRec.Top)) / 2, 0, 0, SWP_NOSIZE);
        }

        private static string _formText;// = string.Empty;
        private static Process _process = null;
        /// <summary>
        /// 
        /// </summary>
        /// <param name="str"></param>
        public static void Singling(string formtext)
        {
            _formText = formtext;
            Process instance = GetInstance();
            if (instance != null)   //首先确定有无进程
            {
                _process = instance;
                if (_process.MainWindowHandle.ToInt32() != 0) //是否托盘化
                {
                    //HandleRunningInstance(pro);
                    ShowWin(_process.MainWindowHandle);
                }
                else
                {
                    CallBack myCallBack = new CallBack(Report);
                    EnumWindows(myCallBack, 0);
                }
                //System.Environment.Exit(System.Environment.ExitCode);
            }

        }

        public static Process GetInstance()
        {
            Process current = Process.GetCurrentProcess();
            Process[] processes = Process.GetProcessesByName(Application.ProductName);//current.ProcessName);
            //遍历正在有相同名字运行的例程    
            foreach (Process process in processes)
            {
                //忽略现有的例程      
                if (process.Id != current.Id)
                {
                    //if (process.MainModule.FileName == current.MainModule.FileName)
                    {
                        //返回另一个例程实例          
                        return process;
                    }
                }
            }
            //没有其它的例程，返回Null    
            return null;
        }

        private static bool Report(IntPtr hwnd, int lParam)
        {
            //获得窗体标题
            StringBuilder sb = new StringBuilder(100);
            GetWindowText(hwnd, sb, sb.Capacity);

            int calcID;
            //获取进程ID   
            GetWindowThreadProcessId(hwnd, out calcID);
            if ((sb.ToString() == _formText) && (_process != null) && (calcID == _process.Id)) //标题栏、进程id符合
            //if (pro != null && calcID == pro.Id) //进程id符合
            {
                ShowWin(hwnd);
                return true;
            }
            return true;


        }


        #region  win32 API
        /// <summary>
        /// 获取窗体句柄
        /// </summary>，两个参数至少要知道一个
        /// <param name="lpClassName">窗体类名，可以通过Spy++获取，为null表示忽略</param>
        /// <param name="lpWindowName">窗体标题，Text属性，为null时表示忽略</param>
        /// <returns></returns>
        [DllImport("user32.dll", EntryPoint = "FindWindow")]
        public extern static IntPtr FindWindow(string lpClassName, string lpWindowName);

        /// <summary>
        /// 根据窗体句柄获得窗体标题
        /// </summary>
        /// <param name="hWnd"></param>
        /// <param name="lpText"></param>
        /// <param name="nCount"></param>
        /// <returns></returns>
        [DllImport("user32.dll", CharSet = CharSet.Auto)]
        private static extern int GetWindowText(IntPtr hWnd, StringBuilder lpText, int nCount);

        /// <summary>
        /// 枚举窗体
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        [DllImport("user32")]
        private static extern int EnumWindows(CallBack x, int y);
        private delegate bool CallBack(IntPtr hwnd, int lParam);

        /// <summary>
        /// 根据窗体句柄获得其进程ID
        /// </summary>
        /// <param name="hwnd"></param>
        /// <param name="ID"></param>
        /// <returns></returns>
        [DllImport("User32.dll", CharSet = CharSet.Auto)]
        private static extern int GetWindowThreadProcessId(IntPtr hwnd, out int ID);

        /// <summary>
        /// 修改位置、大小
        /// </summary>
        /// <param name="hWnd"></param>
        /// <param name="hWndInsertAfter"></param>
        /// <param name="X"></param>
        /// <param name="Y"></param>
        /// <param name="cx"></param>
        /// <param name="cy"></param>
        /// <param name="uFlags"></param>
        /// <returns></returns>
        [DllImport("user32.dll")]
        private static extern bool SetWindowPos(IntPtr hWnd, int hWndInsertAfter, int X, int Y, int cx, int cy, uint uFlags);
        /// <summary>
        ///     Retains the current size (ignores the cx and cy parameters).
        /// </summary>
        static uint SWP_NOSIZE = 0x0001;
        static int HWND_TOP = 0;
        public struct Rect
        {
            public int Left;
            public int Top;
            public int Right;
            public int Bottom;
        }

        [DllImport("user32.dll")]
        private static extern int GetWindowRect(IntPtr hwnd, out  Rect lpRect);

        /// <summary>
        /// 显示窗体,同  ShowWindowAsync 差不多
        /// </summary>
        /// <param name="hwnd"></param>
        /// <param name="nCmdShow"></param>
        /// <returns></returns>
        [DllImport("user32.dll", EntryPoint = "ShowWindow", CharSet = CharSet.Auto)]
        private static extern int ShowWindow(IntPtr hwnd, int nCmdShow);
        private const int SW_RESTORE = 9;


        /// <summary> 
        /// 该函数设置由不同线程产生的窗口的显示状态。 (没用)
        /// </summary> 
        /// <param name="hWnd">窗口句柄</param> 
        /// <param name="cmdShow">指定窗口如何显示。查看允许值列表，请查阅ShowWlndow函数的说明部分。</param> 
        /// <returns>如果函数原来可见，返回值为非零；如果函数原来被隐藏，返回值为零。</returns> 
        [DllImport("User32.dll")]
        private static extern bool ShowWindowAsync(IntPtr hWnd, int cmdShow);

        /// <summary> 
        /// 该函数将创建指定窗口的线程设置到前台，并且激活该窗口。
        /// 键盘输入转向该窗口，并为用户改各种可视的记号。系统给创建前台窗口的线程分配的权限稍高于其他线程。 
        /// (没用)
        /// </summary> 
        /// <param name="hWnd">将被激活并被调入前台的窗口句柄。</param> 
        /// <returns>如果窗口设入了前台，返回值为非零；如果窗口未被设入前台，返回值为零。</returns> 
        [DllImport("User32.dll")]
        private static extern bool SetForegroundWindow(IntPtr hWnd);
        private const int WS_SHOWNORMAL = 1;

        /// <summary>
        /// 窗体焦点
        /// </summary>
        /// <param name="hWnd"></param>
        /// <param name="fAltTab"></param>
        [DllImport("user32.dll ", SetLastError = true)]
        private static extern void SwitchToThisWindow(IntPtr hWnd, bool fAltTab);

        #endregion



    }
}

　　

。

参考

http://www.cnblogs.com/city22/archive/2007/02/02/638260.html

信号量与互斥锁

C# 多线程之一：信号量Semaphore

C#多线程之二：ManualResetEvent和AutoResetEvent

 

。

转载于:https://www.cnblogs.com/xiaochun126/p/5133322.html

weixin_30617561
关注
linux-Mutex实现进程间的互斥.
Gdl.痕迹 的博客
09-22 1933
在linux的ipc进程通信中，semaphore是可以实现进程间共享互斥的，然而对于mutex，rwlock，spinlock默认的都是进程内的线程间的同步互斥(虽然也是process假装的)，本篇通过修改mutex默认属性来实现进程间的mutex。 参考man mutex*，从man pthread_mutexattr_setpshared得知mutex的共享属性选项有两个： PTHREAD_...
Qt进程之间互斥
相忘于江湖的专栏
08-06 188
我们开发软件的时候，有时候需要多个进程访问同一个资源，这个时候需要进程之间实现函数互斥，实现对同一资源的序列化访问。
进程间互斥 Mutex
记事本
11-12 1783
对于普通的线程间互斥可以使用CreateMutex传建一个匿名的互斥量做互斥，对进程间的互斥就要用到命名互斥量来做互斥了。用到的函数有： 1. 创建一个命名互斥量使用CreateMutex（）方法，只需把lpName参数设置为非NULL，如"my mutex" HANDLE WINAPI CreateMutex( __in LPSECURITY_ATTRIBUTES
进程通信(7)：互斥锁(mutex)和条件变量
最新发布
weixin_40748540的博客
08-23 61
互斥锁(mutex)用于互斥访问临界区，只允许一个线程访问共享变量。 条件变量可以让获取互斥锁 的线程在某个条件变量上等待，直到有其他线程把他唤醒。互斥锁和条件变量通常一起使用实现同步。互斥锁的操作lock(mutex)； // 获取锁，如果获取不到锁，线程进入阻塞状态，释放CPUunlock(mutex) ；//释放锁t...
进程间的mutex
Stephen___Qin的博客
12-02 3359
设两个进程共用一个临界资源的互斥信号量mutex=1，当mutex＝－1时表示()。 一个进程进入了临界区，另一个进程等待 没有一个进程进入临界区 两个进程都进入临界区 两个进程都在等待 互斥信号量不采用自旋锁的方式实现，mutex初始值为1，当一个准备进入临界区时，mutex - 1 = 0，该进程进入临界区； 另一个进程准备进入临界区时，mutex - 1 = -1，mu...
进程间同步之mutex锁
u012385733的专栏
04-23 3226
进制间同步机制之mutex 1. Mutex锁可以用于进程间互斥？  当然可以。 a) 使用pthread_mutex_t 来实现进程间的互斥。 b) 当必须支持PTHREAD_PROCESS_SHARED属性 c)其中设置共享对象的属性为PTHREAD_PROCESS_SHARED是为了告诉系统该共享对象是跨越进程的，不仅仅对创建它的进程可见；但是仅有这一个条件显然无法满足不同进程使用该...
linux无亲缘关系进程间通信(互斥锁+条件变量+共享内存)
07-07
本示例中提到的“linux无亲缘关系进程间通信”着重讲解了如何利用互斥锁（Mutex）、条件变量（Condition Variable）以及共享内存（Shared Memory）这三种机制来实现非父子进程间的同步通信。 1. **互斥锁**：互斥锁...
进程间同步互斥问题——银行柜员服务问题1
08-03
【操作系统中的进程间同步互斥】 在操作系统中，进程间的同步和互斥是多线程编程中的核心概念。在银行柜员服务问题中，这些概念得到了实际的应用。该问题模拟了一个银行环境，其中n个柜员为顾客提供服务。为了解决这...
进程间 互斥锁用法 linux系统编程
qq_24447809的博客
10-19 574
创建映射区，两个进程共享锁和操作变量。 关键是改变锁的属性由线程共享改为进程共享 pthread_mutexattr_t mutexattr; pthread_mutexattr_setpshared(&mm->mutexattr,PTHREAD_PROCESS_SHARED); //设置锁属性为进程间共享 //PTHREAD_PROCESS_SHARED 进程间 //PTHREAD_PROCESS_PRIVATE 线程间（默认） #include<stdio.h> #incl
Mutex 互斥锁
huangweiqing80的博客
10-15 3090
1、理解互斥锁？ 互斥锁的使用也是保持内核临界区的同步的，互斥锁可以说源于信号量，信号量设置计数器可以容许n个进程并发的访问临界区，而互斥锁不行，只能容许每次一个进程访问，也就是计数器值为1的信号量，可以这么理解。互斥锁和自旋锁有不同（显然的），互斥锁在中断处理程序中和可延迟函数中都不能使用，因为它是可以睡眠的，只能在进程上下文或者软中断上下文才能使用。 struct mutex { /* 1: ...
使用互斥对象（Mutex）实现不同进程间线程同步
04-25
使用互斥对象（Mutex）实现不同进程间线程同步
*.exe 进程唯一Mutext
05-20
使用Mutex检测应用程序在进程中是否存在 使用Process检测应用程序在进程中是否存在 如何应用程序存在，可以进行激活，让其显示在最前端 C# Vs2008 Console 控制台应用程序
线程、进程通信－－－mutex=>互斥锁
DeepXL
05-17 761
互斥锁用来保证一段时间内只有一个线程在执行一段代码。必要性显而易见:假设各个线程向同一个文件顺序写入数据, 最后得到的结果一定是灾难性的。我们先看下面一段代码。这是一个读/写程序,它们公 用一个缓冲区,并且我们假定一个缓冲区只能保存一条信息。即缓冲区只有两个状态:有信息或没有信息。 (pthread_delay_np 这个函数只在 POSIX Threads for Window里面有,
使用Mutex实现Windows下进程间互斥访问同一资源
On my way
10-16 6283
0.前言       做一个demo开发过程中，出现两个进程访问同一文件的情况：进程A不停地写该文件实现刷新，进程B不停地读取该文件做后续处理。涉及到同一内存的访问问题，免不了做互斥处理。根据网上搜索的答案，使用Mutex有名互斥量就可以解决该问题。 1.互斥量       有关互斥量的使用这里不再介绍，网上有很多详细介绍文章。进程中使用互斥量与在线程中使用其原理和操作流程相同，唯一区别在于
使用互斥锁mutex进行进程间同步的说明和示例
jinking01的专栏
11-24 1590
进程间同步可以使用互斥量mutex（互斥锁）、信号量和文件锁。这里面的重要函数是pthread_mutex_init()，它负责进行互斥锁的初始化，只有初始化之后才能使用它进行加锁、解锁。这里需要说明的是，mutex不仅可以用于进程间的同步，还可以用于线程间的同步，默认情况下是线程间同步。如果要用于进程间同步，则需要在pthread_mutex_init初始化之前，修改其属性为进程间共享。pthread_mutexattr_t mattr 类型就是用于定义mutex锁的属性的。
linux mutex 进程同步,使用 Mutex 实现进程间同步
weixin_35671110的博客
05-01 324
我们知道 Mutex 互斥量是可以用在线程间同步的，线程之间共享进程的数据，mutex 就可以直接引用。而进程有自己独立的内存空间，要怎样将它应用在进程间同步呢？为了达到这一目的，可以在 pthread_mutex_init 初始化之前，修改其属性为进程间共享，并将其映射到共享内存中即可。使用到的API：pthread_mutexattr_t mattr 类型：用于定义互斥量的属性pthread_...
深入探讨进程间同步与互斥的机制
进程间同步与互斥是操作系统管理多个进程时必须解决的关键问题，它涉及到进程之间的协调和通信。同步确保多个进程能按照预定的顺序协作执行任务，而互斥则保证共享资源在同一时间只能被一个进程访问，避免了资源竞争...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值