浅谈.NET开发中多线程思维方式

在NET中，我们用的最多的锁机制就是lock，用起来很简单，短短几行程序就可以实现，例如：

Lock 's Code
public class TestThreading
{
    private System.Object lockThis = new System.Object();
    public void Function()
    {
        lock (lockThis)
        {
            // Access thread-sensitive resources.
        }
    }
}

其实我们也明白，lock并不是锁，而是MS提供的一个简便式的写法，真正实现的是Monitor类中的Enter和Exit方法，既然提到了Monitor类也就说下有个需要注意的地方：

Pulse和PulseAll方法，这两个方法就是把锁状态将要改变的消息通知给等待队列中的线程，不过这时如果等待队列中没有线程，那么该方法就会一直等待下去，直到有等待的线程进入队列，也就是说该方法可能造成类试死锁的情况出现。

上面的lock + 线程(Thread和ThreadPool) = 多线程编程(N%)！？

对于该公式我曾经的N是80，现在是20。其中有很多东西影响我，让我从80->20，下面的Optex就是一个入口点。

--------------------------------------------------------------------------------


Optex 's Code
public sealed class Optex : IDisposable {
   private Int32 m_Waiters = 0;
   private Semaphore m_WaiterLock = new Semaphore(0, Int32.MaxValue);


   public Optex() { }
   public void Dispose() {
      if (m_WaiterLock != null)
      { 
         m_WaiterLock.Close(); 
         m_WaiterLock = null;
      } 
   }


   public void Enter() {
      Thread.BeginCriticalRegion();
      // Add ourself to the set of threads interested in the Optex
      if (Interlocked.Increment(ref m_Waiters) == 1) {
         // If we were the first thread to show interest, we got it.
         return;
      }


      // Another thread has the Optex, we need to wait for it
      m_WaiterLock.WaitOne();
      // When WaitOne returns, this thread now has the Optex
   }


   public void Exit() {
      // Subtract ourself from the set of threads interested in the Optex
      if (Interlocked.Decrement(ref m_Waiters) > 0) {
         // Other threads are waiting, wake 1 of them
         m_WaiterLock.Release(1);
      }
      Thread.EndCriticalRegion();
   }
}

看完上面的代码，让我增加了两点认识：

1、Thread.BeginCriticalRegion()和Thread.EndCriticalRegion();        

因为这段时间正好看了一本多线程编程的书，既然将上面方法认为是进入临界区和退出临界区，对于临界区而言，进入该区的数据，在没有退出之前，如果临界区外的程序需要使用它，那么就必须出于等待。所以觉得已经使用临界区，为什么还要使用Semaphore？！

可是，MS只是取了个相同的名字，做的事情完全不同，上面两个方法完全没有临界区的概念，它只是设置一个区域(Begin到End之间)，表示该区域内发生线程中断或未处理的异常会影响整个应用程序域。

2、m_Waiters的作用

一开始以为在Enter的时候，直接写上：

m_WaiterLock.WaitOne();

Exit的时候，写上：

m_WaiterLock.Release(1); 

这样就可以了。m_Waiters有什么意义？！           

优化性能，Semaphore是内核对象，我们都知道，要尽量少的进入内核模式，因为这是很消耗性能，所以尽量少的使用内核对象。m_Waiters的意义就在这里，如果只有一个线程使用该锁对象的时候，是不需要去获取和释放的。 OK，上述的东西都是铺垫，铺完了也就进入主题了！

多线程的思维

优化的Optex 


namespace ThreadConcurrent.Lock
{
    public sealed class Optex : IDisposable
    {
        /// 
        /// 琐的状态
        /// 
        private Int32 m_LockState = c_lsFree;


        ///

        /// 自由状态
        /// 
        private const Int32 c_lsFree = 0x00000000;
        
        /// 
        /// 被拥有状态
        /// 
        private const Int32 c_lsOwned = 0x00000001;
        
        /// 
        /// 等待的线程数
        /// 
        private const Int32 c_1Waiter = 0x00000002;


        private Semaphore m_WaiterLock = new Semaphore(0, Int32.MaxValue);


        #region 构造函数


        ///

        /// 
        /// 
        public Optex() { }


        #endregion


        ///

        /// 请求锁
        /// 
        public void Enter()
        {
            Thread.BeginCriticalRegion();
            while (true)
            {
                Int32 ls = InterlockedOr(ref m_LockState, c_lsOwned);


                //自由状态
                if ((ls & c_lsOwned) == c_lsFree) return;


                // 增加等待的线程数
                if (IfThen(ref m_LockState, ls, ls + c_1Waiter))
                {
                    m_WaiterLock.WaitOne();
                }
            }
        }


        public void Exit()
        {
            // 释放琐
            Int32 ls = InterlockedAnd(ref m_LockState, ~c_lsOwned);


            //无等待的线程
            if (ls == c_lsOwned)
            {
            }
            else
            {
                ls &= ~c_lsOwned;
                if (IfThen(ref m_LockState, ls & ~c_lsOwned, ls - c_1Waiter))
                {
                    m_WaiterLock.Release(1);
                }
                else
                {
                }
            }
            Thread.EndCriticalRegion();
        }


        #region 原子化操作


        ///

        /// 与操作
        /// 
        /// 
        /// 
        /// 
    
     
        private static Int32 InterlockedAnd(ref Int32 target, Int32 with)
     
        {
     
            Int32 i, j = target;
     
            do
     
            {
     
                i = j;
     
                j = Interlocked.CompareExchange(ref target, i & with, i);
     
            } while (i != j);
     
            return j;
     
        }
     


     
        ///
     
        /// 或操作
        /// 
     
        /// 
     
     
        /// 
     
     
        /// 
     
      
        private static Int32 InterlockedOr(ref Int32 target, Int32 with)
      
        {
      
            Int32 i, j = target;
      
            do
      
            {
      
                i = j;
      
                j = Interlocked.CompareExchange(ref target, i | with, i);
      
            } while (i != j);
      
            return j;
      
        }
      
 
      
        #endregion
 
      
        private static Boolean IfThen(ref Int32 val, Int32 @if, Int32 then)
        {
            return (Interlocked.CompareExchange(ref val, @then, @if) == @if);
        }
 
      
        private static Boolean IfThen(ref Int32 val, Int32 @if, Int32 then, out Int32 prevVal)
        {
            prevVal = Interlocked.CompareExchange(ref val, @then, @if);
            return (prevVal == @if);
        }
 
      
        ///
      
        /// 释放资源
        /// 
      
        public void Dispose()
      
        {
      
            if (m_WaiterLock != null)
      
            {
      
                m_WaiterLock.Close();
      
                m_WaiterLock = null;
      
            } 
      
        }
      
    }
      
}
      
    

对于上面的这个代码，我晕眩了好一段时间，不过当我真正理解的时候，从晕眩中学到了做多线程编程应该具备的思维方式。

首先从简单的理解开始谈，

1、原子化操作

对于InterLocked类，曾经也知道，但是却用的很少，不过从该代码中知道，在多线程的编程中对共享数据的写入操作，一定要达到原子性。至于如何做到这点，InterlockedAnd和InterlockedOr做了很好的诠释：

While循环的目的就是保证target值以***的值做与操作，如果传入的值在执行的过程被其他线程改变的话，那么是不会退出该循环的，并会利用改变后的值重新做次与操作。

2、理解Enter和Exit

这两个方法很难写出来解释，用图是最清晰的。

曾经的晕眩：

1、Enter方法中为什么存在循环，为什么不是执行完waitone就结束，必须m_lockState等于c_IsFree的时候才结束？

线程的执行并不完全按照先前排好的顺序去执行，有时会发生一些特殊的情况来使改变线程的调度顺序，所以就可能会出现上图灰色部分的情况，则为了解决该可能发生的问题（概率很小）循环机制就出现了。

2、为什么在WaitOne和Release之前，除了增加和减少等待者外，还需要判断m_lockstate是否改变（进入Enter到执行Waitone前的这段时间）？

一般性的思维：

该程序的思维：

这样做的好处就是尽量少的操作内核对象，提高性能！

多线程编程虽然复杂，但是我觉得很有意思和挑战性，而且随着硬件的发展，多线程编程会更加重要，既然已经上路就让我们走到尽头！

【编辑推荐】

  1. 白话详解ASP.NET的设计思想
  2. 简单理解ASP.NET MVC基本知识
  3. ASP.NET视频教程

文章题目：浅谈.NET开发中多线程思维方式
转载注明：http://www.shufengxianlan.com/qtweb/news30/471830.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站排名知识

同城分类信息

精灵网　　 　亮美家　　 　移动服务器托管　　 　成都网站设计　　 　成都定制网站　　 　三台网站建设　　 　成都名片印刷厂　　 　成都服务器托管　　 　温岭熙道网站　　 　成都印刷厂　　 　成都网站设计　　 　无边发光字制作　　 　成都网站建设　　 　成都广告公司　　 　雅安网站建设　　 　网络整合营销　　 　云服务器　　 　商城网站建设公司　　 　专业网站设计　　 　简阳网站制作