Mutex小应用

System.Threading.Mutex :同步基元,它只向一个线程授予对共享资源的独占访问权

实现原理: 在程序启动时,请求一个互斥体,如果能获取对指定互斥的访问权,就继续运行程序,否则就退出程序

PS:如果一个线程获取了互斥体,则要获取该互斥体的第二个线程将被挂起,直到第一个线程释放该互斥体。

eg:

  1.  static class Program
  2.     {
  3.         /// <summary>
  4.         /// 应用程序的主入口点。
  5.         /// </summary>
  6.         [STAThread]
  7.         static void Main()
  8.         {
  9.             //Application.EnableVisualStyles();
  10.             //Application.SetCompatibleTextRenderingDefault(false);
  11.             //Application.Run(new Form1());
  12.             bool bCreatedNew=false;
  13.             //第一个参数:true--给调用线程赋予互斥体的初始所属权
  14.             //第一个参数:互斥体的名称
  15.             //第三个参数:返回值,如果调用线程已被授予互斥体的初始所属权,则返回true
  16.             Mutex mutex=new Mutex(true,"MutexDemo",out bCreatedNew);
  17.             if(!bCreatedNew)
  18.             {
  19.                 MessageBox.Show("已经有一个实例在运行","提示");
  20.               //  mutex.ReleaseMutex();//释放
  21.                 return;
  22.             }
  23.             try
  24.             {
  25.                 Application.Run(new Form1());
  26.             }
  27.             catch
  28.             {
  29.             
  30.             }
  31.         }      
  32.     }
  33. 此外,类型功能的还有lock,monitor(锁定)
    1. //lock一般用法 
    2.  lock (this)
    3.             {
    4.                 Console.WriteLine("lock()");
    5.                 Thread.Sleep(50);
    6.             }
    7. //monitor一般用法
    8.   Monitor.Enter(this);
    9.   Console.WriteLine("monitor");
    10.   Thread.Sleep(50);
    11.   Monitor.Exit(this);
std::mutex是C++标准库中提供的一种互斥量(mutex)类型,用于实现线程间的互斥访问。它可以用来保护共享资源,确保在同一时间只有一个线程可以访问该资源,从而避免数据竞争和并发访问的问题。 std::mutex的使用步骤如下: 1. 创建一个std::mutex对象,可以通过默认构造函数创建。 2. 在需要保护的代码块前调用std::mutex的lock()成员函数,以获取互斥锁。如果当前锁已经被其他线程占用,则当前线程会被阻塞,直到锁可用。 3. 执行需要保护的代码。 4. 在代码块执行完毕后,调用std::mutex的unlock()成员函数,释放互斥锁,使其他线程可以获取锁并执行相应的代码。 下面是一个使用std::mutex的简单示例: ```cpp #include <iostream> #include <thread> #include <mutex> std::mutex mtx; // 创建一个互斥量对象 void printMessage(const std::string& message) { std::lock_guard<std::mutex> lock(mtx); // 获取互斥锁 std::cout << message << std::endl; // 打印消息 // 互斥锁会在lock_guard对象析构时自动释放 } int main() { std::thread t1(printMessage, "Hello from thread 1"); std::thread t2(printMessage, "Hello from thread 2"); t1.join(); t2.join(); return 0; } ``` 在上面的示例中,我们创建了一个互斥量对象`mtx`,并在`printMessage`函数中使用`std::lock_guard`来获取互斥锁。这样可以确保每次只有一个线程可以打印消息,避免了输出混乱的问题。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值