互斥锁、同步锁、读写锁的区别

最新推荐文章于 2024-05-09 22:03:31 发布

Me918

最新推荐文章于 2024-05-09 22:03:31 发布

阅读量6k

点赞数

分类专栏：锁

锁专栏收录该内容

3 篇文章 1 订阅

订阅专栏

        相交进程之间的关系主要有两种，同步与互斥。所谓互斥，是指散步在不同进程之间的若干程序片断，当某个进程运行其中一个程序片段时，其它进程就不能运行它 们之中的任一程序片段，只能等到该进程运行完这个程序片段后才可以运行。所谓同步，是指散步在不同进程之间的若干程序片断，它们的运行必须严格按照规定的 某种先后次序来运行，这种先后次序依赖于要完成的特定的任务。
　　显然，同步是一种更为复杂的互斥，而互斥是一种特殊的同步。
　　也就是说互斥是两个线程之间不可以同时运行，他们会相互排斥，必须等待一个线程运行完毕，另一个才能运行，而同步也是不能同时运行，但他是必须要安照某种次序来运行相应的线程（也是一种互斥）！
　　总结：互斥：是指某一资源同时只允许一个访问者对其进行访问，具有唯一性和排它性。但互斥无法限制访问者对资源的访问顺序，即访问是无序的。
　　同步：是指在互斥的基础上（大多数情况），通过其它机制实现访问者对资源的有序访问。在大多数情况下，同步已经实现了互斥，特别是所有写入资源的情况必定是互斥的。少数情况是指可以允许多个访问者同时访问资源。

读写锁特点：

1）多个读者可以同时进行读 2）写者必须互斥（只允许一个写者写，也不能读者写者同时进行） 3）写者优先于读者（一旦有写者，则后续读者必须等待，唤醒时优先考虑写者）

互斥锁特点：

一次只能一个线程拥有互斥锁，其他线程只有等待

互斥锁(lock)

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

代码示例：

   
         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(); 
        
         } 
        
         } 
        
         } 
        
         } 
        
         }

Me918

关注

0
点赞
踩
12

收藏

觉得还不错? 一键收藏
0
评论
互斥锁、同步锁、读写锁的区别

相交进程之间的关系主要有两种，同步与互斥。所谓互斥，是指散步在不同进程之间的若干程序片断，当某个进程运行其中一个程序片段时，其它进程就不能运行它们之中的任一程序片段，只能等到该进程运行完这个程序片段后才可以运行。所谓同步，是指散步在不同进程之间的若干程序片断，它们的运行必须严格按照规定的某种先后次序来运行，这种先后次序依赖于要完成的特定的任务。　　显然，同步是一种更为复杂的互斥，而互斥是一种
复制链接

扫一扫