Let's talk about the three core issues of concurrent programming.

There are three core issues in concurrent programming ：

• Division of labor

• Synchronization problem

• The problem of mutual exclusion

Concurrent programming is not an isolated technology , Nor is it a technology that is divorced from the real life scene .

contrary , Concurrent programming is a comprehensive technology , meanwhile , It is closely related to the scenes in real life .

This paper gives a brief introduction to these three core issues .

Division of labor

About division of labor , The more official explanation is ： A relatively large task is split into multiple tasks of appropriate size , These tasks of the right size are given to the right thread to execute .

The division of labor emphasizes the performance of execution .

Analogy with real cases

The division of labor can be understood by analogy with the scenes in real life , for example , If you are a listed company CEO, that , Your main job is to plan the strategic direction of the company and manage the company well . In terms of how to manage the company , There are many tasks involved .

here , It can be seen as a big task to manage the company well , This big task can include personnel recruitment and management 、 The product design 、 product development 、 Product operation 、 Product promotion 、 Tax statistics and calculation, etc . If these tasks are assigned to CEO Do it alone , So estimate CEO You will get tired and lie down .CEO One person finishes all the daily work of the company, as shown in the figure 1 Shown .

chart 1 CEO One person finishes all the daily work of the company

Pictured 1 Shown , company CEO It is a very undesirable way for one person to finish all the daily work of the company , This will make the company unable to operate normally , So how to do it ？

There is a good way to break down the daily work of the company , Hand over the recruitment and management of personnel to the human resources department , Will produce The product design work is handed over to the design department , Hand over the product development work to the R & D department , Hand over the product operation and product promotion to Yun Sales and marketing department , Hand over the company's tax statistics and calculation to the finance department .

such ,CEO The focus of our work has become to keep abreast of the work of each department , Coordinate and coordinate the work of all departments , And think about how to plan the company's strategy .

The daily work of the company after division of labor is shown in the figure 2 Shown .

chart 2 The daily work of the company after division of labor

Divide the daily work of the company , You can find , The work among departments can be carried out in parallel . for example , When the human resources department conducts employee performance appraisal , The design department and R & D department are designing and developing the company's products , meanwhile , The company's operators are communicating with designers and R & D personnel on how to better improve the company's products , The marketing department is making greater efforts to publicize and promote the company's products , The finance department is counting and calculating various financial statements of the company . Everything is so orderly .

therefore , in real life , It is very important to arrange the right people to do the right things . Mapping to the realm of concurrent programming The same is true .

Division of labor in concurrent programming

In concurrent programming , It is also necessary to split a large task into several smaller tasks , And give these small tasks to Different threads execute , Pictured 3 Shown .

chart 3 Split a large task into several smaller tasks

In concurrent programming , Because multiple threads can execute concurrently , Therefore, it can improve the execution efficiency of the task to a certain extent .

In the field of concurrent programming , One more thing to note is ： Assign tasks to appropriate threads to do . in other words , Don't leave the task performed by the main thread to the child thread , otherwise , There is no way to solve the problem .

It's like a company's CEO It is the same as handing over the planning of the company's future work to a product developer , Not only can not plan the future of the company , It can even run counter to the company's values .

stay Java in , Thread pool 、Fork/Join The framework and Future Interfaces are all ways to realize division of labor . In multithreaded design pattern ,Guarded Suspension Pattern 、Thread-Per-Message Pattern 、 producer — Consumer model 、 Two stage termination mode 、Worker-Thread Patterns and Balking Patterns are the implementation of division of labor .

Synchronization problem

In concurrent programming , Synchronization refers to a thread executing its own tasks , How to notify other threads to continue the task , It can also be understood as collaboration between threads , Synchronization emphasizes the performance of execution .

Analogy with real cases

You can find cases similar to the synchronization problem in concurrent programming in real life .

for example , Zhang San 、 Li Si and Wang Wu jointly developed a project , Zhang San is a front-end developer , He needs to wait for Lisi's development interface task to complete before he starts rendering page , Li Si needs to wait for Wang Wu's service development to complete before writing the interface .

in other words , There is a dependency between tasks , When the task ahead is finished , To perform the following tasks .

in real life , This synchronization of tasks , It is more realized by the exchange and communication between people . for example , Wang Wu's service development task has been completed , Tell Li Si , Li Si immediately began to implement the task of developing interfaces . After Li Si's interface development is completed , Tell Zhangsan again , Zhang San immediately calls the interface developed by Li Si to render the returned data to the page . in real life The synchronization model of is shown in the figure 4 Shown .

chart 4 Synchronous model in real life

From the figure 4 It can be seen that , in real life , Zhang San 、 There is a dependency between the tasks of Li Si and Wang Wu , Zhang San's task of rendering the page depends on Li Si's task of developing the interface , Li Si's task of developing interfaces depends on Wang Wu's task of developing services .

Synchronization in concurrent programming

In the field of concurrent programming , The synchronization mechanism refers to the task execution of a thread , How to notify other threads to continue executing tasks , The simple model of concurrent programming synchronization is shown in the figure 5 Shown .

chart 5 A simple model of concurrent programming synchronization

From the figure 5 It can be seen that , In concurrent programming , Tasks between multiple threads are dependent .

Threads A Need to block the waiting thread B The task cannot be executed until the task is completed , Threads B Need to block the waiting thread C The task cannot be executed until the task is completed . Threads C After executing the task, the thread will wake up B Go ahead with the task , Threads B After executing the task, the thread will wake up A Go ahead with the task .

This synchronization mechanism between threads , You can use the following if Pseudo code to represent .

if( Dependent task completion ){
   Perform the current task  
}else{
   Continue to wait for the execution of dependent tasks  
} 

Above if What pseudo code means is ： When the dependent task is completed , Perform the current task , otherwise , Continue to wait Depend on the execution of the task .

In the real world , It is often necessary to judge whether the dependent task has been completed in time , It can be used at this time while Follow Ring instead of if Judge , while The pseudocode is as follows .

while( Dependent tasks are not completed ){
   Continue to wait for the execution of dependent tasks  
}  
 Perform the current task 

Above while What pseudo code means is ： If the dependent task is not completed , Then wait all the time , Until the dependent task is completed , To execute the current task .

In the field of concurrent programming , The synchronization mechanism has a very classic model —— producer — Consumer model . If the queue is full , Then the producer thread needs to wait , If the queue is not satisfied , You need to wake up the producer thread ; If the queue is empty , Then the consumer thread needs to wait , If the queue is not empty , You need to wake up consumers .

The following pseudocode can be used to represent the producer — Consumer model .

Producer pseudocode

while( The queue is full ){
   Producer thread waiting  
}  
 Wake up producers 

Consumer pseudocode

while( The queue is empty ){
   Consumer waiting  
}  
 Wake up consumers 

stay Java in ,Semaphore、Lock、synchronized.、CountDownLatch、CyclicBarrier、Exchanger and Phaser And other tool classes or frameworks have implemented the synchronization mechanism .

The problem of mutual exclusion

In concurrent programming , The mutual exclusion problem generally refers to that only one thread is allowed to access the shared resources in the critical area at the same time . Mutex emphasizes the correctness of multiple threads executing tasks .

Analogy with real cases

A typical scenario of mutual exclusion problem in reality is that multiple vehicles at an intersection merge into a one-way street , Pictured 6 Shown .

chart 6 Many cars at the intersection merge into a one-way street

From the picture 6 It can be seen that , When multiple vehicles cross an intersection and join the same one-way street , As the entrance of the one-way street can only accommodate one vehicle , So other vehicles need to wait for the vehicles in front to pass through the one-way street entrance , Then pass through the entrance of one-way street orderly . This is the mutually exclusive scene in real life .

Mutual exclusion in concurrent programming

In concurrent programming , Division and synchronization emphasize the performance of tasks , Mutual exclusion emphasizes the correctness of task execution , That is, thread safety .

If in concurrent programming , Multiple threads enter the critical area to access the same shared variable at the same time , Thread safety problems may arise , This is determined by the atomicity of threads 、 Visibility and order issues .

And solve atomicity in concurrent programming 、 The core solution to the visibility and ordering problem is the mutual exclusion between threads .

for example , have access to JVM Provided in synchronized Lock to realize mutual exclusion between multiple threads , Use synchronized The pseudo code of the lock is as follows .

Modification methods

public synchronized void methodName(){
   // Omit the specific method  
}

Decorated code block

public void methodName(){
   synchronized(this){
      // Omit the specific method 
   }
} 

public void methodName(){
   synchronized(obj){
      // Omit the specific method   
   }  
} 

public void methodName(){
   synchronized(ClassName.class){
      // Omit the specific method 
   }  
}

Modified static method

public synchronized static void staticMethodName(){
   // Omit the specific method  
}

except synchronized lock ,Java It also provides ThreadLocal、CAS、 Atomic classes and with CopyOnWrite The first concurrent container class 、Lock Lock and read / Write locks, etc. , They all implement the mutual exclusion mechanism of threads .