The Thread class: This class represents all the threads that execute a concurrent Java application

The Runnable interface: This is another way to create concurrent applications in Java

The ThreadLocal class: This is a class to store variables locally to a thread

The ThreadFactory interface: This is the base of the Factory design pattern that you can use to create customized threads

Define a critical section to access a shared resource

Synchronize different tasks in a common point

The synchronized keyword: The synchronized keyword allows you to define a critical section in a block of code or in an entire method.

The Lock interface: Lock provides a more flexible synchronization operation than the synchronized keyword. There are different kinds of Locks: ReentrantLock, to implement a Lock that can be associated with a condition; ReentrantReadWriteLock, which separates read and write operations; and StampedLock, a new feature of Java 8 that includes three modes for controlling read/write access.

The Semaphore class: The class that implements the classical semaphore to implement synchronization. Java supports binary and general semaphores.

The CountDownLatch class: A class that allows a task to wait for the finalization of multiple operations.

The CyclicBarrier class: A class that allows the synchronization of multiple threads in a common point.

The Phaser class: A class that allows you to control the execution of tasks divided into phases. None of the tasks advance to the next phase until all of the tasks have finished the current phase.

The Executor and ExecutorService interface: They include methods common to all executors.

ThreadPoolExecutor: This is a class that allows you to get an executor with a pool of threads and optionally define a maximum number of parallel tasks

ScheduledThreadPoolExecutor: This is a special kind of executor to allow you to execute tasks after a delay or periodically

Executors: This is a class that facilitates the creation of executors

The Callable interface: This is an alternative to the Runnable interface—a separate task that can return a value

The Future interface: This is an interface that includes the methods to obtain the value returned by a Callable interface and to control its status

ForkJoinPool: This is a class that implements the executor that is going to run the tasks

ForkJoinTask: This is a task that can be executed in the ForkJoinPool class

ForkJoinWorkerThread: This is a thread that is going to execute tasks in the ForkJoinPool class

The Stream interface: This is an interface that defines all the operations that you can perform on a stream.

Optional: This is a container object that may or may not contain a non-null value.

Collectors: This is a class that implements reduction operations that can be used as part of a stream sequence of operations.

Lambda expressions: Streams has been thought to work with Lambda expressions. Most stream methods accept a lambda expression as a parameter. This allows you to implement a more compact version of the operations.

Blocking data structures: These include methods that block the calling task when, for example, the data structure is empty and you want to get a value.

Non-blocking data structures: If the operation can be made immediately, it won't block the calling tasks. Otherwise, it returns the null value or throws an exception.

ConcurrentLinkedDeque: This is a non-blocking list

ConcurrentLinkedQueue: This is a non-blocking queue

LinkedBlockingDeque: This is a blocking list

LinkedBlockingQueue: This is a blocking queue

PriorityBlockingQueue: This is a blocking queue that orders its elements based on its priority

ConcurrentSkipListMap: This is a non-blocking navigable map

ConcurrentHashMap: This is a non-blocking hash map

AtomicBoolean, AtomicInteger, AtomicLong, and AtomicReference: These are atomic implementations of the basic Java data types