Lock使用及效率分析(C#)

    针对无Lock、Lock、ReadWriterLock、ReadWriterLockSlim四种方式，测试在连续写的情况下，读取的效率（原子操作Interlocked由于使用针对int,double等修改的地方特别多，而且使用范围受限，所以本文章没有测试）

先说结论： 

锁类型	每分钟运行次数1	每分钟运行次数2	每分钟运行次数3	平均
无lock	97998684	80541036	97074298	91871339.3
lock	81270863	71114328	87351084	79912091.7
ReadWriterLock	74970270	89350032	85879937	83400079.7
ReadWriterLockSlim	85942306	92206133	88802621	88983686.7

运行环境：

运行效率：无lock>ReadWriteLockSlim>ReadWriterLock>lock

一、无Lock

多线程读写易造成数据错误，这里不是为了复现数据错误，而是为了测试无Lock方式的读取效率

private IntellVega.Project.Develop.Models.CustomSetting Compensation
{
    get
    {
        return _compensation;
    }
    set
    {
        _compensation = value;
    }
}

private void InitCommand()
{
    WriteCommand = new RelayCommand(Write);
    ReadCommand = new RelayCommand(Read);
}

private void Write()
{
    Task.Run(() =>
    {
        while (true)
        {
            IntellVega.Project.Develop.Models.CustomSetting compensation = new IntellVega.Project.Develop.Models.CustomSetting();
            Random random = new Random();
            compensation.FocusCompensation = random.NextDouble();
            Compensation = compensation;
        }
    });
}

private void Read()
{
    Time = 0;
    Task.Run(() =>
    {
        Stopwatch sw = Stopwatch.StartNew();
        while (true)
        {
            if (sw.ElapsedMilliseconds > 60 * 1000) { break; }
            double d = Compensation.FocusCompensation;
            Time++;
        }
    });
}

二、lock

lock是一种比较好用的简单的线程同步方式，它是通过为给定对象获取互斥锁来实现同步的。它可以保证当一个线程在关键代码段的时候，另一个线程不会进来，它只能等待，等到那个线程对象被释放，也就是说线程出了临界区。

lock的参数必须是基于引用类型的对象，不要是基本类型像bool,int什么的，这样根本不能同步，原因是lock的参数要求是对象，如果传入int，势必要发生装箱操作，这样每次lock的都将是一个新的不 同的对象。最好避免使用public类型或不受程序控制的对象实例，因为这样很可能导致死锁。特别是不要使用字符串作为lock的参数，因为字符串被CLR“暂留”，就是说整个应用程序中给定的字符串都只有一个实例，因此更容易造成死锁现象。建议使用不被“暂留”的私有或受保护成员作为参数。其实某些 类已经提供了专门用于被锁的成员，比如Array类型提供SyncRoot，许多其它集合类型也都提供了SyncRoot。

　　所以，使用lock应该注意以下几点：　

　　１、如果一个类的实例是public的，最好不要lock(this)。因为使用你的类的人也许不知道你用了lock，如果他new了一个实例，并且对这个实例上锁，就很容易造成死锁。

　　２、如果MyType是public的，不要lock(typeof(MyType))

　　３、永远也不要lock一个字符串

private IntellVega.Project.Develop.Models.CustomSetting Compensation
{
    get
    {
        lock (_obj)
        {
            return _compensation;
        }
    }
    set
    {
        lock (_obj)
        {
            _compensation = value;
        }
    }
}

三、ReadWriterLock方式

在考虑资源访问的时候,惯性上我们会对资源实施lock机制,但是在某些情 况下,我们仅仅需要读取资源的数据,而不是修改资源的数据,在这种情况下获取资源的独占权无疑会影响运行效率,因此.Net提供了一种机制,使用ReaderWriterLock进行资源访问时,如果在某一时刻资源并没有获取写的独占权,那么可以获得多个读的访问权,单个写入的独占权,如果某一时 刻已经获取了写入的独占权,那么其它读取的访问权必须进行等待

private IntellVega.Project.Develop.Models.CustomSetting Compensation
{
    get
    {
        try
        {
            _readWriterLock.AcquireReaderLock(1000);
            return _compensation;
        }
        finally
        {
            _readWriterLock.ReleaseReaderLock();
        }
    }
    set
    {
        _readWriterLock.AcquireWriterLock(1000);
        _compensation = value;
        _readWriterLock.ReleaseWriterLock();
    }
}

四、ReadWriterLockSlim方式

 ReaderWriterLockSlim 类似于 ReaderWriterLock，只是简化了递归、升级和降级锁定状态的规则。 ReaderWriterLockSlim 可避免多种潜在的死锁情况。 此外，ReaderWriterLockSlim 的性能明显优于 ReaderWriterLock。 建议在所有新的开发工作中使用 ReaderWriterLockSlim。
摘自：链接：https://www.jianshu.com/p/a3e69ed17c8a
 

private IntellVega.Project.Develop.Models.CustomSetting Compensation
{
    get
    {
        try
        {
            _readWriterSlimLock.EnterReadLock();
            return _compensation;
        }
        finally
        {
            _readWriterSlimLock.ExitReadLock();
        }
    }
    set
    {
        try
        {
            _readWriterSlimLock.EnterUpgradeableReadLock();
            try
            {
                _readWriterSlimLock.EnterWriteLock();
                _compensation = value;
            }
            finally
            {
                _readWriterSlimLock.ExitWriteLock();
            }
        }
        finally
        {
            _readWriterSlimLock.ExitUpgradeableReadLock();
        }
    }
}

--END