<\/a>The code is using double-checked locking pattern<\/a> that allows initializing an identity field lazily in multithreaded environment. During one of the profiling sessions, I\u2019ve noticed that the number of objects with a valid id reached few million instances and the main surprise was that it didn\u2019t cause any issues in terms of performance.<\/p>\n After that, I\u2019ve created a benchmark to see the impact of the lock<\/b> statement in terms of performance compared to a no-lock approach.<\/p>\n To analyze performance differences, I\u2019ll be using BenchmarkDotNet<\/a>:<\/p>\n In this case, NoLockNode<\/b> is not suitable for multithreaded scenarios, but our benchmark doesn\u2019t try to get Id<\/b>\u2019s for two instances from different threads at the same time either. The benchmark mimics the real-world scenario when contention is happening rarely and in most cases the application just consumes already created identifier.<\/p>\n As we can see the difference is extremely small. How can the CLR get 1 million locks with almost 0 overhead?<\/p>\n To shed some light on the CLR behavior, let\u2019s extend our benchmarking test suite by another case. Let\u2019s add another Node<\/b> class that calls GetHashCode<\/b> method in the constructor (non overridden version of it) and then discards the result:<\/p>\n The result of the GetHashCode<\/b> invocation is discarded and the call itself does not affect the end-2-end time because the benchmark excludes construction time from the measurements. But the questions are: why there is almost 0 overhead for a lock<\/b> statement in case of NodeWithLock<\/b> and significant difference when the GetHashCode<\/b> method was called on the object instance in NodeWithLockAndGetHashCode<\/b>?<\/p>\n Each object in the CLR can be used to create a critical region to achieve mutually exclusive execution. And you may think that to do so, the CLR creates a kernel object for each CLR object. But this approach would make no sense just because only a very small fraction of all the objects are being used as handles for synchronization purposes. So, it makes a perfect sense that the CLR creates expensive data structures required for synchronization lazily. Moreover, if the CLR can avoid redundant data structures, it won\u2019t create them at all.<\/p>\n As you may know, every managed object has an auxiliary field for every object called the object header. The header itself can be used for different purposes and can keep different information based on the current object\u2019s state.<\/p>\n The CLR can store object\u2019s hash code, domain specific information, lock-related data and some other stuff at the same time. Apparently, 4 bytes of the object header is simply not enough for all of that. So, the CLR will create an auxiliary data structure called sync block table and will keep just an index in the header itself. But the CLR will try to avoid that and will try to put as much data in the header itself as possible.<\/p>\n Here is a layout for a most significant byte of the object header:<\/p>\n If the BIT_SBLK_IS_HASH_OR_SYNCBLKINDEX bit is 0, then the header itself keeps all lock-related information and the lock is called a \u201cthin lock\u201d. In this case, the overall layout of the object header is the following:<\/p>\n If the BIT_SBLK_IS_HASH_OR_SYNCBLKINDEX bit is 1 then the sync block created for an object or the hash code was computed. If the BIT_SBLK_IS_HASHCODE is 1 (bit #26) then the rest of the dword (lower 26 bits) is the object\u2019s hash code, otherwise, the lower 26 bits represents a sync block index:<\/p>\npublic class NoLockNode\r\n{\r\n public const int InvalidId = -1;\r\n private static int s_idCounter;\r\n\r\n private int m_id = InvalidId;\r\n\r\n public int Id\r\n {\r\n get\r\n {\r\n if (m_id == InvalidId)\r\n {\r\n \/\/ Leaving double check to have the same amount of computation here\r\n if (m_id == InvalidId)\r\n {\r\n m_id = Interlocked.Increment(ref s_idCounter);\r\n }\r\n }\r\n\r\n return m_id;\r\n }\r\n }\r\n}<\/pre>\nList<NodeWithLock.Node> m_nodeWithLocks => \r\n Enumerable.Range(1, Count).Select(n => new NodeWithLock.Node()).ToList();\r\nList<NodeNoLock.NoLockNode> m_nodeWithNoLocks => \r\n Enumerable.Range(1, Count).Select(n => new NodeNoLock.NoLockNode()).ToList();\r\n\r\n[Benchmark]\r\npublic long NodeWithLock()\r\n{\r\n \/\/ m_nodeWithLocks has 5 million instances\r\n return m_nodeWithLocks\r\n .AsParallel()\r\n .WithDegreeOfParallelism(16)\r\n .Select(n => (long)n.Id).Sum();\r\n}\r\n\r\n[Benchmark]\r\npublic long NodeWithNoLock()\r\n{\r\n \/\/ m_nodeWithNoLocks has 5 million instances\r\n return m_nodeWithNoLocks\r\n .AsParallel()\r\n .WithDegreeOfParallelism(16)\r\n .Select(n => (long)n.Id).Sum();\r\n}<\/pre>\n Method | Mean | StdDev |\r\n---------------------------- |------------ |---------- |\r\n NodeWithLock | 152.2947 ms | 1.4895 ms |\r\n NodeWithNoLock | 149.5015 ms | 2.7289 ms |<\/pre>\n
public class Node\r\n{\r\n public const int InvalidId = -1;\r\n private static int s_idCounter;\r\n private object syncRoot = new object();\r\n private int m_id = InvalidId;\r\n public Node()\r\n {\r\n GetHashCode();\r\n }\r\n\r\n public int Id\r\n {\r\n get\r\n {\r\n if (m_id == InvalidId)\r\n {\r\n lock(this)\r\n {\r\n if (m_id == InvalidId)\r\n {\r\n m_id = Interlocked.Increment(ref s_idCounter);\r\n }\r\n }\r\n }\r\n\r\n return m_id;\r\n }\r\n }\r\n}<\/pre>\n Method | Mean | StdDev |\r\n---------------------------- |------------ |---------- |\r\n NodeWithLock | 152.2947 ms | 1.4895 ms |\r\n NodeWithNoLock | 149.5015 ms | 2.7289 ms |\r\n NodeWithLockAndGetHashCode | 541.6314 ms | 4.0445 ms |<\/pre>\n
Thin locks, inflation and object header layout<\/h4>\n
![\"clip_image002\"](\"https:\/\/devblogs.microsoft.com\/wp-content\/uploads\/sites\/31\/2019\/06\/clip_image002_thumb2.png\" "\\"clip_image002\\"")
<\/a><\/p>\n![\"image\"](\"https:\/\/devblogs.microsoft.com\/wp-content\/uploads\/sites\/31\/2019\/06\/image_thumb24.png\" "\\"image\\"")
<\/a><\/p>\n
![\"image\"](\"https:\/\/devblogs.microsoft.com\/wp-content\/uploads\/sites\/31\/2019\/06\/image_thumb25.png\" "\\"image\\"")
<\/a><\/p>\n