Location>code7788 >text

Concurrent programming knowledge summary

Popularity：288 ℃/2025-03-09 19:21:28

Concurrent programming

process and thread

process

What we often hear about is applications, that is, apps.Consisting of instructions and data.But when we don't run a specific app, these applications are some binary code placed on disk (also including USB disk, remote network storage, etc.). Once we run these applications, the instructions to run and the data to be read and written, the instructions must be loaded to the CPU and the data to be loaded into memory. During the command operation, disk, network and other devices are also required.From this perspective, processes are used to load instructions, manage memory, and manage IO.

When a program is run, the code of the program is loaded from disk to memory, a process is started.

A process can be regarded as an instance of a program. Most programs can run multiple instance processes at the same time (such as notepad, drawing, browser, etc.), and some programs can only start one instance process (such as NetEase Cloud Music, 360 Security Guard, etc.). Obviously, the program is dead and static, and the process is alive and dynamic.Processes can be divided into system processes and user processes.Any process used to complete the various functions of the operating system is the system process, they are the operating system itself in the running state, and the user process is all the processes started by you.

From the perspective of the operating system,A process is the smallest unit of the program's running resource allocation (mainly memory).

Thread

A machine will definitely run many programs, and the CPU is limited. How can a limited CPU run so many programs? A mechanism is needed to coordinate between programs, which is the so-called CPU scheduling.Threads are the smallest unit of CPU scheduling.

A thread must exist on a process. A thread is an entity in a process and is the basic unit of CPU scheduling and dispatching. It is a basic unit that is smaller than a process and can run independently.The thread itself basically does not own system resources, but only has essential resources (such as program counters, a set of registers and stacks) in operation, but it can share all the resources owned by the process with other threads belonging to the same process.A process can have multiple threads, and a thread must have a parent process.Threads are sometimes called lightweight processes (LWP). In the early Linux thread implementations were almost reused processes, and later their own API was independent.

The difference between thread and process:

  • Processes are basically independent of each other, while threads exist within the process and are a subset of the process.
  • The process has shared resources, such as memory space, for its internal threads to share
  • Inter-process communication is more complex
    • The process communication of the same computer is called IPC (Inter-process communication)
    • Process communication between different computers requires the network and adhere to common protocols such as HTTP
  • Thread communication is relatively simple because they share memory within the process. One example is that multiple threads can access the same shared variable
  • Threads are lighter, and thread context switching costs are generally lower than process context switching.

The relationship between the number of CPU cores and threads

As mentioned earlier, the current mainstream CPUs are multi-core, and threads are the smallest unit of CPU scheduling. At the same time, a CPU core can only run one thread, that is, the number of threads running simultaneously is 1:1, which means that the 8-core CPU can execute 8 threads code at the same time. However, after Intel introduced hyperthreading technology, the concept of a logical processor was created, forming a 1:2 relationship between the number of cores and the number of threads. Generally, the number of cores is 6 and the number of logical processors is 12.

().availableProcessors() is provided in Java, which allows us to get the current number of CPU cores. Note that this number of cores refers to the number of logical processors.

Obtaining the current number of CPU cores is very important in concurrent programming, and performance optimization under concurrent programming is often closely related to the number of CPU cores.

Context switch

Since the operating system needs to schedule between multiple processes (threads), each thread always needs to use resources in the CPU, such as CPU registers and program counters when using the CPU. This means that the operating system must ensure the normal execution of threads before and after scheduling, so there is a concept of context switching in the operating system, which isRefers to the switching of a CPU (Central Processing Unit) from one process or thread to another.

The context is the contents of the CPU registers and program counters at any point in time.
Registers are a small portion of very fast memory inside the CPU (relative to cache inside the CPU and slower RAM main memory outside the CPU), which speeds up execution of computer programs by providing quick access to common values.
A program counter is a specialized register that indicates the CPU's position in its instruction sequence and holds the address of the execution instruction or the address of the next instruction to be executed, depending on the specific system.

Context switching can be described in more detail as the kernel (i.e. the core of the operating system) performing the following activities on processes (including threads) on the CPU:

  • Pauses processing of a process and stores the CPU state (i.e., context) of the process somewhere in memory
  • Get the context of the next process from memory and restore it in the CPU's registers
  • Return to the location indicated by the program counter (ie, return to the line of code in which the process was interrupted) to resume the process.

Concurrency and parallelism

Let’s give an example. If there are 8 lanes side by side on highway A, then the largestparallelThere are 8 vehicles. When the vehicles walking side by side on this highway A are less than or equal to 8 vehicles, the vehicles can run in parallel. The same principle is true for CPUs. One CPU is equivalent to a highway A, and the number of cores or threads is equivalent to a lane that can be passed side by side; and multiple CPUs are equivalent to multiple highways side by side, and each highway has multiple lanes side by side.

When talking aboutconcurrentWhen you are in the mean time, you must add a unit of time, which means what is the concurrency in unit of time? Leaving unit time is actually meaningless.

Overall:

Concurrent:It means that applications can execute different tasks alternately. For example, executing multiple threads under a single CPU core does not mean that multiple tasks are executed at the same time. If you start two threads to execute, you will constantly switch these two tasks at a speed that you are almost impossible to detect, and have achieved the "simultaneous execution effect". In fact, it is not, it is just that the computer is too fast and we cannot detect it.This method of taking turns using CPU is generally calledconcurrent. To sum up in one sentence, it is: microsequential serialization, macroscopic parallelization.

Parallel:It means that the application can perform different tasks at the same time. For example: you can make phone calls while eating, and these two things can be performed at the same time.Under multi-core CPU, each core can schedule running threads, and the threads can be parallel.

The difference between the two: one is to execute alternately and the other is to execute simultaneously.

Understand threads in Java

Java programs are born multi-threaded

A Java program starts with the main() method and then executes according to the established code logic. It seems that no other threads are involved, but in fact, Java programs are born with a multi-threaded program because the one that executes the main() method is a thread named main.

Sample code

public class OnlyMain {
     public static void main(String[] args){
         //The management interface of Java virtual machine thread system
         ThreadMXBean threadMXBean = ();
         // There is no need to obtain synchronized monitor and synchronizer information, only thread and thread stack information
         ThreadInfo[] threadInfos =
                 (false, false);
         // traverse thread information and print only thread ID and thread name information
         for (ThreadInfo threadInfo : threadInfos) {
             ("[" + () + "] "
                     + ());
         }
     }
 }

Even if a Java program runs without threads opened by the user, there are actually many threads started by JVMs. Generally speaking, there are:

[6] Monitor Ctrl-Break // Monitor Ctrl-Break interrupt signal
[5] Attach Listener //Memory dump, thread dump, class information statistics, obtaining system attributes, etc.
[4] Signal Dispatcher // Distribute the thread that processes the signal sent to the JVM
[3] Finalizer // The thread that calls the finalize method of the object
[2] Reference Handler//Clear the thread of Reference
[1] main //main thread, user program entry
Although these threads will vary according to different JDK versions, it still proves that Java programs are born multi-threaded.

Creation and startup of threads

The threads I just saw are all system threads started by JVM. Here is how to create and start threads.

The ways to create and start threads are:

Method 1: Use the Thread class or inherit the Thread class

// Create thread object
 Thread t = new Thread() {
      public void run() {
      // Task to be performed
      }
 };
 // Start the thread
 ();

Example:

// The parameters of the constructor are to specify a name to the thread. It is recommended
 Thread t1 = new Thread("t1") {
      @Override
      // The task to be executed is implemented in the run method
      public void run() {
          ("Hello Thread");
      }
 };
 ();

Method 2: Implement the Runnable interface with Thread

Separate [thread] and [task] (code to be executed)

  • Thread stands for thread
  • Runnable tasks (code that threads want to execute)
Runnable runnable = new Runnable() {
      public void run(){
          // Task to be performed
      }
 };
 // Create thread object
 Thread t = new Thread( runnable );
 // Start the thread
 ();

Example:

// Create a task object
 Runnable task2 = new Runnable() {
      @Override
      public void run() {
          ("hello");
      }
 };
 // Parameter 1 is the task object; Parameter 2 is the thread name, recommended
 Thread t2 = new Thread(task2, "t2");
 ();

Java 8 can use lambda to simplify the code later

// Create a task object
 Runnable task2 = () -> ("hello");
 // Parameter 1 is the task object; Parameter 2 is the thread name, recommended
 Thread t2 = new Thread(task2, "t2");
 ();

summary

  • Thread is the only abstraction of threads in Java, and Runnable is just an abstraction of tasks (business logic). Thread can accept any Runnable instance and execute it.
  • Method 1 is to merge threads and tasks together, and Method 2 is to separate threads and tasks.
  • Use Runnable to separate task classes from the Thread inheritance system, making them more flexible and easier to cooperate with advanced APIs such as thread pools

Method 3: Use FutureTask with Thread

FutureTask can receive parameters of Callable type to handle cases where results are returned.

// Create a task object
 FutureTask<Integer> task3 = new FutureTask<>(() -> {
      ("hello");
      return 100;
 });
 // Parameter 1 is the task object; Parameter 2 is the thread name, recommended
 new Thread(task3, "t3").start();
 // The main thread is blocked, waiting for the result of task execution in synchronization
 Integer result = ();
 ("The result is: {}", result);

Runnable is an interface, and only one run() method is declared in it. Since the return value of the run() method is void type, no results can be returned after the task is executed.

Callable is located under the package. It is also an interface. Only one method is declared in it. However, this method is called call(), which is a generic interface. The type returned by the call() function is the V type passed in.

Future means canceling the execution results of specific Runnable or Callable tasks, querying whether they are completed, and obtaining the results. If necessary, you can get the execution result through the get method, which blocks until the task returns the result.

Because Future is just an interface, it cannot be used directly to create objects, so the following FutureTask is available.

The FutureTask class implements the RunnableFuture interface, which inherits the Runnable interface and the Future interface, andFutureTask implements the RunnableFuture interface. So it can be executed by thread as a Runnable, and can also be used as a Future to get the callable return value.

Therefore, we run Callable through a thread, but Thread does not support passing Callable instances in the constructor, so we need to wrap a Callable into Runnable through FutureTask, and then get the return value after the Callable is run through this FutureTask.

To new an instance of FutureTask, there are two ways

Interview questions: How many ways are there to create threads?

There are actually many different answers to this question, there are 2 types, 3 types, 4 types, etc. The better answer is:

Follow the comments on Thread in the Java source code:

There are two ways to create a new thread of execution

The official statement is that in Java there are two ways to create a thread for execution, one is derived from the Thread class, and the other is to implement the Runnable interface.

Of course, in essence, there is only one way to implement threads in Java, which is to create thread objects through new Thread() and start the thread by calling Thread#start.

As for the method based on the callable interface, since the object that implements the callable interface is ultimately wrapped into Runnable through FutureTask and then handed over to Thread for execution, this can actually be regarded as the same type as implementing the Runnable interface.

The thread pooling method is essentially a pooling technology, a resource reuse, and has nothing to do with newly started threads.

Therefore, I agree with the official statement that there are two ways to create a thread for execution.

run and start

The Thread class is an abstraction of thread concept in Java. It can be understood as follows: We use new Thread() to actually just create an instance of Thread, and there is no real thread hanging hook in the operating system.Only after executing the start() method can the true startup thread be realized.

From the source code of Thread, we can see that the start0() method of Thread is called, and start0() is a native method, which shows that Thread#start must be closely related to the operating system.

The start() method lets a thread enter the ready queue and wait for the CPU to be allocated. It will call the implemented run() method after being assigned to the CPU.The start() method cannot be called repeatedly. If it is called repeatedly, an exception will be thrown (note that there may be an interview question here: What will happen if the start method of a thread is called multiple times?).

The run method is where business logic is implemented. It is essentially no difference from any member method of any class. It can be executed repeatedly or called separately.

Learn Java threads in depth

The state/life cycle of the thread

Five states

This is described from the operating system level

  • [Initial State] The thread object was created only at the language level and has not been associated with the operating system thread yet
  • [Runable state] (ready state) means that the thread has been created (associated with the operating system thread) and can be executed by the CPU.
  • [Running Status] refers to the state in which the CPU time slice is running
    • When the CPU time slice is used up, it will switch from [running state] to [runable state], which will cause the thread's context switch
  • 【Blocking state】
    • If a blocking API is called, such as BIO reading and writing files, the thread will not actually use the CPU, which will cause thread context switching and enter the [blocking state]
    • When the BIO operation is completed, the blocking thread will be awakened by the operating system and converted to [runable state]
    • The difference from [runable state] is that for threads in [blocking state], as long as they are not awakened, the scheduler will not consider scheduling them.
  • [Terminated Status] means that the thread has been executed, the life cycle has ended, and will not be converted to other states

Six states

This is described from the Java API level

According to the Thread State enumeration, there are six types of thread states in Java:

  1. Initial (NEW): A new thread object is created, but the start() method has not been called yet.
  2. Run (RUNNABLE): The two states in Java threads are generally called "running".
    After the thread object is created, other threads (such as main thread) call the start() method of the object. The thread in this state is located in the runnable thread pool, waiting to be selected by the thread schedule, obtaining the CPU's usage rights, and is in the ready state. The thread in the ready state becomes running after obtaining the CPU time slice.
  3. BLOCKED: means that the thread is blocked by the lock
  4. Waiting: The thread entering this state needs to wait for other threads to make some specific actions (notification or interrupt).
  5. Timeout Waiting (TIMED_WAITING): This state is different from WAITINGG, it can return itself after the specified time.
  6. Terminate (TERMINATED): means that the thread has been executed.

Common methods for threads

Method name static Function description Notice
start() Start a new thread and run the code in the run method in the new thread The start method just lets the thread enter ready, and the code inside may not run immediately (the CPU time slice has not been allocated to it). The start method of each thread object can only be called once. If it is called multiple times, IllegalThreadStateException will appear.
run() Methods that will be called after the new thread is started If the Runnable parameter is passed when constructing a Thread object, the run method in Runnable will be called after the thread starts, otherwise no operation will be performed by default. But you can create a Thread subclass object to override the default behavior
join() Wait for the thread to run to end
join(long n) Wait for the thread to run, wait for up to n milliseconds
getId() Get the thread-long integer id id unique
getName() Get the thread name
setName(String) Modify thread name
getPriority() Get thread priority
setPriority(int) Modify thread priority Java stipulates that thread priority is an integer of 1~10. A larger priority can increase the probability that the thread is scheduled by the CPU.
getState() Get thread status In Java, thread state is represented by 6 enums, namely NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED
isInterrupted() Determine whether it is interrupted The interrupt flag will not be cleared
isAlive() Whether the thread survives (not completed yet)
interrupt() Interrupt thread If the interrupted thread is sleeping, waiting, and join, it will cause the interrupted thread to throw an InterruptedException and clear the interrupt flag; if the interrupted running thread is interrupted, an interrupt flag will be set; if the park thread is interrupted, an interrupt flag will be set.
interrupted() static Determine whether the current thread is interrupted The interrupt flag will be cleared
currentThread() static Get the currently executing thread
sleep(long n) static Let the currently executed thread sleep n milliseconds, and when sleeping, give the CPU time slice to other threads
yield() static Prompt the thread scheduler to give up the current thread's use of the CPU

There are also some methods that are not recommended. These methods are outdated and can easily destroy synchronous code blocks and cause thread deadlocks.

Method name static Function description
stop() Stop thread running
suspend() Pending (pause) thread running
resume() Recover thread running
sleep and yield
Sleep method
  • Calling sleep will cause the current thread to enter the Timed Waiting state from Running (blocking).The object lock will not be released.
  • Other threads can use the interrupt method to interrupt the thread that is sleeping, and the sleep method will throw an InterruptedException.
  • The thread after sleep is not necessarily executed immediately
  • It is recommended to use TimeUnit's sleep instead of Thread's sleep for better readability
  • sleep When the incoming parameter is 0, it is the same as yield
Thread t1 = new Thread(new Runnable() {
     @Override
     public void run() {

         try {
             (3000);
         } catch (InterruptedException e) {
             throw new RuntimeException(e);
         }
         ("Execution Complete");

     }
 },"t1");
 ();

 ("Status of thread t1:"+());

 try {
     (500);
 } catch (InterruptedException e) {
     throw new RuntimeException(e);
 }

 ("Status of thread t1:"+());

 //();

When cpu is not used for calculation, do not let while(true) idle and waste cpu. At this time, you can use yield or sleep to give up the right to use cpu to other programs.

while(true) {
     try {
         (50);
     } catch (InterruptedException e) {
         ();
     }
}
  • Similar effects can be achieved using wait or condition variables
  • The difference is that the latter two require locking and corresponding wake-up operations are required. They are generally suitable for scenarios where synchronization is to be performed.
  • sleep is suitable for scenarios without lock synchronization
yield method
  • yield will free up CPU resources, allowing the current thread to enter the Runnable state from Running, allowing threads with higher priority (at least the same) to obtain execution opportunities.The object lock will not be released;
  • Assuming that the current process only has the main thread, when yield is called, the main thread will continue to run because there is no thread with higher priority than it;
  • The specific implementation depends on the operating system's task scheduler

For example, the yield method is used in the ConcurrentHashMap#initTable method.

This is because multiple threads may initialize tables at the same time in ConcurrentHashMap, but in fact, only one thread is allowed to perform initialization operations at this time, and other threads need to be blocked or waited, but the initialization operation is actually very fast. Here, in order to avoid blocking or waiting for context switching caused by these operations, Doug Lea master asked other threads that do not perform initialization operations to simply execute the yield() method to give up the CPU execution rights, so that the threads that perform initialization operations can complete execution faster.

Thread priority

Thread priority prompts the scheduler to schedule the thread first, but it is just a prompt that the scheduler can ignore.If the CPU is busy, the threads with higher priority will get more time slices, but when the CPU is idle, the priority is almost useless.

In Java threads, priority is controlled through an integer member variable priority. The priority range is from 1 to 10. When building threads, the priority can be modified through the setPriority(int) method. The default priority is 5. The number of threads with high priority allocated time slices is greater than that of threads with low priority.

When setting thread priority, a higher priority is required for threads that frequently block (sleep or I/O operations), while a lower priority is required for threads that focus on calculations (requiring more CPU time or biased operations) to ensure that the processor is not exclusive. There will be differences in thread planning in different JVMs and operating systems, and some operating systems even ignore the setting of thread priority.

Runnable task1 = () -> {
    int count = 0;
    for (;;) {
        ("t1---->" + count++);
    }
};
Runnable task2 = () -> {
    int count = 0;
    for (;;) {
        // ();
        ("t2---->" + count++);
    }
};
Thread t1 = new Thread(task1, "t1");
Thread t2 = new Thread(task2, "t2");
// (Thread.MIN_PRIORITY);
// (Thread.MAX_PRIORITY);
();
();
Join method

The program continues to execute after the thread that calls the join method is completed. It is generally used in scenarios where the asynchronous thread can only continue to run after the result of the execution of the asynchronous thread.It is generally used in scenarios where the asynchronous thread can only continue to run after the result is executed.

Why do you need a join?

private static int count = 0;

 public static void main(String[] args) throws InterruptedException {
     ("Start execution");

     Thread t1 = new Thread(() -> {
         ("Start execution");
         (1);
         count = 5;
         ("Execution Complete");
     },"t1");
     ();
     ("Result: {}", count);
     ("Execution Complete");
 }

Output

19:30:09.614 [main] DEBUG - Start execution
19:30:09.660 [t1] DEBUG - Start execution
19:30:09.660 [main] DEBUG - The result is: 0
19:30:09.662 [main] DEBUG - Execution completed
19:30:10.673 [t1] DEBUG - Execution completed

analyze

  • Because the main thread and thread t1 are executed in parallel, it takes 1 second for the t1 thread to calculate count=5
  • The main thread must print the result of count at the beginning, so it can only print out count=0

Solution

  • Can sleep be used? Why?
  • Use join, add it after ()

Implement synchronization

From the caller's perspective, if:

  • You need to wait for the result to return before continuing to run is synchronous
  • It is asynchronous to continue running without waiting for the result to return
private static int count = 0;

 public static void main(String[] args) throws InterruptedException {
     ("Start execution");

     Thread t1 = new Thread(() -> {
         ("Start execution");
         (1);
         count = 5;
         ("Execution Complete");
     },"t1");
     ();

     //(1);

     ();

     ("Result: {}", count);
     ("Execution Complete");
  }

Output

19:36:05.192 [main] DEBUG - Start execution
19:36:05.235 [t1] DEBUG - Start execution
19:36:06.239 [t1] DEBUG - Execution completed
19:36:06.239 [main] DEBUG - Results are: 5
19:36:06.240 [main] DEBUG - Execution completed

Interview questions

There are now three threads T1, T2 and T3. How do you ensure that T2 is executed after T1 is executed and T3 is executed after T2 is executed?

It can be implemented using the join() method to add the specified thread to the current thread, and two alternate execution threads can be merged into sequential execution. For example, the join() method of thread T1 is called in thread T2, and the remaining code in thread T2 will not continue to be executed until thread T1 is executed.

Thread t1 = new Thread(new Runnable() {
     @Override
     public void run() {
         ("Thread t1 execution completed");
     }
 },"t1");
 Thread t2 = new Thread(new Runnable() {
     @Override
     public void run() {
         try {
             ();
         } catch (InterruptedException e) {
             throw new RuntimeException(e);
         }
         ("Thread t2 execution completed");
     }
 },"t2");
 Thread t3 = new Thread(new Runnable() {
     @Override
     public void run() {
         try {
             ();
         } catch (InterruptedException e) {
             throw new RuntimeException(e);
         }
         ("Thread t3 execution completed");
     }
 },"t3");

 ();
 ();
 ();
Daemon thread

By default, the Java process needs to wait for all threads to end before it ends. There is a special thread called a daemon thread. As long as other non-daemon threads are running, they will be forced to end even if the code of the daemon thread is not executed.

("Start running...");
 Thread t1 = new Thread(() -> {
     ("Start running...");
     (3);
     ("Run end...");
 }, "t1");

 // Set the t1 thread as a daemon thread
 (true);
 ();
 (1);
 ("Run end...");

Output

21:21:58.104 [main] DEBUG - Start running...
21:21:58.143 [t1] DEBUG - Start running...
21:21:59.158 [main] DEBUG - Run ends...

Application scenarios of daemon threads

Daemon threads seem useless? But in fact it has a great effect.

  • For example, in the JVM, the garbage collector uses daemon threads. If there are no user threads in a program, then there will be no garbage, and the garbage collector does not need to work.
  • Daemon threads can also be used in scenarios involving timed asynchronous execution such as heartbeat detection and event monitoring of middleware, because these are tasks that are constantly executed in the background. When the process exits, these tasks do not need to exist, and the daemon thread can automatically end its life cycle.

From these actual scenarios, it can be seen that for some background tasks, daemon threads can be used when it is not desired to prevent the end of the JVM process.

Thread termination

Thread termination naturally

Either the run execution is completed, or an unhandled exception is thrown to cause the thread to end early

Interview question: How to correctly terminate a running thread?

stop (do not use)

The stop() method has been abandoned by jdk. Calling the stop method will release the CPU resource and release the lock resource regardless of whether the logic in run() is executed or not. This can cause thread insecure, as this method can cause two problems:

  • ThreadDeath exception is immediately thrown, and any execution instruction in the run() method may throw a ThreadDeath exception.
  • All locks held by the current thread will be released, and the release of this lock is uncontrollable.

For example: Thread A's logic is to transfer money (acquire the lock, account No. 1 is reduced by 100 yuan, account No. 2 is increased by 100 yuan, and lock is released). Then, as soon as thread A has executed the account No. 1 is reduced by 100 yuan, it calls the stop() method, releasing the lock resources and releasing the CPU resources. Account No. 1 was 100 yuan short of no reason.

public class ThreadStopDemo {

     private static final Object lock = new Object();
     private static int account1 = 1000;
     private static int account2 = 0;

     public static void main(String[] args) {
         Thread threadA = new Thread(new TransferTask(),"threadA");
         ();

         // Wait for thread A to start execution
         (50);
         // Suppose that during the transfer process, we forced to stop thread A
         ();

         //Verify whether the lock is released
 // synchronized (lock){
 // ("The main thread locks successfully");
 // }
     }

     static class TransferTask implements Runnable {
         @Override
         public void run() {
             synchronized (lock) {
                 try{
                     ("Start transfer...");
                     // Account No. 1 is reduced by 100 yuan
                     account1 -= 100;
                     // 100ms sleep
                     (50);
                     // Assuming that the thread is stopped here, then the account number 2 will not be increased and the lock will be released abnormally
                     ("Account 1 balance: " + account1);
                     account2 += 100; // Account No. 2 will increase by 100 yuan
                     ("Account 2 balance: " + account2);
                     ("The transfer ends...");
                 }catch (Throwable t){
                     ("Thread A ends execution");
                     ();
                 }

             }
         }
     }
 }

Therefore, in practical applications, the stop() method must not be used to terminate the thread. So how to safely implement thread termination?

Interrupt mechanism

A safe abort is caused by other threads calling a thread A.interrupt()Methods perform interrupt operations on it. Interruption is like other threads greeting the thread, "A, you are going to interrupt", which does not mean that thread A will stop its work immediately. The same thread A can completely ignore this interrupt request.The thread responds by checking whether its interrupt flag is set to true.

Threading through methodsisInterrupted()To determine whether it has been interrupted, you can also call static methods()To determine whether the current thread has been interrupted, but () will also rewrite the interrupt identification bit to false.

If a thread is in a blocking state (such as the thread calls, etc.), if the thread finds that the interrupt is true when checking the interrupt flag, an InterruptedException will be thrown at these blocking method calls, and the interrupt flag bit of the thread will be immediately cleared after the exception is thrown, that is, reset to false.

It is not recommended to customize a cancel flag to abort the thread's run.Because the cancel flag cannot be detected quickly when there is a blocking call in the run method, the thread must return from the blocking call before checking the cancel flag. In this case, it would be better to use interrupts because,

  1. General blocking methods, such as sleep, themselves support interrupt checks.
  2. There is no difference between checking the status of the interrupt bit and checking the cancel flag bit. Using the status of the interrupt bit can also avoid declaring the cancel flag bit and reduce resource consumption.

Note: The thread in the deadlock state cannot be interrupted

Interrupting normal running threads
Interrupting the normal running thread will not clear the interrupt state

Thread t1 = new Thread(()->{
     while(true) {
         Thread current = ();
         boolean interrupted = ();
         if(interrupted) {
             ("Interrupted status: {}", interrupted);
             break;
         }
     }
 }, "t1");
 ();

 //Interrupt thread t1
 ();
 ("Interrupt status: {}",());

Output

20:45:17.596 [t1] DEBUG - Interrupt status: true
20:45:17.596 [main] DEBUG - Interrupt status: true

Threads that interrupt sleep, wait, join

These methods will cause the W-pass to enter a blocking state, and the interrupted thread will clear the interrupt state. Take sleep as an example:

Thread t1 = new Thread(()->{
     while(true) {
         try {
             (2000);
         } catch (InterruptedException e) {
             ();
         }
     }
 }, "t1");
 ();

 (100);

 //Interrupt thread t1
 ();
 ("Interrupt status: {}",());
Thread scheduling mechanism

Thread scheduling refers to the process in which the system allocates CPU usage rights to threads. There are two main scheduling methods:

  • Cooperative Threads-Scheduling
  • Preemptive Threads-Scheduling

Using a multi-threaded system with collaborative thread scheduling, the thread execution time is controlled by the thread itself. After the thread has completed its own work, it must actively notify the system to switch to another thread. The biggest advantage of using collaborative thread scheduling is that the implementation is simple. Since threads have to complete their own tasks, they will notify the system to switch threads, so there is no problem of thread synchronization, but the disadvantage is also obvious. If a thread has a problem, the program will keep blocking.

Using preemptive thread scheduling, the time for each thread to execute and whether to switch is determined by the system. In this case, the execution time of the thread is uncontrollable, so there will be no problem of "one thread causing the entire process to block".

Java thread scheduling is preemptive scheduling, why? This will be analyzed later.

In Java, () can give up the CPU execution time, but the thread itself has no way to obtain the execution time. For obtaining CPU execution time, the only way that threads can use is to set thread priority. Java sets 10 levels of program priority. When two threads are in the Ready state at the same time, the higher the priority thread, the easier it is to be selected by the system to execute.

Java threading model

There are three main ways to implement threads in any language: using kernel thread implementation (1:1 implementation), using user thread implementation (1:N implementation), and using user thread plus lightweight process hybrid implementation (N:M implementation).

Kernel thread implementation

The way to implement it using kernel threads is also called a 1:1 implementation. Kernel-Level Thread (KLT) is a thread directly supported by the operating system kernel (Kernel, hereinafter referred to as the kernel). This thread is used by the kernel to complete thread switching. The kernel schedules threads by manipulating the scheduler (Scheduler) and is responsible for mapping the thread's tasks to each processor.

Due to the support of kernel threads, each thread becomes an independent scheduling unit. Even if one of them is blocked in the system call, it will not affect the entire process's continued work. The related scheduling work does not require additional consideration and has been processed by the operating system.

Limitations: First of all, since it is implemented based on kernel threads, various thread operations, such as creation, destruction and synchronization, require system calls. The cost of system calls is relatively high, and they need to switch back and forth in user mode and kernel mode. Secondly, each language-level thread needs to be supported by a kernel thread, so it consumes a certain amount of kernel resources (such as the stack space of kernel threads), so the number of threads supported by a system is limited.

In modern operating systems, CPUs actually spend time in two completely different modes:
Kernel Mode
In kernel mode, executing code allows complete and unrestricted access to the underlying hardware. It can execute any CPU instructions and reference any memory address. Kernel mode is usually reserved for the lowest level and most trusted functionality of the operating system. Crashing in kernel mode is disastrous; they will paralyze the entire computer.
User Mode
In user mode, executing code cannot directly access hardware or reference memory. Code running in user mode must be delegated to the system API to access hardware or memory. Due to the protection provided by this isolation, crashes in user mode are always recoverable. Most of the code running on your computer will be executed in user mode.

How to implement threads in Linux system

  • LinuxThreads linux/glibc package only implemented LinuxThreads before 2.3.2
  • NPTL (Native POSIX Thread Library) is a standard thread library for POSIX (Portable Operating System Interface, portable operating system interface)
    • The POSIX standard defines a set of thread operation-related function library pthread, which is used to make it easier for programmers to operate and manage threads.
    • pthread_create is a function that creates threads in Unix-like operating systems (Unix, Linux, Mac OS X, etc.).

You can use the following command to view which thread library is used in Linux system implementation
getconf GNU_LIBPTHREAD_VERSION

User thread implementation

In a strict sense, user thread refers to a thread library that is completely built on a user space. The system kernel cannot sense the existence of user threads and how to implement them.The establishment, synchronization, destruction and scheduling of user threads are completely completed in the user mode and do not require kernel help.If the program is implemented properly, this thread does not need to switch to the kernel state, so the operation can be very fast and low-consuming, and can also support a larger number of threads. Multithreading in some high-performance databases is implemented by user threads.

The advantage of user threads is that they do not need support from the system kernel, and the disadvantage is that they do not have support from the system kernel. All thread operations need to be handled by the user program themselves.Thread creation, destruction, switching and scheduling are issues that users must consider. Moreover, since the operating system only allocates processor resources to the process, problems such as "how to deal with blocking" and "how to map threads to other processors in a multiprocessor system" will be extremely difficult, and some are even impossible to achieve. Because programs implemented using user threads are usually more complex, general applications do not tend to use user threads. The Java language used user threads, but eventually gave up. However, in recent years, many new programming languages ​​with high concurrency as the selling point generally support user threads, such as Golang.

Implementation of Java threads

Java threads were implemented by user threads on early Classic virtual machines (before JDK 1.2), but fromStarting from JDK 1.3, the threading model of mainstream commercial Java virtual machines has been generally replaced with an operating system native thread model, that is, a 1:1 threading model is adopted.

Taking HotSpot as an example, each of its Java threads is directly mapped to an operating system native thread to implement, and there is no additional indirect structure in the middle, so HotSpot itself will not interfere with thread scheduling and will give it all to the operating system to handle.

So, this is why we say that Java thread scheduling is preemptive scheduling. Moreover, thread priority in Java is implemented by mapping to native threads of the operating system, so thread scheduling ultimately depends on the operating system. The priority of threads in the operating system sometimes cannot correspond to one-to-one in Java, so Java priority is not particularly reliable.

Virtual thread

In Java 21, virtual threads (Virtual Threads), which are user-level threads. Virtual threads are a lightweight thread in Java that are designed to solve some limitations in the traditional threading model, providing more efficient concurrent processing capabilities, allowing thousands or even tens of thousands of virtual threads to be created without consuming large amounts of operating system resources.

Applicable scenarios

  • Virtual threads are suitable for performing blocking tasks, during which CPU resources can be transferred to other tasks
  • Virtual threads are not suitable for CPU-intensive computing or non-blocking tasks. Virtual threads do not run faster, but increase their size.
  • Virtual threads are lightweight resources, and they are thrown out immediately after use and do not need to be pooled.
  • Usually we do not need to use virtual threads directly. For example, Tomcat, Jetty, Netty, Spring boot, etc., they already support virtual threading.

Example

public class VTDemo {

     public static void main(String[] args) throws InterruptedException {

         //Platform thread
         ().start(new Runnable() {
             @Override
             public void run() {
                 (());
             }
         });

         //Virtual thread
         Thread vt = ().start(new Runnable() {
             @Override
             public void run() {
                 (());
             }
         });
         //Waiting for the virtual thread to complete printing before exiting the main program
         ();

     }
 }

Output

Thread[#22,Thread-0,5,main]
VirtualThread[#23]/runnable@ForkJoinPool-1-worker-1

Communication between threads

Many times, a lonely thread is not of much use. Most of the time, we work together, and we communicate between these threads or cooperate to complete a certain task. This is inseparable from communication, coordination and collaboration between threads.

Pipeline input and output stream

There is a similar pipeline mechanism in Java threads, which is used for data transmission between threads, and the transmission medium is memory.

Imagine an application scenario: generate files through Java applications, and then upload files to the cloud. Our general approach is to write files to the local disk first, and then read them from the file disk to upload them to the cloud disk. However, through the pipeline input and output stream in Java, one step can be avoided writing to the disk.

The pipeline input/output streams in Java mainly include the following 4 specific implementations: PipedOutputStream, PipedInputStream, PipedReader and PipedWriter. The first two are byte-oriented, while the last two are character-oriented.

public class Piped {
     public static void main(String[] args) throws Exception {
         PipedWriter out = new PipedWriter();
         PipedReader in = new PipedReader();
         // Connect the output stream and the input stream, otherwise an IOException will be thrown when used
         (in);

         Thread printThread = new Thread(new Print(in), "PrintThread");

         ();
         int receive = 0;
         try {
             while ((receive = ()) != -1) {
                 (receive);
             }
         } finally {
             ();
         }
     }

     static class Print implements Runnable {
         private PipedReader in;

         public Print(PipedReader in) {
              = in;
         }

         @Override
         public void run() {
             int receive = 0;
             try {
                 while ((receive = ()) != -1) {
                     ((char) receive);
                 }
             } catch (IOException ex) {
             }
         }
     }
 }

volatile, the lightest communication/synchronization mechanism

The volatile ensures visibility of different threads when operating this variable, that is, a thread modifies the value of a certain variable, and this new value is immediately visible to other threads.

public class VolatileDemo {

     private static volatile boolean stop = false;

     public static void main(String[] args) throws InterruptedException {
         Thread t1 = new Thread(new Runnable() {
             @Override
             public void run() {
                 ("Thread t1 starts execution");
                 int i=0;
                 While (!stop){
                     i++;
                 }
                 ("Breaking out of loop");
             }
         },"t1");
         ();

         (1000);
         stop = true;
         ("Main thread modification stop=true");

     }
 }

When volatile is not added, the child thread cannot sense that the main thread has modified the value of stop, so that it will not exit the loop. After volatile is added, the child thread can sense that the main thread has modified the value of ready and exit the loop quickly.

However, volatile cannot guarantee thread safety when data is written simultaneously under multiple threads. The most suitable scenario for volatile is: one thread writes and multiple threads reads.

Communication between Java threads is controlled by the Java Memory Model (JMM), which determines when a thread's write to a shared variable is visible to another thread. According to JMM's regulations,All operations of shared variables by threads must be performed in their own local memory and cannot be read directly from the main memory.JMM provides Java programs with memory visibility guarantees by controlling the interaction between the main memory and the local memory of each thread.

Join can be understood as thread merging. When one thread calls the join method of another thread, the current thread blocks and waits for the thread called the join method to be executed before it can continue to execute. Therefore, the benefits of join can ensure the execution order of threads. However, if the join method called the thread has actually lost the meaning of parallelism. Although there are multiple threads, it is essentially serial. The final implementation of join is actually based on the waiting notification mechanism.

Waiting/notification mechanism

Threads cooperate with each other to complete a certain task, such as: one thread modifies the value of an object, while another thread senses the change, and then performs corresponding operations. The whole process starts with one thread, and the final execution is another thread. The former is a producer, and the latter is a consumer. This model isolates "what" and "how". The simple method is to let the consumer thread continuously loop to check whether the variable meets the expected set unsatisfied conditions in the while loop. If the conditions are met, exit the while loop, thereby completing the consumer's work. But there are the following problems:

  • It is difficult to ensure timeliness.
  • It is difficult to reduce overhead. If the sleep time is reduced, such as sleeping for 1 millisecond, consumers can detect changes in conditions more quickly, but may consume more processor resources, causing unwarranted waste.

The waiting/notification mechanism can avoid the above problems well.

Object#wait/notify/notifyAll

The waiting notification mechanism can be implemented based on the wait and notify methods of the object. The wait method of the thread locks the object is called in a thread, and the thread will enter the waiting queue and wait until it is woken up.

  • notify(): Notify a thread waiting on the object and returns it from the wait method. The premise of return is that the thread acquires the object's lock, and the thread that does not obtain the lock re-enteres the WAITING state.
  • notifyAll(): Notify all threads waiting on the object. Use notifyAll() as much as possible and use notify() with caution, because notify() will only wake up one thread, and we cannot ensure that the thread that is awakened must be the thread we need to wake up.
  • wait(): The thread calling this method enters the WAITING state and will return only if it is waiting for notification from another thread or is interrupted. It should be noted that after calling the wait() method, the object's lock will be released.
  • wait(long): Timeout waits for a period of time. The parameter time here is milliseconds, that is, waits for up to n milliseconds. If there is no notification, the timeout will return.
  • wait (long,int): For finer granular control of timeout time, it can reach nanoseconds

The waiting party follows the following principles:

1) Acquire the lock of the object.
2) If the condition is not met, then the wait() method of the object is called and the condition must still be checked after being notified.
3) If the conditions are met, the corresponding logic will be executed.

synchronized(object) {
     while (the condition is not met) {
         Object.wait();
     }
     Corresponding logic;
 }

The notifier shall follow the following principles.
1) Obtain the lock of the object.
2) Change the conditions.
3) Notify all threads waiting on the object.

synchronized(object) {
     Change the conditions
     object.notifyAll();
 }

Example

public class WaitDemo {

     public static void main(String[] args) throws InterruptedException {
         Object locker = new Object();

         Thread t1 = new Thread(() -> {
             try {
                 ("wait start");
                 synchronized (locker) {
                     ();
                 }
                 ("wait end");
             } catch (InterruptedException e) {
                 ();
             }
         });

         ();

         // Ensure that t1 is started first, wait() is executed first
         (1000);

         Thread t2 = new Thread(() -> {
             synchronized (locker) {
                 ("notify start");
                 ();
                 ("notify end");
             }
         });

         ();

     }
 }

LockSupport#park/unpark

LockSupport is a tool used in JDK to implement thread blocking and wake-up. When a thread calls park, it waits for "permit", and when an unpark calls it, it provides "permit" to the specified thread.LockSupport is very similar to a binary semaphore (only 1 license is available). If this license has not been occupied, the current thread obtains the license and continues to execute; if the license has been occupied, the current thread blocks, waiting to obtain the license. Use it to block threads in any situation, you can specify any thread to wake up, and you don’t have to worry about the order of blocking and wake-up operations, but be careful that the effect of multiple consecutive wake-ups is the same as one wake-up.

The core AQS: AbstractQueuedSynchronizer, the Java lock and synchronizer framework, realizes thread blocking and awakening by calling() and().

public class LockSupportDemo {

     public static void main(String[] args) throws InterruptedException {

         Thread parkThread = new Thread(new Runnable() {
             @Override
             public void run() {
                 ("ParkThread starts execution");
                 // When there is no "license", the current thread suspends running; when there is "license", use this "license" and the current thread resumes running
                 ();
                 ("ParkThread execution completed");
             }
         });
         ();

         (1000);

         ("Wake up parkThread");
         // Give a "license" to thread parkThread (multiple consecutive calls to unpark will only issue one "license")
         (parkThread);
     }

 }
  • () and unpark() can be called anytime, anywhere. wait and notify can only be called in synchronized code segment
  • LockSupport allows unpark(Thread t) to be called first and then park(). If thread1 calls unpark(thread2) first, and then thread2 calls park() later, thread2 will not block. If thread 1 calls notify first, and then thread 2 calls wait, thread 2 will be blocked.
<Previous Next>