Your implementation is correct. The .NET Framework does not provide a built-in concurrent hashset type, unfortunately. However, there are some workarounds. ConcurrentDictionary (recommended) This first one is to use the class ConcurrentDictionary<TKey, TValue> in the namespace System.Collections.Concurrent. In the case, the value is pointless, so we can use a simple byte (1 byte in memory). … Read more
1) Yes, a select with NOLOCK will complete faster than a normal select. 2) Yes, a select with NOLOCK will allow other queries against the effected table to complete faster than a normal select. Why would this be? NOLOCK typically (depending on your DB engine) means give me your data, and I don’t care what … Read more
The Wikipedia article on spurious wakeups has this tidbit: The pthread_cond_wait() function in Linux is implemented using the futex system call. Each blocking system call on Linux returns abruptly with EINTR when the process receives a signal. … pthread_cond_wait() can’t restart the waiting because it may miss a real wakeup in the little time it … Read more
If you declare the method as synchronized (as you’re doing by typing public synchronized void addA()) you synchronize on the whole object, so two thread accessing a different variable from this same object would block each other anyway. If you want to synchronize only on one variable at a time, so two threads won’t block … Read more
The scoped_lock is a strictly superior version of lock_guard that locks an arbitrary number of mutexes all at once (using the same deadlock-avoidance algorithm as std::lock). In new code, you should only ever use scoped_lock. The only reason lock_guard still exists is for compatibility. It could not just be deleted, because it is used in … Read more
Can anyone tell me the advantage of the synchronized method over the synchronized block with an example? Thanks. There is not a clear advantage of using synchronized method over the block. Perhaps the only one ( but I wouldn’t call it an advantage ) is you don’t need to include the object reference this. Method: … Read more
It is bad form to use this in lock statements because it is generally out of your control who else might be locking on that object. In order to properly plan parallel operations, special care should be taken to consider possible deadlock situations, and having an unknown number of lock entry points hinders this. For … Read more
A lock allows only one thread to enter the part that’s locked and the lock is not shared with any other processes. A mutex is the same as a lock but it can be system wide (shared by multiple processes). A semaphore does the same as a mutex but allows x number of threads to … Read more
The lock statement is translated by C# 3.0 to the following: var temp = obj; Monitor.Enter(temp); try { // body } finally { Monitor.Exit(temp); } In C# 4.0 this has changed and it is now generated as follows: bool lockWasTaken = false; var temp = obj; try { Monitor.Enter(temp, ref lockWasTaken); // body } finally … Read more
Worst (won’t actually work) Change the access modifier of counter to public volatile As other people have mentioned, this on its own isn’t actually safe at all. The point of volatile is that multiple threads running on multiple CPUs can and will cache data and re-order instructions. If it is not volatile, and CPU A … Read more