Common lock strategies

1 Optimism lock vs Pessimistic locking

2 Read-write lock vs Common mutex

Between threads , There is no thread safety problem between data readers , But data writers need to be mutually exclusive with each other and with readers . If the same lock is used in both scenarios , There will be great performance loss . Therefore, read-write locks are generated .

A thread's access to data , There are two main operations : Reading data and Writing data .
Both threads just read one data , There is no thread safety issue at this time . Read directly and concurrently .
Both threads have to write a data , There are thread safety issues .
One thread reads and another thread writes , There are also thread safety issues

Between read lock and read lock , Not mutually exclusive .
Between write lock and write lock , Mutually exclusive .
Between read lock and write lock , Mutually exclusive .
The read-write lock is especially suitable for “ Frequent reading , Write less frequently ” In the scene . ( Such scenes are actually very widespread )

3 Hang wait lock vs spinlocks

4 Heavyweight lock vs Lightweight lock

5 Fair lock vs Not fair lock

6 Reentrant lock vs Do not reenter the lock

synchronized The above summary

CAS

like :

like :

ABA problem

ABA The solution to the problem

synchronized Lock optimization mechanism in ( Several typical optimization methods )

Lock expansion / Lock escalation

It's like :

Lock coarsening

Lock elimination

Callable Interface

Callable It's a interface . It is equivalent to encapsulating a thread “ Return value ”. It is convenient for the program to calculate the result by means of multithreading .

Use Callable Interface

package Callable Interface ;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/** * @author: fs * @date: 2022/4/20 20:53 * @Description: */
public class Demo {
    
    public static void main(String[] args){
    
        // adopt Callable To describe such a task 
        Callable<Integer> callable=new Callable<Integer>() {
    
            @Override
            public Integer call() throws Exception {
    
                int sum=0;
                for (int i = 0; i <= 1000; i++) {
    
                    sum += i;
                }
                return sum;
            }
        };

        // In order for the thread to execute callable  The task , The use of construction methods alone is not enough , You also need an auxiliary class .
        FutureTask<Integer> task=new FutureTask(callable);
        // Create a thread to complete the calculation here 
        Thread t=new Thread(task);

        t.start();
        // Bring your own spicy hot with a small ticket 、
        // What if the task of the thread is not finished ,get_ It will block .
        //  It's blocked until , Mission accomplished , The result is calculated ~~

        try {
    
            System.out.println(task.get());
        } catch (InterruptedException e) {
    
            e.printStackTrace();
        } catch (ExecutionException e) {
    
            e.printStackTrace();
        }

    }
}

Description of the above code

JUC(java.util.concurrent) Common classes for

ReentrantLock

Reentrant mutexes . and synchronized Similar location , Are used to achieve mutually exclusive effects , Ensure thread safety .
ReentrantLock It's also a re-entry lock . “Reentrant” The original meaning of this word is “ Reentrant ”
ReentrantLock Usage of :
lock(): Lock , If you can't get the lock, you'll die and wait .
trylock( Timeout time ): Lock , If the lock cannot be acquired , Give up locking after waiting for a certain time .
unlock(): Unlock

CountDownLatch

Multithreading environment uses ArrayList

Multithreaded environments use hash tables

like :

Solution

summary