[原创][MethodImpl(MethodImplOptions.Synchronized)]、lock(this)与lock(typeof(...))

最新推荐文章于 2025-05-28 13:07:09 发布
最新推荐文章于 2025-05-28 13:07:09 发布 · 105 阅读 · 0
文章标签：

#thread

本文探讨了.NET中使用MethodImplAttribute实现线程同步的方法。详细分析了MethodImplAttribute(MethodImplOptions.Synchronized)在实例方法和静态方法上的应用效果，并通过实验验证了其与lock关键字的关系。

对于稍微有点经验的.NET开发人员来说，倘若被问及如何保持线程同步，我想很多人都能说好好几种。在众多的线程同步的可选方式中，加锁无疑是最为常用的。如果仅仅是基于方法级别的线程同步，使用System.Runtime.CompilerServices.MethodImplAttribute无疑是最为简洁的一种方式。MethodImplAttribute可以用于instance method，也可以用于static method。当在某个方法上标注了MethodImplAttribute，并指定MethodImplOptions.Synchronized参数，可以确保在不同线程中运行的该方式以同步的方式运行。我们几天来讨论MethodImplAttribute（MethodImplOptions.Synchronized）和lock的关系。

一、提出结论

在进行讨论之前，我先提出下面3个结论：

  • [MethodImplAttribute(MethodImplOptions.Synchronized)]仍然采用加锁的机制实现线程的同步。
  • 如果[MethodImplAttribute(MethodImplOptions.Synchronized)]被应用到instance method，相当于对当前实例加锁。
  • 如果[MethodImplAttribute(MethodImplOptions.Synchronized)]被应用到static method，相当于当前类型加锁

二、基于instance method的线程同步

为了验证我们上面提出的结论，我作了一个小小的例子。在一个console application中定义了一个class：SyncHelper，其中定义了一个方法Execute。打印出方法执行的时间，并休眠当前线程模拟一个耗时的操作：

   1: class SyncHelper
<!--CRLF--> 
   2: {
<!--CRLF--> 
   3:     public void Execute()
<!--CRLF--> 
   4:     {
<!--CRLF--> 
   5:         Console.WriteLine("Excute at {0}", DateTime.Now);
<!--CRLF--> 
   6:         Thread.Sleep(5000);
<!--CRLF--> 
   7:     }
<!--CRLF--> 
   8: }
<!--CRLF-->

在入口Main方法中，创建SyncHelper对象，通过一个System.Threading.Timer对象实现每隔1s调用该对象的Execute方法：

   1: class Program
<!--CRLF--> 
   2: {
<!--CRLF--> 
   3:     static void Main(string[] args)
<!--CRLF--> 
   4:     {
<!--CRLF--> 
   5:         SyncHelper helper = new SyncHelper();
<!--CRLF--> 
   6:         Timer timer = new Timer(
<!--CRLF--> 
   7:         delegate
<!--CRLF--> 
   8:         {
<!--CRLF--> 
   9:             helper.Execute();
<!--CRLF--> 
  10:         }, null, 0, 1000);
<!--CRLF--> 
  11:
<!--CRLF--> 
  12:         Console.Read();
<!--CRLF--> 
  13:
<!--CRLF--> 
  14:     }
<!--CRLF--> 
  15: }
<!--CRLF--> 
  16:
<!--CRLF-->

由于Timer对象采用异步的方式进行调用，所以虽然Execute方法的执行时间是5s，但是该方法仍然是每隔1s被执行一次。这一点从最终执行的结果可以看出：

image

为了让同一个SyncHelper对象的Execute方法同步执行，我们在Execute方法上添加了如下一个MethodImplAttribute：

   1: [MethodImpl(MethodImplOptions.Synchronized)]
<!--CRLF--> 
   2: public void Execute()
<!--CRLF--> 
   3: {
<!--CRLF--> 
   4:     Console.WriteLine("Excute at {0}", DateTime.Now);
<!--CRLF--> 
   5:     Thread.Sleep(5000);
<!--CRLF--> 
   6: }
<!--CRLF-->

从如下的输出结果我们可以看出Execute方法是以同步的方式执行的，因为两次执行的间隔正式Execute方法执行的时间：

image

在一开始我们提出的结论中，我们提到“如果[MethodImplAttribute(MethodImplOptions.Synchronized)]被应用到instance method，相当于对当前实例加锁”。说得直白一点：[MethodImplAttribute(MethodImplOptions.Synchronized)] = lock(this)。我们可以通过下面的实验验证这一点。为此，在SyncHelper中定义了一个方法LockMyself。在此方法中对自身加锁，并持续5s中，并答应加锁和解锁的时间。

   1: public void LockMyself()
<!--CRLF--> 
   2: {
<!--CRLF--> 
   3:    lock (this)
<!--CRLF--> 
   4:     {
<!--CRLF--> 
   5:         Console.WriteLine("Lock myself at {0}", DateTime.Now);
<!--CRLF--> 
   6:         Thread.Sleep(5000);
<!--CRLF--> 
   7:         Console.WriteLine("Unlock myself at {0}", DateTime.Now);
<!--CRLF--> 
   8:     }
<!--CRLF--> 
   9: }
<!--CRLF-->

我们在Main（）中以异步的方式（通过创建新的线程的方式）调用该方法： 

   1: static void Main(string[] args)
<!--CRLF--> 
   2: {
<!--CRLF--> 
   3:     SyncHelper helper = new SyncHelper();
<!--CRLF--> 
   4:
<!--CRLF--> 
   5:     Thread thread = new Thread(
<!--CRLF--> 
   6:         delegate()
<!--CRLF--> 
   7:         {
<!--CRLF--> 
   8:
<!--CRLF--> 
   9:              helper.LockMyself();
<!--CRLF--> 
  10:
<!--CRLF--> 
  11:         });
<!--CRLF--> 
  12:     thread.Start();
<!--CRLF--> 
  13:     Timer timer = new Timer(
<!--CRLF--> 
  14:     delegate
<!--CRLF--> 
  15:     {
<!--CRLF--> 
  16:         helper.Execute();
<!--CRLF--> 
  17:     }, null, 0, 1000);
<!--CRLF--> 
  18:
<!--CRLF--> 
  19:     Console.Read();
<!--CRLF--> 
  20: }
<!--CRLF-->

结合我们的第二个结论想想最终的输出会是如何。由于LockMyself方法是在另一个线程中执行，我们可以简单讲该方法的执行和Execute的第一个次执行看作是同时的。但是MethodImplAttribute(MethodImplOptions.Synchronized)]果真是通过lock(this)的方式实现的话，Execute必须在等待LockMyself方法执行结束将对自身的锁释放后才能得以执行。也就是说LockMyself和第一次Execute方法的执行应该相差5s。而输出的结果证实了这点：

image

三、基于static method的线程同步

讨论完再instance method上添加MethodImplAttribute(MethodImplOptions.Synchronized)]的情况，我们相同的方式来讨论倘若一样的MethodImplAttribute被应用到static方法，又会使怎样的结果。

我们先将Execute方法上的MethodImplAttribute注释掉，并将其改为static方法：

   1: //[MethodImpl(MethodImplOptions.Synchronized)]
<!--CRLF--> 
   2: public static void Execute()
<!--CRLF--> 
   3: {
<!--CRLF--> 
   4:     Console.WriteLine("Excute at {0}", DateTime.Now);
<!--CRLF--> 
   5:     Thread.Sleep(5000);
<!--CRLF--> 
   6: }
<!--CRLF-->

在Main方法中，通过Timer调用该static方法：

   1: static void Main(string[] args)
<!--CRLF--> 
   2: {
<!--CRLF--> 
   3:     Timer timer = new Timer(
<!--CRLF--> 
   4:     delegate
<!--CRLF--> 
   5:     {
<!--CRLF--> 
   6:         SyncHelper.Execute();
<!--CRLF--> 
   7:     }, null, 0, 1000);
<!--CRLF--> 
   8:
<!--CRLF--> 
   9:     Console.Read();
<!--CRLF--> 
  10: }
<!--CRLF-->

毫无疑问，Execute方法将以1s的间隔异步地执行，最终的输出结果如下：

image

然后我们将对[MethodImpl(MethodImplOptions.Synchronized)]的注释取消：

   1: [MethodImpl(MethodImplOptions.Synchronized)]
<!--CRLF--> 
   2: public static void Execute()
<!--CRLF--> 
   3: {
<!--CRLF--> 
   4:     Console.WriteLine("Excute at {0}", DateTime.Now);
<!--CRLF--> 
   5:     Thread.Sleep(5000);
<!--CRLF--> 
   6: }
<!--CRLF-->

最终的输出结果证实了Execute将会按照我们期望的那样以同步的方式执行，执行的间隔正是方法执行的时间：

image

我们回顾一下第三个结论：“如果[MethodImplAttribute(MethodImplOptions.Synchronized)]被应用到static method，相当于当前类型加锁”。为了验证这个结论，在SyncHelper中添加了一个新的static方法：LockType。该方法对SyncHelper tpye加锁，并持续5s中，在加锁和解锁是打印出当前时间：

   1: public static void LockType()
<!--CRLF--> 
   2: {
<!--CRLF--> 
   3:     lock (typeof(SyncHelper))
<!--CRLF--> 
   4:     {
<!--CRLF--> 
   5:         Console.WriteLine("Lock SyncHelper type at {0}", DateTime.Now);
<!--CRLF--> 
   6:         Thread.Sleep(5000);
<!--CRLF--> 
   7:         Console.WriteLine("Unlock SyncHelper type at {0}", DateTime.Now);
<!--CRLF--> 
   8:     }
<!--CRLF--> 
   9: }
<!--CRLF-->

在Main中，像验证instance method一样，创建新的线程执行LockType方法：

   1: static void Main(string[] args)
<!--CRLF--> 
   2: {
<!--CRLF--> 
   3:     Thread thread = new Thread(
<!--CRLF--> 
   4:         delegate()
<!--CRLF--> 
   5:         {
<!--CRLF--> 
   6:             SyncHelper.LockType();
<!--CRLF--> 

 



                

        




    


  



    

      

        

            

              
                
                  iteye_11848
                
              
            

            

                关注
              
            

        

        

          
      

      










                



	

		

			

				
					
C# Lock 解读

				
			

			

				

					类人_猿的博客
				

				

					10-15
					
					6539
					
				

			

		

		

			
				
lock 关键字可以用来确保代码块完成运行，而不会被其他线程中断。它可以把一段代码定义为互斥段（critical section），互斥段在一个时刻内只允许一个线程进入执行，而其他线程必须等待。这是通过在代码块运行期间为给定对象获取互斥锁来实现的。在多线程中，每个线程都有自己的资源，但是代码区是共享的，即每个线程都可以执行相同的函数。这可能带来的问题就是几个线程同时执行一个函数，导致数据的混乱，产生不可预料的结果，因此我们必须避免这种情况的发生。

			
		

	



                

            
              



	

		

			

				
					
C#Lock用法

					
热门推荐

				
			

			

				

					qq_30725967的博客
				

				

					01-14
					
					3万+
					
				

			

		

		

			
				
最近在研究.NET分布式缓存代码，正好涉及Lock，看了网上的文章，总结了一些Lock相关的知识，供大家一起学习参考。
一、Lock定义
lock 关键字可以用来确保代码块完成运行，而不会被其他线程中断。它可以把一段代码定义为互斥段（critical section），互斥段在一个时刻内只允许一个线程进入执行，而其他线程必须等待。这是通过在代码块运行期间为给定对象获取互斥锁来实现的。
在多线程中，...

			
		

	



              


  
              

                


	

		

			

				
					
C# 中 [MethodImpl(MethodImplOptions.Synchronized)] 的使用详解

				
			

			

				

					鲤籽鲲的博客
				

				

					01-27
					
					1724
					
				

			

		

		

			
				
C# 中 [MethodImpl(MethodImplOptions.Synchronized)] 的使用详解

			
		

	





	

		

			

				
					
C#的线程同步

				
			

			

				

					 IT技术猿猴的博客
				

				

					04-05
					
					4343
					
				

			

		

		

			
				
使用线程有几个原因。假设从应用程序中进行网络调用需要一定的时间。我们不希望用户界面停止响应，让用户一直等待直到从服务器返回一个响应。用户可以同时执行其他一些操作，或者甚至取消发送给服务器的请求。这些都可以使用线程来实现。



线程是程序中独立的指令流。使用C编写任何程序时，都有一个入口点:Main()方法。程序从Main(方法的第一条语句开始执行，直到这个方法返回为止。



这种程序结构非常适合于其中有一个可识别的任务序列的程序，但程序常常需要同时完成多个任务。线程对客户端和服务器端应用程序都非常重要。

			
		

	



		

			
		



	

		

			

				
					
深入解析 MethodImplOptions.NoInlining 特性：原理、作用与实际应用

				
			

			

				

					品质生活，极致编程。
				

				

					04-16
					
					905
					
				

			

		

		

			
				
是一个非常有用的特性，它可以帮助我们解决内联优化带来的问题。通过禁用内联优化，我们可以确保方法的独立性，动态获取方法名称，以及在调试和性能分析中获取准确的堆栈跟踪信息。在实际开发中，合理使用这个特性可以大大提高代码的可维护性和调试效率。希望本文能够帮助你更好地理解和使用特性。如果你有任何问题或建议，欢迎在评论区留言！

			
		

	





	

		

			

				
					
同步方法 [MethodImpl(MethodImplOptions.Synchronized)]

				
			

			

				

					
				

				

					07-27
					
					1765
					
				

			

		

		

			
				
使用[MethodImpl(MethodImplOptions.Synchronized)]而不是lock语句块实现“同步方法”。

			
		

	





	

		

			

				
					
iOS日常开发之面试题集锦（持续更新中...）

				
			

			

				

					天佑木枫
				

				

					07-24
					
					1360
					
				

			

		

		

			
				
目录1、block的本质1.1 block的本质1.2 为什么在默认情况下无法修改被block捕获的变量？ __block都做了什么？2、可变集合类 和 不可变集合类的 copy 和 mutablecopy有什么区别？如果是集合是内容复制的话，集合里面的元素也是内容复制么？3、关于nonatomic和atomic3.1 区别3.2 atomic是绝对的线程安全么？为什么？3.3 如果不是，那应该如何实现？3.3.1 使用NSLock实现的锁3.3.2 使用synchronized关键字构建的锁3.3.3 使

			
		

	





	

		

			

				
					
C# 线程同步与对象方法访问的深度解析

				
			

			

				

					记录学习的过程
				

				

					05-28
					
					1034
					
				

			

		

		

			
				
本文探讨了C#多线程编程中线程访问对象同步方法的问题。通过分析不同同步机制（lock语句、MethodImpl特性）和锁粒度（方法级、对象级、自定义锁），指出其他线程能否访问对象的其他方法取决于锁对象是否相同。实验表明：不同锁对象的方法可并行执行，相同锁对象的方法会阻塞。文章还对比了各种同步机制的特点，建议遵循锁定范围最小化和时间最短化原则，推荐使用自定义对象锁实现细粒度控制。最佳实践包括避免锁住整个对象、优先使用lock语句等。

			
		

	





	

		

			

				
					
[MethodImpl(MethodImplOptions.Synchronized)]

				
			

			

				

					weixin_30294709的博客
				

				

					11-20
					
					603
					
				

			

		

		

			
				
[MethodImpl(MethodImplOptions.Synchronized)]用来实现方法级别的线程同步。
MethodImplOptions 枚举:定义如何实现某方法的详细信息。
枚举成员：
AggressiveInlining:
此方法应内联（如果可能）。
ForwardRef:
此方法被声明，但提供该方法实现的在其他地方。
InternalCall:
内部调用是对在...

			
		

	





	

		

			

				
					
ILSpy反编译C#代码时出现的[MethodImpl(MethodImplOptions.Synchronized)]问题

				
			

			

				

					鸣风
				

				

					12-25
					
					1976
					
				

			

		

		

			
				
如下为反编译后的代码


public event EventHandler PageCountChanged
		{
			[MethodImpl(MethodImplOptions.Synchronized)]
			add
			{
				this.PageCountChanged = (EventHandler)Delegate.Combine(this.PageCountChanged...

			
		

	





	

		

			

				
					
[MethodImpl(MethodImplOptions.Synchronized)]、lock(this)与lock(typeof(...)) 

				
			

			

				

					carcarrot的博客
				

				

					08-22
					
					595
					
				

			

		

		

			
				
转自:https://blog.csdn.net/artech/article/details/4610277



对于稍微有点经验的.NET开发人员来说，倘若被问及如何保持线程同步，我想很多人都能说好好几种。在众多的线程同步的可选方式中，加锁无疑是最为常用的。如果仅仅是基于方法级别的线程同步，使用System.Runtime.CompilerServices.MethodImplAttribute无疑是最为简洁的一种方式。MethodImplAttribute可以用于instance method，

			
		

	





	

		

			

				
					
MethodImplOptions.Synchronized的一点讨论

				
			

			

				

					weixin_30951743的博客
				

				

					03-15
					
					294
					
				

			

		

		

			
				
Review代码发现有一个方法加了[MethodImpl(MethodImplOptions.Synchronized)] 属性，这个属性的目的，从名字上就可以看出，是要对所有线程进行同步执行。
对方法加上这个属性之后，会把整个方法体加在一个同步块中，比如下面的代码：

[MethodImpl(MethodImplOptions.Synchronized)]
public static v...

			
		

	





	

		

			

				
					
【总结】C# 线程同步技术（二）之 MethodImplAttribute 类和 SynchronizationAttribute 类...

				
			

			

				

					weixin_34191734的博客
				

				

					01-05
					
					207
					
				

			

		

		

			
				
本篇我们主要总结和介绍一下利用属性标签方式对多线程进行方法同步和上下文同步，主要用到的是MethodImplAttribute 类 和 SynchronizationAttribute 类。
这两个属于方法特性和类的特性，标识某个方法或类是同步方法，本质上还是基于Lock的实现的。
首先我们还是来看一个例子，假如小明和小红两个人用都是主附银行卡，两个人都可以对帐户进行操作，比如帐户余额1000...

			
		

	





	

		

			

				
					
C# 线程同步

				
			

			

				

					breakbridge的博客
				

				

					11-02
					
					1192
					
				

			

		

		

			
				
要避免同步问题，最好不要在线程之间共享数据。当然，这并不总是可行的。如果需要共享数据，就必须使用同步技术。如果不注意这些问题，就很难在应用程序中找到问题的原因，因为线程问题是不定期发生的。


...

			
		

	





	

		

			

				
					
C# Note26: [MethodImpl(MethodImplOptions.Synchronized)]与lock机制

				
			

			

				

					weixin_33834679的博客
				

				

					08-29
					
					280
					
				

			

		

		

			
				
在进行.NET开发时，经常会遇见如何保持线程同步的情况。在众多的线程同步的可选方式中，加锁无疑是最为常用的。如果仅仅是基于方法级别的线程同步，使用System.Runtime.CompilerServices.MethodImplAttribute无疑是最为简洁的一种方式。MethodImplAttribute可以用于instance method，也可以用于static method。当在某个...

			
		

	





	

		

			

				
					
C#开发笔记：[MethodImpl(MethodImplOptions.AggressiveInlining)]内联函数的声明和意义

				
			

			

				

					比比的博客
				

				

					03-24
					
					4104
					
				

			

		

		

			
				
在C#中我们通常定义以下函数来求两个整数的最大值：

复制代码代码如下:


int max(int a, int b)
{
return a > b ? a : b;
}

为这么一个小的操作定义一个函数的好处有：

① 阅读和理解函数 max 的调用，要比读一条等价的条件表达式并解释它的含义要容易得多

② 如果需要做任何修改，修改函数要比找出并修改每一处等价表达式容易得多

③ 使用函数可以确保统一的行为，每个测试都保证以相同的方式实现

④ 函数可以重用，不必为其他应用程序重写代码

虽然..

			
		

	





	

		

			

				
					
C#中是如何实现线程同步的

					
最新发布

				
			

			

				

					10-11
				

			

		

		

			
				
 [MethodImpl(MethodImplOptions.Synchronized)]  public static void Add(List<DateTime> list)  {  list.Add(DateTime.Now); // 自动同步  }  ```  - **实例方法**：锁定当前对象实例（等效 `lock(this)`）。  - *...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值