Thread by @nipafx

What's it called when multiple threads execute at the same time? Parallelism? Concurrency? 🤔 Is there a difference? (Spoiler: Yes!)

Let me explain in a few tweets, ripping off @pressron's #InsideJava blog post "On Parallelism and Concurrency". 🧵

inside.java/2021/11/30/on-…

Parallelism:
Taking a task and splitting it up, so multiple CPUs can compute partial solutions in parallel to solve the task in less wall-clock time.

Concurrency:
Having a number of tasks that need to be arranged in a way that solves as many of them per $time_unit as possible.

Some parallelizable tasks:

* sorting an array
* inverting a matrix
* rendering graphics

Some examples for concurrency:

* processing incoming web requests
* making outbound calls to DB and/or other web services
* observe file system for changes

Parallel and concurrent problems have a lot in common, but also a number of distinctive properties:

* task origin and control
* resource use and coordination
* main metric
* use and number of threads

Let's juxtapose them.

Task origin and control:

In parallel computing, it's the algorithm / the solution that produces multiple tasks and dev is in control over their shape and number.
In concurrent computing, tasks emerge from the environment and are part of the problem.

Resource use and coordination:

Parallel tasks coordinate use of resources (e.g. CPU time or data structures).
Concurrent tasks compete over resources (e.g. I/O).

Main Metric:

Latency for parallelized tasks.
Throughput for concurrent tasks.

Use and number of threads:

In parallel computing, threads are an abstraction for CPU cores. Thread count is usually in the same order of magnitude as core count.

In concurrent computing, threads are an abstraction for tasks. Having one thread per task would be easiest.

The distinction isn't always clear cut (e.g. booting an app requires initializing plugins / latency-oriented [P] but thread per plugin/task [C]) and the styles can be nested (e.g. a web request [C] requires sorting a large array [P]), but it's important to differentiate them.

Java supports both approaches, e.g.:

* thread pools work for either
* parallel streams lean towards parallelism
* reactive leans toward concurrency

#ProjectLoom will greatly improve support for concurrent programming by allowing us to have one (virtual) thread per task.

Beyond that, Loom aims to introduce *structured* concurrency. More on that in the JEP draft (openjdk.java.net/jeps/8277129), the latest Newscast (), and an upcoming thread.

🏁

Here's the thread I threatened. 🥁 (I'll see myself out.)

https://twitter.com/nipafx/status/1473255949922025476