Multi thread learning notes -1.cas

Muke multi thread learning tutorial

1. What is? CAS

1.1 brief introduction

• Essentially, CPU Special instructions for
  • Because it's an instruction , from CPU It guarantees atomicity , So it's thread safe
    
    

1.2. CAS The equivalent code of （ semantics ）

/** *  describe ：  simulation CAS operation , Equivalent code  */
public class SimulatedCAS {
    
    private volatile int value;
    //  The whole method corresponds to an instruction ==CAS Instructions 
    public synchronized int compareAndSwap(int expectedValue, int newValue) {
    
        int oldValue = value;
        if (oldValue == expectedValue) {
    
            value = newValue;
        }
        return oldValue;
    }
}

1.3 Case presentation - Simulate thread contention

• Create two threads , Perform simulation at the same time CAS operation

public class TwoThreadsCompetition implements Runnable {
    

    private volatile int value;

    public synchronized int compareAndSwap(int expectedValue, int newValue) {
    
        int oldValue = value;
        if (oldValue == expectedValue) {
    
            value = newValue;
        }
        return oldValue;
    }
    //  Simulate two threads competing 
    public static void main(String[] args) throws InterruptedException {
    
        TwoThreadsCompetition r = new TwoThreadsCompetition();
        r.value = 0;//  The default is expectation 0
        Thread t1 = new Thread(r,"Thread 1");
        Thread t2 = new Thread(r,"Thread 2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(r.value);
    }

    @Override
    public void run() {
    
        compareAndSwap(0, 1);
    }
}

• Thread debugging - Enable multithreading debugging
  
• Execute first 1 Threads - take value Make changes
  
• Re execution 2 Threads , It is found that the expected value is different from the existing value , Update failed
  

3. Application scenarios

3.1 Optimism lock

3.2 Concurrent container

• for example ConcurrentHashMap
  

3.3 Atomic classes

With AtomicInteger For example , analysis CAS Realization principle

volatile modification

• Ensure the visibility of variables

Unsafe class

Unsafe Class compareAndSwapInt

summary

5. Shortcomings and summary

5.1 ABA problem

• If only the change of value is considered , There may be A Changed by another thread to B, Finally, it was changed to A, such , The current thread will mistakenly think that there is no version change , In this way, some operations in the subsequent sequence will have hidden dangers
• The solution strategy is ： Copy database , Add a version number to each version for maintenance , Each comparison does not just look at the value , Also compare whether the version number has changed

5.2 Spin time is too long

• If the competition is fierce , The lock can't be reached , Will spin all the time , Will consume CPU