C# 多线程编程之锁的使用【互斥锁(lock)和读写锁(ReadWriteLock)】

Frank__Library 2015-08-19

展开全文

今天主要介绍下C#的两种锁：互斥锁(lock)和读写锁(ReadWriteLock)

互斥锁(lock)

lock 关键字将语句块标记为临界区，方法是获取给定对象的互斥锁，执行语句，然后释放该锁。当任何一个线程获取到锁后，其他线程如果需要使用该临界区内代码，则必须等待前一个线程使用完毕后释放锁。

代码示例：

1

2

3

4

5

Object thisLock = new Object();
lock (thisLock)
{
    // 临界区代码块
}

读写锁(ReadWriteLock)

ReadWriteLock定义支持单个写线程和多个读线程的锁。该锁的作用主要是解决并发读的性能问题，使用该锁，可以大大提高数据并发访问的性能，只有在写时，才会阻塞所有的读锁。

示例代码：

using System.Collections.Generic;
using System.Windows;
using System.Threading;
 
 
namespace FYSTest
{
    public partial class MainWindow : Window
    {
        List<int> list = new List<int>();
        private ReaderWriterLock _rwlock = new ReaderWriterLock();
 
        public MainWindow()
        {
            InitializeComponent();
            Thread ThRead = new Thread(new ThreadStart(Read));
            ThRead.IsBackground = true;
            Thread ThRead2 = new Thread(new ThreadStart(Read));
            ThRead2.IsBackground = true;
            Thread ThWrite = new Thread(new ThreadStart(Write));
            ThWrite.IsBackground = true;
            ThRead.Start();
            ThRead2.Start();
            ThWrite.Start();
        }
 
        private void Read()
        {
            while (true)
            {
                //使用一个 System.Int32 超时值获取读线程锁。
                _rwlock.AcquireReaderLock(100);
                try
                {
                    if (list.Count > 0)
                    {
                        int result = list[list.Count - 1];
                    }
                }
                finally
                {
                    //减少锁计数,释放锁
                    _rwlock.ReleaseReaderLock();
                }
            }
        }
 
        int WriteCount = 0;//写次数
        private void Write()
        {
            while (true)
            {
                //使用一个 System.Int32 超时值获取写线程锁。
                _rwlock.AcquireWriterLock(100);
                try
                {
                    list.Add(WriteCount++);
                }
                finally
                {
                    //减少写线程锁上的锁计数，释放写锁
                    _rwlock.ReleaseWriterLock();
                }
            }
        }
    }
}
</int></int>