详细解析C#多线程同步事件及等待句柄

最近捣鼓了一下多线程的同步问题,发现其实C#关于多线程同步事件处理还是很灵活,这里主要写一下,自己测试的一些代码,涉及到了AutoResetEvent 和 ManualResetEvent,当然还有也简要提了一下System.Threading.WaitHandle.WaitOne 、System.Threading.WaitHandle.WaitAny和System.Threading.WaitHandle.WaitAll ,下面我们一最初学者的角度来看,多线程之间的同步。

假设有这样的一个场景,主线程开了一个子线程,让子线程等着,等主线程完成了某件事情时再通知子线程去往下执行,这里关键就在于这个怎让子线程等着,主线程怎通知子线程,一般情况下我们不难想到用一个公共变量,于是咱们就有了下面的代码:

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

namespace AutoResetEventTest
{
  class Class1
  {
    static bool flag = true; 

    static void DoWork()
    {
      Console.WriteLine("  worker thread started, now waiting on event...");
      while (flag)
      { 

      }
      Console.WriteLine("  worker thread reactivated, now exiting...");
    } 

    static void Main()
    {
      Console.WriteLine("main thread starting worker thread...");
      Thread t = new Thread(DoWork);
      t.Start(); 

      Console.WriteLine("main thrad sleeping for 1 second...");
      Thread.Sleep(1000); 

      Console.WriteLine("main thread signaling worker thread...");
      flag = false;
    }
  }
}

虽然目的达到了,但是看着这代码就纠结,下面该是我们的主角上场了,AutoResetEvent 和 ManualResetEvent,关于这两者我们暂且认为是差不多了,稍后我会介绍他们的不同,这里以AutoResetEvent为例,其实很多官方的说法太过于抽象,这里通俗地讲,可以认为AutoResetEvent就是一个公共的变量(尽管它是一个事件),创建的时候可以设置为false,然后在要等待的线程使用它的WaitOne方法,那么线程就一直会处于等待状态,只有这个AutoResetEvent被别的线程使用了Set方法,也就是要发通知的线程使用了它的Set方法,那么等待的线程就会往下执行了,Set就是发信号,WaitOne是等待信号,只有发了信号,等待的才会执行。如果不发的话,WaitOne后面的程序就永远不会执行。好下面看用AutoResetEvent改造上面的程序:

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

namespace AutoResetEventTest
{
  class Class2
  {
    static AutoResetEvent mEvent=new AutoResetEvent(false);
    //static ManualResetEvent mEvent = new ManualResetEvent(false); 

    static void DoWork()
    {
      Console.WriteLine("  worker thread started, now waiting on event...");
      mEvent.WaitOne();
      Console.WriteLine("  worker thread reactivated, now exiting...");
    } 

    static void Main()
    {
      Console.WriteLine("main thread starting worker thread...");
      Thread t = new Thread(DoWork);
      t.Start(); 

      Console.WriteLine("main thrad sleeping for 1 second...");
      Thread.Sleep(1000); 

      Console.WriteLine("main thread signaling worker thread...");
      mEvent.Set();
    }
  }
}

这时代码是不是清爽多了,这里其实你还会看到,把上面的AutoResetEvent换成ManualResetEvent也是没有问题的,那么它两之间的区别是什么呢?个人认为它们最大的区别在于,无论何时,只要 AutoResetEvent 激活线程,它的状态将自动从终止变为非终止。相反,ManualResetEvent 允许它的终止状态激活任意多个线程,只有当它的 Reset 方法被调用时才还原到非终止状态。开下面的代码:

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

namespace AutoResetEventTest
{
  class Class3
  {
    static AutoResetEvent mEvent = new AutoResetEvent(false);
    //static ManualResetEvent mEvent = new ManualResetEvent(false); 

    static void DoWork()
    {
      Console.WriteLine("  worker thread started, now waiting on event...");
      for (int i = 0; i < 3; i++)
      {
        mEvent.WaitOne();
        //mEvent.Reset();
        Console.WriteLine("  worker thread reactivated, now exiting...");
      }
    } 

    static void Main()
    {
      Console.WriteLine("main thread starting worker thread...");
      Thread t = new Thread(DoWork);
      t.Start(); 

      for (int i = 0; i < 3; i++)
      {
        Thread.Sleep(1000);
        Console.WriteLine("main thread signaling worker thread...");
        mEvent.Set();
      }
    }
  }
}

如果你想仅仅把AutoResetEvent换成ManualResetEvent的话,你发现输出就会乱套了,为什么呢?

假如有autoevent.WaitOne()和manualevent.WaitOne(),当线程得到信号后都得以继续执行。差别就在调用后,autoevent.WaitOne()每次只允许一个线程进入,当某个线程得到信号(也就是有其他线程调用了autoevent.Set()方法后)后,autoevent会自动又将信号置为不发送状态,则其他调用WaitOne的线程只有继续等待,也就是说,autoevent一次只唤醒一个线程。而manualevent则可以唤醒多个线程,当某个线程调用了set方法后,其他调用waitone的线程获得信号得以继续执行,而manualevent不会自动将信号置为不发送,也就是说,除非手工调用了manualevent.Reset()方法,否则manualevent将一直保持有信号状态,manualevent也就可以同时唤醒多个线程继续执行。

在上面代码中,如果将AutoResetEvent换成ManualResetEvent的话,只要要在waitone后面做下reset,就会达到同样的效果。

之后咱们再来个简单的例子:

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

namespace AutoResetEventTest
{
  class Class4
  {
    public static AutoResetEvent mEvent = new AutoResetEvent(false); 

    public static void trmain()
    {
      Thread tr = Thread.CurrentThread;
      Console.WriteLine("thread: waiting for an event");
      mEvent.WaitOne();
      Console.WriteLine("thread: got an event");
      for (int x = 0; x < 10; x++)
      {
        Thread.Sleep(1000);
        Console.WriteLine(tr.Name + ": " + x);
      }
    }
    static void Main(string[] args)
    {
      Thread thrd1 = new Thread(new ThreadStart(trmain));
      thrd1.Name = "thread1";
      thrd1.Start();
      for (int x = 0; x < 10; x++)
      {
        Thread.Sleep(900);
        Console.WriteLine("Main:" + x);
        if (5 == x) mEvent.Set();
      }
      while (thrd1.IsAlive)
      {
        Thread.Sleep(1000);
        Console.WriteLine("Main: waiting for thread to stop");
      }
    }
  }
}

是不是更有感觉了?之后咱来看看另外几个东东:

System.Threading.WaitHandle.WaitOne 使线程一直等待,直到单个事件变为终止状态;

System.Threading.WaitHandle.WaitAny 阻止线程,直到一个或多个指示的事件变为终止状态;

System.Threading.WaitHandle.WaitAll 阻止线程,直到所有指示的事件都变为终止状态。

然后再来个例子,以WaitAll使用为例:

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

namespace AutoResetEventTest
{
  class other
  {
    static void Main(string[] args)
    {
      Random randomGenerator = new Random();
      AutoResetEvent[] resets=new AutoResetEvent[5]; 

      for (int i = 0; i < 5; i++)
      {
        resets[i] = new AutoResetEvent(false);
        int wTime = randomGenerator.Next(10)+1; 

        worker w = new worker(wTime, resets[i]); 

        Thread thrd1 = new Thread(new ThreadStart(w.work));
        thrd1.Start();
      }
      WaitHandle.WaitAll(resets);
      Console.WriteLine("ALL worker done - main exiting.");
    } 

  } 

  public class worker
  {
    public string name;
    public int wTime;
    public AutoResetEvent mEvent; 

    public worker(int w, AutoResetEvent m)
    {
      name = w.ToString();
      wTime = w * 1000;
      mEvent = m;
    } 

    public void work()
    {
      Console.WriteLine(name + " worker thread waiting for " + wTime + "....");
      Thread.Sleep(wTime);
      Console.WriteLine(name + " worker thread back...");
      mEvent.Set();
    }
  }
}

简单来说就是,开了5个线程,每个线程随机休眠若干秒,都完成后通知主线程退出,这里就开了一个AutoResetEvent数组,主线程就WaitHandle.WaitAll(resets) ,子线程休眠完后就Set1个AutoResetEvent,最后都Set完后,主线程就会往下执行。最后最后再来个买书付款取货的例子,加深理解:

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

namespace AutoResetEventTest
{
  class Program
  {
    const int numIterations = 10;
    static AutoResetEvent myResetEvent = new AutoResetEvent(false);
    static AutoResetEvent ChangeEvent = new AutoResetEvent(false);
    //static ManualResetEvent myResetEvent = new ManualResetEvent(false);
    //static ManualResetEvent ChangeEvent = new ManualResetEvent(false);
    static int number; //这是关键资源 

    static void Main()
    {
      Thread payMoneyThread = new Thread(new ThreadStart(PayMoneyProc));
      payMoneyThread.Name = "付钱线程";
      Thread getBookThread = new Thread(new ThreadStart(GetBookProc));
      getBookThread.Name = "取书线程";
      payMoneyThread.Start();
      getBookThread.Start(); 

      for (int i = 1; i <= numIterations; i++)
      {
        Console.WriteLine("买书线程:数量{0}", i);
        number = i;
        //Signal that a value has been written.
        myResetEvent.Set();
        //ChangeEvent.Set();
        Thread.Sleep(10);
      }
      payMoneyThread.Abort();
      getBookThread.Abort();
    } 

    static void PayMoneyProc()
    {
      while (true)
      {
        myResetEvent.WaitOne();
        //myResetEvent.Reset();
        Console.WriteLine("{0}:数量{1}", Thread.CurrentThread.Name, number);
        ChangeEvent.Set();
      }
    }
    static void GetBookProc()
    {
      while (true)
      {
        ChangeEvent.WaitOne();
        //ChangeEvent.Reset();
        Console.WriteLine("{0}:数量{1}", Thread.CurrentThread.Name, number);
        Console.WriteLine("------------------------------------------");
        //Thread.Sleep(0);
      }
    }
  }
}

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • C#实现多线程的同步方法实例分析

    本文主要描述在C#中线程同步的方法.线程的基本概念网上资料也很多就不再赘述了.直接接入 主题,在多线程开发的应用中,线程同步是不可避免的.在.Net框架中,实现线程同步主要通过以下的几种方式来实现,在MSDN的线程指南中已经讲了几种,这里结合作者实际中用到的方式一起说明一下. 1. 维护自由锁(InterLocked)实现同步 2. 监视器(Monitor)和互斥锁(lock) 3. 读写锁(ReadWriteLock) 4. 系统内核对象 1) 互斥(Mutex), 信号量(Semaphore

  • C#多线程及同步示例简析

    60年代,在OS中能拥有资源和独立运行的基本单位是进程,然而随着计算机技术的发展,进程出现了很多弊端,一是由于进程是资源拥有者,创建.撤消与切换存在较大的时空开销,因此需要引入轻型进程:二是由于对称多处理机(SMP)出现,可以满足多个运行单位,而多个进程并行开销过大. 因此在80年代,出现了能独立运行的基本单位--线程(Threads).        线程,有时被称为轻量级进程(Lightweight Process,LWP),是程序执行流的最小单元.一个标准的线程由线程ID,当前指令指针(P

  • C#简单多线程同步和优先权用法实例

    本文实例讲述了C#简单多线程同步和优先权用法.分享给大家供大家参考.具体分析如下: 本文实例题目如下: 麦当劳有两个做汉堡的厨师(工号:11,12)和三个销售人员(工号:21,22,23). 厨师生产汉堡,并负责将做好的汉堡放入货架,货架台大小有限,最多放6个汉堡,11和12不能同时往货架台上放汉堡,11具有优先权. 销售人员负责销售食品,三个销售人员取食品时,货架不能为空,三人不能同时取,23优先权最高,21最低.21卖的最快,取得频率最高,22次之. 一天的工作量是销售70个汉堡. 这里先来

  • c#.net多线程编程教学——线程同步

    随着对多线程学习的深入,你可能觉得需要了解一些有关线程共享资源的问题. .NET framework提供了很多的类和数据类型来控制对共享资源的访问. 考虑一种我们经常遇到的情况:有一些全局变量和共享的类变量,我们需要从不同的线程来更新它们,可以通过使用System.Threading.Interlocked类完成这样的任务,它提供了原子的,非模块化的整数更新操作. 还有你可以使用System.Threading.Monitor类锁定对象的方法的一段代码,使其暂时不能被别的线程访问. System

  • 详解C#多线程之线程同步

    多线程内容大致分两部分,其一是异步操作,可通过专用,线程池,Task,Parallel,PLINQ等,而这里又涉及工作线程与IO线程:其二是线程同步问题,鄙人现在学习与探究的是线程同步问题. 通过学习<CLR via C#>里面的内容,对线程同步形成了脉络较清晰的体系结构,在多线程中实现线程同步的是线程同步构造,这个构造分两大类,一个是基元构造,一个是混合构造.所谓基元则是在代码中使用最简单的构造.基原构造又分成两类,一个是用户模式,另一个是内核模式.而混合构造则是在内部会使用基元构造的用户模

  • C#多线程编程之使用ReaderWriterLock类实现多用户读与单用户写同步的方法

    本文实例讲述了C#多线程编程之使用ReaderWriterLock类实现多用户读与单用户写同步的方法.分享给大家供大家参考,具体如下: 摘要:C#提供了System.Threading.ReaderWriterLock类以适应多用户读/单用户写的场景.该类可实现以下功能:如果资源未被写操作锁定,那么任何线程都可对该资源进行读操作锁定,并且对读操作锁数量没有限制,即多个线程可同时对该资源进行读操作锁定,以读取数据. 使用Monitor或Mutex进行同步控制的问题:由于独占访问模型不允许任何形式的

  • 详细解析C#多线程同步事件及等待句柄

    最近捣鼓了一下多线程的同步问题,发现其实C#关于多线程同步事件处理还是很灵活,这里主要写一下,自己测试的一些代码,涉及到了AutoResetEvent 和 ManualResetEvent,当然还有也简要提了一下System.Threading.WaitHandle.WaitOne .System.Threading.WaitHandle.WaitAny和System.Threading.WaitHandle.WaitAll ,下面我们一最初学者的角度来看,多线程之间的同步. 假设有这样的一个场

  • ReentrantLock从源码解析Java多线程同步学习

    目录 前言 管程 管程模型 MESA模型 主要特点 AQS 共享变量 资源访问方式 主要方法 队列 node节点等待状态 ReentrantLock源码分析 实例化ReentrantLock 加锁 A线程加锁成功 B线程尝试加锁 释放锁 总结 前言 如今多线程编程已成为了现代软件开发中的重要部分,而并发编程中的线程同步问题更是一道难以逾越的坎.在Java语言中,synchronized是最基本的同步机制,但它也存在着许多问题,比如可重入性不足.死锁等等.为了解决这些问题,Java提供了更加高级的

  • 超详细讲解Linux C++多线程同步的方式

    目录 一.互斥锁 1.互斥锁的初始化 2.互斥锁的相关属性及分类 3,测试加锁函数 二.条件变量 1.条件变量的相关函数 1)初始化的销毁读写锁 2)以写的方式获取锁,以读的方式获取锁,释放读写锁 四.信号量 1)信号量初始化 2)信号量值的加减 3)对信号量进行清理 背景问题:在特定的应用场景下,多线程不进行同步会造成什么问题? 通过多线程模拟多窗口售票为例: #include <iostream> #include<pthread.h> #include<stdio.h&

  • Python编程scoketServer实现多线程同步实例代码

    本文研究的主要是Python编程scoketServer实现多线程同步的相关内容,具体介绍如下. 开发过程中,为了实现不同的客户端同一时刻只能有一个使用共同数据. 虽说用Python编写简单的网络程序很方便,但复杂一点的网络程序还是用现成的框架比较好.这样就可以专心事务逻辑,而不是套接字的各种细节.SocketServer模块简化了编写网络服务程序的任务.同时SocketServer模块也是Python标准库中很多服务器框架的基础. 网络服务类: SocketServer提供了4个基本的服务类:

  • Java多线程同步工具类CountDownLatch详解

    目录 简介 核心方法 CountDownLatch如何使用 CountDownLatch运行流程 运用场景 总结 简介 CountDownLatch是一个多线程同步工具类,在多线程环境中它允许多个线程处于等待状态,直到前面的线程执行结束.从类名上看CountDown既是数量递减的意思,我们可以把它理解为计数器. 核心方法 countDown():计数器递减方法. await():使调用此方法的线程进入等待状态,直到计数器计数为0时主线程才会被唤醒. await(long, TimeUnit):在

  • Mysql中复制详细解析

    1.mysql复制概念 指将主数据库的DDL和DML操作通过二进制日志传到复制服务器上,然后在复制服务器上将这些日志文件重新执行,从而使复制服务器和主服务器的数据保持同步.复制过程中一个服务器充当主服务器(master),而一个或多个其它服务器充当从服务器(slaves).主服务器将更新重新写入二进制日志文件,并维护文件的一个索引以跟踪日志循环.这些日志可以记录发送到从服务器的更新.当一个从服务器连接主服务器时,它通知主服务器.从服务器在日志中读取的最后一次成功更新的位置.从服务器接受从那时起发

  • python多线程之事件Event的使用详解

    前言 小伙伴a,b,c围着吃火锅,当菜上齐了,请客的主人说:开吃!,于是小伙伴一起动筷子,这种场景如何实现 Event(事件) Event(事件):事件处理的机制:全局定义了一个内置标志Flag,如果Flag值为 False,那么当程序执行 event.wait方法时就会阻塞,如果Flag值为True,那么event.wait 方法时便不再阻塞. Event其实就是一个简化版的 Condition.Event没有锁,无法使线程进入同步阻塞状态. Event() set(): 将标志设为True,

  • python多线程同步实例教程

    前言 进程之间通信与线程同步是一个历久弥新的话题,对编程稍有了解应该都知道,但是细说又说不清.一方面除了工作中可能用的比较少,另一方面就是这些概念牵涉到的东西比较多,而且相对较深.网络编程,服务端编程,并发应用等都会涉及到.其开发和调试过程都不直观.由于同步通信机制的原理都是想通的,本文希通过望借助python实例来将抽象概念具体化. 阅读之前可以参考之前的一篇文章:python多线程与多进程及其区别,了解一下线程和进程的创建. python多线程同步 python中提供两个标准库thread和

  • 关于java中@Async异步调用详细解析附代码

    目录 前言 1. @Async讲解 2. 用法 2.1 同步调用 2.2 异步调用 3. 自定义线程池 前言 异步调用与同步调用 同步调用:顺序执行,通过调用返回结果再次执行下一个调用 异步调用:通过调用,无需等待返回结果,执行下一个调用 1. @Async讲解 其@Async的注解代码如下: @Target({ElementType.TYPE, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Documented public

随机推荐