In multithreaded programming, synchronization limits the benefits of concurrent executions

Short answer: concurrency is tricky. Real concurrency, with multiple concurrent authors, is really heavy.

What you need to define is what your actual consistency guarantees should be. Does every reader need to see every post guaranteed? You will then be forced to linearize all threads in some way (using locks, for example) - your next effort should be to make sure you do as much work as possible from the lock to hold the lock for as short a time as possible.

One way to keep a lock for as short a time as possible is to use a lock algorithm . Most of the locking-based algorithms are based on the atomic comparison and set primitive, such as in a package java.util.concurrent.atomic

. They can be very high performing, but designing a successful blocking algorithm can be subtle. One simple non-blocking algorithm is to simply create a new (immutable) state object and then atomically make it a "live" state, repeating in a loop if another state was created by another author in the middle. (This approach is good enough for many applications, but it is vulnerable to livelock if you have too many writers.)

If you can get a simpler consistency guarantee, then many other optimizations are possible. For example, you can use thread-local caches so that each thread sees its own view of the data and can write in parallel. Then you need to deal with the consequences of stale or inconsistent data. Most methods in this vein tend to be as consistent as possible : entries may not be visible to all readers at once, but they are guaranteed to all readers in the end.

This is an active area of ​​research and a complete answer could fill a book (several books indeed!). If you are just getting started in this field, I would recommend that you read Java concurrency in practice from Goetz et al, as he gives a good introduction to the topic and lots of practical advice on how to successfully create concurrent systems.

As far as I understand, since the state will be shared between threads, each thread must acquire a state lock before executing, so wouldn't that overcome the goal of multithreading?

The short answer is, "It depends." It is rare that you have a multithreaded application that does not share data. Thus, sharing data, even if it requires a complete lock, does not necessarily result in performance degradation when creating a multi-threaded application with a single thread.

The big question is what is the frequency that the state should update on each stream. If threads read in state do their parallel processing that takes time and then change state at the end, then you might see a performance boost. On the other hand, if every step of processing needs to be coordinated in some way between threads, then they might waste time fighting over the state object. By reducing this dependency on shared state, you will improve your multi-threaded performance.

There are also more efficient ways to update a state variable that can avoid locks. Something like the following pattern is used a lot:

 private AtomicReference<State> sharedState;
 ...
 // inside a thread processing loop
 // do the processing job
 while (true) {
   State existingState = sharedState.get();
    // create a new state object from the existing and our processing
    State newState = updateState(state);
    // if the application state hasn't changed, then update it
    if (sharedState.compareAndSet(existingState, newState)) {
        break;
    }
    // otherwise we need to get the new existing state and try again
 }

      

        
        
        
      

    

One way to handle state changes is to have a coordinating thread. This is the only thread that reads from state and generates jobs. When the job completes, they add updates to the state BlockingQueue

, which is then read by the coordinating thread, which updates the state in turn. Then the processing threads do not have to compete for access to the shared state.