[JUC learning road day 8] condition

StampedLock

Implement the locking mechanism according to the timestamp , Used to solve the read-write lock when the number of read-write resource threads is unbalanced , The unfair situation of resource preemption . There are three lock processing modes supported in this class , Write lock respectively 、 Pessimistic locking 、 Optimism lock . Every complete StampedLock It is composed of version and mode , When acquiring the relevant lock, a digital tag stamp will be returned , Used to control the state of the lock , And the mark stamp is used to realize the unlocking processing .

Condition

When I first learned multithreading technology , Will use Object Class wait、notify Method to wait and wake up , Then in the traditional Thread Among classes , It also provides pause and resume functions （ This function has been abolished ）,Condition It achieves the same function .

Condition It's an interface , Can rely on Lock Interface to implement .public Condition newCondition()

1. stay ReentranLock It can be found in the class that this method is composed of sync.newCondition() Method called ;

2. sync The object is AQS Implementation subclass , So the final newcondition() The way is by AQS To complete ;

   public Condition newCondition() {
         
       return sync.newCondition();
   }
   

3. sync Implemented in the new ConditionObject(), This is a AQS The inner class of , The implementation is as follows ：

   public class ConditionObject implements Condition, java.io.Serializable {
         
       private static final long serialVersionUID = 1173984872572414699L;
       private transient ConditionNode firstWaiter;
       private transient ConditionNode lastWaiter;
       public ConditionObject() {
          }
   
   

   After analysis, we can find , stay Condition Internally, all waiting operation threads are actually saved in the queue , Because we can rely on AQS Provided CLH Mechanism to realize thread control .

Condition Realize thread waiting and wakeup ：

package juc.condition2;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/** * @author birdy * @date 2022/6/25 10:58 AM */
public class Main {
    
    public static String msg = null;
    public static ReentrantLock reentrantLock = new ReentrantLock();
    public static Condition condition = reentrantLock.newCondition();
    public static void main(String[] args) {
    
        try {
    
            reentrantLock.lock();
            new Thread(() -> {
    
                try {
    
                    reentrantLock.lock();
                    TimeUnit.MILLISECONDS.sleep(2);
                    System.out.println("sub thread complete!");
                    msg = "hello!";
                    condition.signal();
                } catch (Exception ex) {
    
                    ex.printStackTrace();
                } finally {
    
                    reentrantLock.unlock();
                }
            }).start();
            condition.await();
        } catch (Exception e) {
    
            e.printStackTrace();
        } finally {
    
            reentrantLock.unlock();
            System.out.println("unlocked");
        }
        System.out.println(msg);
    }
}

LockSupport A little