Multi threading and Concurrency

Table of Contents

Multithreaded
Spawning threads for asynchronous tasks
- Caveats
volatile
What mini-project/assignment would you suggest for better understanding of multithreading?
What’s the best way to implement multi threading in Java aside the usual Runnable interface or Thread base class?
Reading material
Tags

Multithreaded

Describes a program that is designed to have parts of its code execute concurrently.

Spawning threads for asynchronous tasks

And let’s say if I want to perform a time consuming task in my Servlet’s doGet() method asynchronously, I start a new thread using Java executors so that lengthy calculations are done in a separate thread and response is sent right away.

Now does that ensure that I have freed the thread which had been processing my HttpServletRequest or is it still being used because a child thread is still running?

Creating a thread inside another thread doesn’t establish any special relationship, and the whole point of doing so in most cases is to let the one thread do more work or terminate while the other thread continues working. In your scenario, using a different thread to do work required by a request will, as you expect, allow the response to be sent immediately. The thread used to serve that request will also be immediately available for another request, regardless of how long your other thread takes to complete. This is pretty much the way of doing asynchronous work in a thread-per-request servlet container.

Caveats

Be careful. The bean scopes session and request do not work in threads spawned! Also other code beased on ThreadLocal does not work out of the box, you need to transfer the values to the spawned threads by yourself.

This does not apply to the new way of doing things with containers. But if it is a really old app using EE containers, take note of the following points.

If you’re in a full Java EE container, threads may be managed for you in a way that makes it a bad idea to spawn your own. In that case, you’re better off asking the container for a thread, but the general principles are the same.

volatile

A Java keyword used in variable declarations that specifies that the variable is modified asynchronously by concurrently running threads.

What mini-project/assignment would you suggest for better understanding of multithreading?

Barry Rountree · December 10, 2017 - HPC is what I do for a living

Consider nanopond (https://github.com/adamierymenko/nanopond)

. It’s a really cool artificial life/evolution simulator. Nice visuals.

The 2.0 version adds multithreading. Does the existing implementation prevent race conditions? Run a single-threaded version for some number of timesteps, and then run a multithreaded version for the same number of timesteps using the same random number seed. Do the results agree? What changes would you need to make to get identical results for serial and parallel versions? “Strong scaling” refers to increasing parallelism for the same problem, while “weak scaling” refers to keeping the problem size the same for each thread — more parallelism allows solving larger problems. How well does your implementation in #2 scale in both the strong and weak sense? What bottlenecks do you run into? Several cloud providers allow renting compute nodes by the hour at very reasonable rates. How well does your implementation scale on compute nodes with much larger numbers of cores? If you were to relax the constraint of “bitwise reproducibility”, how much more performance could you gain? How does relaxing that constraint change the behavior of the simulation? (Given a set of statistics from a race-free and racy implementation, can you tell which is which?) “Overcommitting” refers to creating more threads than there are cores to run them. If you enable hyperthreading on your processor, does overcommitting lead to higher performance? Is there any performance benefit from using hyperthreads? Is there any performance benefit from creating more threads than hyperthreads per core x number of cores? How much performance is lost from choosing the next location at random? How would you use a multithreaded implementation to hide that memory latency? Do the characteristics of the application change with non-random selection (which should give much, much better cache behavior)?

Now that you’ve mastered multithreading on a tiny program, have a look at ReSCAL (http://www.ipgp.fr/~rozier/rescal/rescal.html) .

What’s the best way to implement multi threading in Java aside the usual Runnable interface or Thread base class?

Vladislav Zorov · July 16, 2015 programming enthusiast.

I think it depends on why you need it:

If you just want to apply some transformation to lots of data, parallelStream in Java 8 is your friend - Parallelism (The Java™ Tutorials > Collections > Aggregate Operations) (https://docs.oracle.com/javase/tutorial/collections/streams/parallelism.html)

If you want to have lots of different tasks in-flight, i.e. to speed up some GUI application, you can use futures (JVM concurrency: Java and Scala concurrency basics) or the new, better futures in Java 8 (JVM concurrency: Java 8 concurrency basics - https://www.ibm.com/developerworks/library/j-jvmc2/index.html). The first link explains the differences to manual threads.

If you just want lots of asynchrony, i.e. for building networked GUI apps, there’s FRP and RxJava (Grokking RxJava, Part 1: The Basics - https://blog.danlew.net/2014/09/15/grokking-rxjava-part-1/). There’s also experimental support for parallel observables here - ReactiveX/RxJavaParallel (https://github.com/ReactiveX/RxJavaParallel).