java-concurrency | clean up java concurrency example

The value of the AtomicLong is on a cacheline. On the X86 there is a feature called cacheline locking which is used for locked instructions. So when a cas is done, the cacheline is first acquired in modified/exclusive state and then locked.

If a different CPU wants to access the same cacheline, its cache coherence requests including the request-for-ownership will be ignored till the cacheline is unlocked.

So it is a very lightweight form of synchronization. If you are lucky, the other CPU has some out of order instructions it can execute while it waits for the cacheline.

This approach is called non blocking even though it could lead to other threads 'blocking' since they need to wait. The primary difference with a blocking algorithm is that it can't happen that the CPU (thread) owning the locked cacheline gets suspended while it has locked that cacheline. This is taken care of at the hardware level (so the CPU can't be interrupted between cacheline lock acquire and release). So the blocking is guaranteed to be very short instead of unbounded like with a blocking algorithm.

According to @BeeOnRope there might be some optimistic behavior as well involved but this goes beyond my knowledge level.

In the first example, flags is initialised using a static initialiser. It is guaranteed by the Java Memory Model that any subsequent reads would see the updated value of the reference, and the correct initial state of Flags (basically, Flags would be properly published).

However, since Flags is mutable and might be mutated at a later point in time by multiple threads, you need to use proper synchronisation to ensure memory visibility for its state. So a volatile would be needed for its fields (or proper synchronisation).

In the second example, simply declaring flags as volatile won't ensure memory visibility of writes to arrays. It just ensures a happens-before relationship b/w writes to the array reference and subsequent reads from it. To ensure a happens-before relationship b/w writes to array elements and subsequent reads from them, you need to use locking, which you are already doing.

Why this works? The JMM guarantees a happens-before relationship b/w the release of a monitor and its re-acquisition. When a thread releases a lock which is later acquired by another thread, a kind-of total ordering (governed by happens-before) is ensured b/w whatever writes happened in the previous thread and any subsequent reads by the thread that re-acquired the lock.

Just remember that declaring a reference as volatile does not ensure proper visibility of the mutable state of the object it refers to. We still need proper synchronisation mechanisms to ensure memory visibility.

It seems that you didn't post a complete example. But, a few general comments:

You might be able to get away with using "compare-and-swap" logic for an integer, but you should not expect it to work for a more-sophisticated thing like a Java "String" or any sort of container.

You should simply use the synchronization-objects provided in the language. If you are going to update or even to examine a shared data structure, you must be holding the proper lock.

Of course, "thread-safe queues" are very helpful in many designs because they facilitate the most-common activity – message-passing – and allow the various threads to operate graciously at slightly-varying speeds. You still have to lock anything that's shared, but nonetheless it's a useful design that's really as old as the Unix® "pipe."

Yes, your code will work fine. The ConcurrentHashMap guarantees that all the inserted mappings will happen in a thread-safe manner.

You don't need to care about pool and cache -- they're effectively final variables, and as such, their values once set at construction time (before you start any multi-threaded code) won't change anymore.

What may be confusing you is that when dealing with non-final fields, you may need to mark them as volatile if you intend to change them and to be sure that the change is correctly propagated across threads. But as said above, notice how in this case the value of pool and caches is never changed.

The "memory cache" appears to really just be talking about anywhere in memory. Sometimes this is a cache of data stored on disk or externally. This is a software cache.

The CPU cache is a hardware cache and is faster, more localised but smaller.

But even if I remove the synchronized on the MySignal methods, this provides the same output as sharedSignal object is locked by one of the threads

Removing the synchronized from the methods won't make a difference as there is already a synchronized block guarding the method access from different threads.

And, if I remove only the synchronized in run(), it does not work properly as one of the threads end before even going to sleep.

But if you remove the the synchronized block then the contents of the block are not executed in an atomic way.

What I mean is without the synchronized block the any thread can call the sharedSignal.hasDataToProcess() get the lock on the MySignal object and then release it after it is done with the method then another thread is free to call the sharedSignal.setHasDataToProcess(false); as the lock on the MySignal instance was already released by the earlier thread when it was done with the method.

You will not be able to prohibit multiple calls from the same request, simply because your library has no concept of what a "request" actually is. This very much depends on the service using the library. Some services may use a single thread per request, but others may not. Using thread-locals is error-prone especially when you are working in multi-threaded or reactive applications where code processing a request can execute on multiple parallel threads.

If your requirement is that addPointsToTask is only called for a task that was actually started by some code that is processing the current request, you could set up your API like that. E.g. createTask could return a context object that is required to call addPointsToTask later.

It's all about happens-before relationship.

This relationship is simply a guarantee that memory writes by one specific statement are visible to another specific statement.

1. In the same thread,

The executor service is creating it for you. If you wish to override the naming of threads you can set options in the executor service. See Naming threads and thread-pools of ExecutorService