Java in a Nutshell, 9th Edition

Chapter 12. Concurrency in Java

This chapter is an introduction to the handling of concurrency (multithreading) in the Java platform. To fully understand this topic, it’s important to have a good grasp of the discussion of memory in Chapter 9—especially because some of the diagrams in this chapter build upon those concepts. It’s also useful, but not essential, to be familiar with the basic components of operating systems, such as the scheduler.

We will cover:

• Java’s concurrency primitives

• Data visibility and mutability

• Executors and threadpools

• Concurrent data structures

• Virtual threads

Let’s get started by defining the basic terms and concepts that we will use throughout this chapter.

Basic Concepts of Java Concurrency

The idea of a thread is that of a lightweight unit of execution—smaller than a process but still capable of executing arbitrary code. The usual way this is implemented is for each thread to be a full-fledged unit of execution to the operating system but to belong to a process, with the address space of the process being shared between all threads that make up that process. This means each thread can be scheduled independently and has its own stack and program counter but shares memory and objects with other threads in the same process.

Java has supported multithreaded programming from the very first version, and the platform directly exposes the ability to create new threads of execution to the developer.

To understand this, first we must consider ...