Thread Synchronization

Question

http://http://www.c-sharpcorner.com/Forum new links/Thread/142312/threading.aspx

What is your definition of Synchronization?

Can you point out some weird issues when dealing with Thread Synchronization? In my past experience. I experience a lot timing issues etc.....

Well my definition is to ensure that your sets are completely processed before you gets happen. These issues happens when you have threaded methods that are not Asynchronus methods. This is were locks and semaphores comes into place.

Vulpes · Answer

The lock is automatically released when the lock statement is exited either because its closing brace is reached or a 'jump' statement (such as return break goto etc.) is encountered which transfers control outside the lock statement.

David Smith · Answer

@Vuples I was doing some reading on locks from the article below. Does the lock become released after the parent method or thread has returned? Creating mutually exclusive code block C# Posted Mar 14 2010 by Mayur Gondaliya in Samples with 0 Comments Sometimes we may need to act on some information(object) which is critical for the application and we need to make sure that the information contained by that object is consistent. The way to keep the information in the object consistent is to avoid the access of that object by more than one thread or program. In short we need to achieve mutual exclusion for that object for predefined number of statements or block of code. C# offers this by several ways such as lock mutex and semaphores. lock statement is the easiest way to lock the object and the related statements. The basic syntax is below. Object thisLock = new Object(); lock (thisLock) { // Critical code section } Suppose you act upon one DataTable object and you do not want to alter the content of it by more than one threads then option available is to lock that datatable object. DataTable dt = DatabaseOperations.GetDataTable(SQL); lock(dt) { // critical statements to alter the contents inside dt } In short lock enables us to achieve the mutually exclusive access to the locked object such that when it is locked no other thread can access that locked object until its lock is released. The thread that attempts to gain the access of the locked object gets to the SUPENDED state until the lock is removed. Examples lock(this) – locks the current instance of the object in which the statements are being executed. lock(typeof(ClassName)) – locks the static members of the class ClassName

Sam Hobbs · Answer

I think this and this will help. Let's say that you and a friend Jasmine want to meet for dinner but you and she will be in meetings and otehr things so you are not sure when. So you call her and she calls you and you agree whan and where to meet. You and she might also use text messages so you are able to communicate during a meeting. So you are on the way to meet Jasmine and you get trapped by a dust storm. So you call her and say you have to postpone or cancel dinner. So for that the phone is a synchronization object; you might say that it provides two synchronization objects voice and text.

Vulpes · Answer

Threading would be easy if threads never interacted with each other but to do anything useful they normally do have to interact in some way. The worst problem is 'shared' read/write memory i.e. memory which all threads have access to and which they can read and write. Incidentally this never includes local variables or parameters passed by value as every thread has its own stack and therefore its own copy of such variables but it does include fields of classes/structs or parameters passed by reference. To avoid the chaos that would otherwise ensue access to shared writeable memory needs to be 'synchronized' between threads in order to achieve a predictable outcome. Where a number of threads can enter the same method concurrently and read or write to shared memory when they do then synchronization is usually achieved using the 'lock' statement. lock(padlock) { // protected block } A lock ensures that only one thread can enter the protected block at a time - the others queue up until the lock is released. The mechanism used is for a thread to take out a mutually-exclusive lock on some object. Any reference type object can be used but the best strategy is to use a private static field in the same class which is dedicated for this purpose. For example: private static object padlock = new object(); All objects are stored on the heap and included in the overhead (8 bytes on a 32-bit system) they all have is a 'sync block address' which is a pointer into a system-wide tables of structures used for synchronization. If this pointer is not NULL then the object is currently locked. There's a lot more to be said about synchronization but I'll leave it at that for now to enable others to chip in.