C#多线程编程中的锁系统(三)

本章主要说下基于内核模式构造的线程同步方式,事件,信号量。

目录

一:理论
二:WaitHandle
三:AutoResetEvent
四:ManualResetEvent
五:总结

一:理论

我们晓得线程同步可分为,用户模式构造和内核模式构造。

内核模式构造:是由windows系统本身使用,内核对象进行调度协助的。内核对象是系统地址空间中的一个内存块,由系统创建维护。

  内核对象为内核所拥有,而不为进程所拥有,所以不同进程可以访问同一个内核对象, 如进程,线程,作业,事件,文件,信号量,互斥量等都是内核对象。

  而信号量,互斥体,事件是windows专门用来帮助我们进行线程同步的内核对象。

  对于线程同步操作来说,内核对象只有2个状态, 触发(终止,true)、未触发(非终止,false)。 未触发不可调度,触发可调度。

用户模式构造:是由特殊CPU指令来协调线程,上节讲的volatile实现就是一种,Interlocked也是。  也可称为非阻塞线程同步。

二:WaitHandle

在windows编程中,我们通过API创建一个内核对象后会返回一个句柄,句柄则是每个进程句柄表的索引,而后可以拿到内核对象的指针、掩码、标示等。

而WaitHandle抽象基类类作用是包装了一个windows内核对象的句柄。我们来看下其中一个WaitOne的函数源码(略精简)。

代码如下:

public virtual bool WaitOne(TimeSpan timeout)
        {
            return WaitOne(timeout, false);
        }

[System.Security.SecuritySafeCritical]  // auto-generated
        [SuppressMessage("Microsoft.Concurrency", "CA8001", Justification = "Reviewed for thread-safety.")]
        private bool WaitOne(long timeout, bool exitContext)
        {
            return InternalWaitOne(safeWaitHandle, timeout, hasThreadAffinity, exitContext);
        }
        [System.Security.SecurityCritical] 
        internal static bool InternalWaitOne(SafeHandle waitableSafeHandle, long millisecondsTimeout, bool hasThreadAffinity, bool exitContext)
        {
            Contract.EndContractBlock();
            int ret = WaitOneNative(waitableSafeHandle, (uint)millisecondsTimeout, hasThreadAffinity, exitContext);
           
            if (ret == WAIT_ABANDONED)
            {
                ThrowAbandonedMutexException();
            }
            return (ret != WaitTimeout);
        }
        //调用win32 waitforsingleobjectEx
        [System.Security.SecurityCritical]
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private static extern int WaitOneNative(SafeHandle waitableSafeHandle, uint millisecondsTimeout, bool hasThreadAffinity, bool exitContext);

WaitAll 和WaitAny 调用win32中,waitformultipleobjectsEx函数。

SignalAndWaitOne 调用win32中,signalandwait函数。

调用api带ex都是设置超时的。 如果我们在c#中不传,默认是-1 表示无限期等待。

其中SafeWaitHandle字段,包含了一个win32内核对象句柄。

理解了WaitHandle其他都好办了,我们来看下它的派生类型。

代码如下:

WaitHandle
  |——EventWaitHandle                  事件构造。
    |——AutoResetEvent
    |——ManualResetEvent
  |——Semaphore                         信号量构造。
  |——Mutex                                 互斥体构造。

其中Semaphore和mutex第一章已经说过了,下面来看看其他的。

三:AutoResetEvent

使用示例如下,有简单注释。   关于描述,尽量贴近系统自身术语。

代码如下:

static void Main(string[] args)
        {
            //AutoResetEvent example
            //AutoResetEvent 通知正在等待的线程已发生的事件。
            AutoResetEvent waitHandler = new AutoResetEvent(false);//false 即非终止,未触发。
            new Thread(() =>
            {
                waitHandler.WaitOne();  //阻塞当前线程,等待底层内核对象收到信号。
                Console.WriteLine("接收到信号,开始处理。");

}).Start();
            new Thread(() =>
            {
                Thread.Sleep(2000);
                Console.WriteLine("发信号");
                waitHandler.Set();    //向内核对象发送信号。设置事件对象为非终止状态、false,解除阻塞。

}).Start();
            //waitHandler.Close(); //释放句柄资源。
            //waitHandler.Reset();  //手动设置事件为非终止状态、false,线程阻止。
            Console.ReadLine();
        }

WaitOne 阻塞线程,非自旋。

Set()   发出一个信号后,设置事件状态为false。  这本应该是2步的操作,AutoResetEvent.set()函数,给2步一起自动做了,很方便。

四:ManualResetEvent

这个和上面基本一样,从字面来说需要手动重置状态,我们来看例子。
 

代码如下:

ManualResetEvent manualWaitHandler = new ManualResetEvent(false);//false 即非终止,未触发。
            new Thread(() =>
            {
                manualWaitHandler.WaitOne();  //阻塞当前线程对象,等待信号。
                Console.WriteLine("接收到信号,开始处理。");

manualWaitHandler.Reset();  //手动 设置事件对象状态为非终止状态,false。
                manualWaitHandler.WaitOne();  //这里直接阻塞等待无效,因为事件对象还是true,必须手动调reset。
                Console.WriteLine("第二次接收到信号,开始处理。");

}).Start();
            new Thread(() =>
            {
                Thread.Sleep(2000);
                Console.WriteLine("发信号");
                manualWaitHandler.Set();    //向事件对象发送ok信号。。

Thread.Sleep(2000);
                Console.WriteLine("第二次发信号");
                manualWaitHandler.Set();
            }).Start();
            Console.ReadLine();

这2则区别很小,其实是系统Api的区分,不是net类库实现的。

在Win32Native类中,我可以看到KERNEL32 api 有这么个参数isManualReset。

代码如下:

[DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
        [ResourceExposure(ResourceScope.Machine)] // Machine or none based on the value of "name"
        internal static extern SafeWaitHandle CreateEvent(SECURITY_ATTRIBUTES lpSecurityAttributes, bool isManualReset, bool initialState, String name);

五:总结

基于内核模式构造的同步步骤是:   托管代码->用户模式代码->内核模式代码。

用户模式构造, 是利用CPU特殊指令,进行原子操作。

用户模式代码,如图。 是指  托管代码调用 win32代码 这一层,   之后在调内核模式代码。

(0)

相关推荐

  • C#多线程编程中的锁系统(二)

    上章主要讲排他锁的直接使用方式.但实际当中全部都用锁又太浪费了,或者排他锁粒度太大了. 这一次我们说说升级锁和原子操作. 目录 1:volatile 2:  Interlocked 3:ReaderWriterLockSlim 4:总结 一:volatile 简单来说: volatile关键字是告诉c#编译器和JIT编译器,不对volatile标记的字段做任何的缓存.确保字段读写都是原子操作,最新值. 这不就是锁吗?   其这货它根本不是锁, 它的原子操作是基于CPU本身的,非阻塞的. 因为32

  • 如何使用C#读写锁ReaderWriterLockSlim

    读写锁的概念很简单,允许多个线程同时获取读锁,但同一时间只允许一个线程获得写锁,因此也称作共享-独占锁.在C#中,推荐使用ReaderWriterLockSlim类来完成读写锁的功能. 某些场合下,对一个对象的读取次数远远大于修改次数,如果只是简单的用lock方式加锁,则会影响读取的效率.而如果采用读写锁,则多个线程可以同时读取该对象,只有等到对象被写入锁占用的时候,才会阻塞. 简单的说,当某个线程进入读取模式时,此时其他线程依然能进入读取模式,假设此时一个线程要进入写入模式,那么他不得不被阻塞

  • C#解决SQlite并发异常问题的方法(使用读写锁)

    本文实例讲述了C#解决SQlite并发异常问题的方法.分享给大家供大家参考,具体如下: 使用C#访问sqlite时,常会遇到多线程并发导致SQLITE数据库损坏的问题. SQLite是文件级别的数据库,其锁也是文件级别的:多个线程可以同时读,但是同时只能有一个线程写.Android提供了SqliteOpenHelper类,加入Java的锁机制以便调用.但在C#中未提供类似功能. 作者利用读写锁(ReaderWriterLock),达到了多线程安全访问的目标. using System; usin

  • Windows中使用C#为文件夹和文件编写密码锁的示例分享

    C#文件夹加锁小工具 用C#语言实现一个文件夹锁的程序,网上类似的"xxx文件夹xxx"软件很多,但是基本上都是C/C++语言实现的,且都没有提供源码(这个可以理解,毕竟是加密程序,不应该泄露源码). 程序的基本原理是:用C#语言重命名文件夹,通过重命名使之成为windows安全文件的类标识符.具体的方法是为文件夹添加拓展名".{2559a1f2-21d7-11d4-bdaf-00c04f60b9f0}" (.{2559a1f2-21d7-11d4-bdaf-00c

  • C#实现将程序锁定到Win7任务栏的方法

    本文实例讲述了C#实现将程序锁定到Win7任务栏的方法.分享给大家供大家参考.具体实现方法如下: Win7Taskbar类: using System; using System.Collections.Generic; using System.Text; using Shell32; using System.IO; namespace TestWin7Taskbar { class Win7Taskbar { public static bool LockApp(bool isLock,

  • C#中lock死锁实例教程

    在c#中有个关键字lock,它的作用是锁定某一代码块,让同一时间只有一个线程访问该代码块,本文就来谈谈lock关键字的原理和其中应注意的几个问题: lock的使用原型是: lock(X) { //需要锁定的代码.... } 首先要明白为什么上面这段话能够锁定代码,其中的奥妙就是X这个对象,事实上X是任意一种引用类型,它在这儿起的作用就是任何线程执行到lock(X)时候,X需要独享才能运行下面的代码,若假定现在有3个线程A,B,C都执行到了lock(X)而ABC因为此时都占有X,这时ABC就要停下

  • C#多线程编程中的锁系统(四):自旋锁

    目录 一:基础 二:自旋锁示例 三:SpinLock 四:继续SpinLock 五:总结 一:基础 内核锁:基于内核对象构造的锁机制,就是通常说的内核构造模式.用户模式构造和内核模式构造 优点:cpu利用最大化.它发现资源被锁住,请求就排队等候.线程切换到别处干活,直到接受到可用信号,线程再切回来继续处理请求. 缺点:托管代码->用户模式代码->内核代码损耗.线程上下文切换损耗. 在锁的时间比较短时,系统频繁忙于休眠.切换,是个很大的性能损耗. 自旋锁:原子操作+自循环.通常说的用户构造模式.

  • C#检查键盘大小写锁定状态的方法

    本文实例讲述了C#检查键盘大小写锁定状态的方法.分享给大家供大家参考.具体分析如下: 1.命名空间: using System.Runtime.InteropServices; 2.导入方法 [DllImport("user32.dll", EntryPoint = "GetKeyboardState")] public static extern int GetKeyboardState(byte[] pbKeyState); 3.大小写状态 public sta

  • C#多线程编程中的锁系统基本用法

    平常在多线程开发中,总避免不了线程同步.本篇就对net多线程中的锁系统做个简单描述. 目录 一:lock.Monitor      1:基础.      2: 作用域.      3:字符串锁.      4:monitor使用 二:mutex 三:Semaphore 四:总结 一:lock.Monitor 1:基础 Lock是Monitor语法糖简化写法.Lock在IL会生成Monitor. 复制代码 代码如下: //======Example 1=====             strin

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

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

随机推荐