JDK提供的原子类和AbstractQueuedSynchronizer（AQS）

原创

zhangyongshizhi 2022-10-19 20:14:28 博主文章分类：Java线程 ©著作权

文章标签 ide java 公平锁 文章分类 运维

©著作权归作者所有：来自51CTO博客作者zhangyongshizhi的原创作品，请联系作者获取转载授权，否则将追究法律责任

大致分成：

1.原子更新基本类型

2.原子更新数组

3.原子更新抽象类型

4.原子更新字段

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicIntegerArray;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
import java.util.concurrent.atomic.AtomicReference;

public class Sequence {
  private AtomicInteger value=new AtomicInteger(0);
  private int [] s={2,1,4,6}; 
  AtomicIntegerArray array=new AtomicIntegerArray(s);
  
  AtomicReference<User> use=new AtomicReference<>();
  
  AtomicIntegerFieldUpdater<User> old=
      AtomicIntegerFieldUpdater.newUpdater(User.class, 
          "old");

  public int getNext(){
    User user=new User();
    System.out.println(old.getAndIncrement(user));
    System.out.println(old.getAndIncrement(user));
    System.out.println(old.getAndIncrement(user));
    old.getAndIncrement(user);
    array.getAndIncrement(2);
    array.getAndAdd(2, 10);
    return value.getAndIncrement();//自增value++
    //value.incrementAndGet();//++value
  }
  public static void main(String[] args) {
    Sequence s=new Sequence();
    new Thread(new Runnable() {
      
      @Override
      public void run() {
        System.out.println(Thread.currentThread().getName()+""
      +s.getNext());
        try {
          Thread.sleep(100);
        } catch (InterruptedException e) {
          
          e.printStackTrace();
        }
      }
      
    }).start();
//      new Thread(new Runnable() {
//      
//      @Override
//      public void run() {
//        System.out.println(Thread.currentThread().getName()+""
//      +s.getNext());
//        try {
//          Thread.sleep(100);
//        } catch (InterruptedException e) {
//          
//          e.printStackTrace();
//        }
//      }
//      
//    }).start();
  }
}

　　Lock接口：

Lock需要显示的获取和释放锁，繁琐，但是能让代码更灵活，随时，获取和释放锁

Synchronized:不需要显示的获取和释放锁　，简单

使用lock可以方便的实现公平性

非阻塞的获取锁

能被中断的获取锁

超时获取锁

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Sequence {
  private int value;
  Lock lock=new ReentrantLock();//所有的线程公用一把锁
  public int getNext() {
    lock.lock();
    int a= value++;
    lock.unlock();
        return a;
  }

  public static void main(String[] args) {
    Sequence s = new Sequence();
    new Thread(new Runnable() {

      @Override
      public void run() {
        while (true) {
          System.out.println(Thread.currentThread().getName() + "" + s.getNext());
          try {
            Thread.sleep(100);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
      }

    }).start();

    new Thread(new Runnable() {

      @Override
      public void run() {
        while (true) {
          System.out.println(Thread.currentThread().getName() + "" + s.getNext());
          try {
            Thread.sleep(100);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
      }

    }).start();

    new Thread(new Runnable() {

      @Override
      public void run() {
        while (true) {
          System.out.println(Thread.currentThread().getName() + "" + s.getNext());
          try {
            Thread.sleep(100);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
      }

    }).start();
  }
}

　　实现一个锁的重入：

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

public class MyLock implements Lock{

  private boolean isLocked=false; 
  private Thread lockBy=null;
  private int lockCount=0;
  @Override
  public synchronized void lock() {
    //Thread.activeCount()
    Thread currentThread=Thread.currentThread();//获取当前线程
    while(isLocked &¤tThread!=lockBy){ //不相等，等待
      try {
        wait();
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      isLocked=true;
      lockBy=currentThread;
      lockCount++;
    }
  }

  @Override
  public synchronized void unlock() {
    if(lockBy==Thread.currentThread()){
      lockCount--;
      if(lockCount==0){
        notify();
        isLocked=false;
      }
    }
  }
  @Override
  public void lockInterruptibly() throws InterruptedException {
    // TODO Auto-generated method stub
    
  }

  @Override
  public Condition newCondition() {
    // TODO Auto-generated method stub
    return null;
  }

  @Override
  public boolean tryLock() {
    // TODO Auto-generated method stub
    return false;
  }

  @Override
  public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
    // TODO Auto-generated method stub
    return false;
  }
}

public class Demo {
   MyLock lock=new MyLock();  
   public void a(){
      lock.lock();
      System.out.println("a");
      b();
      lock.unlock();
   }
   public void b(){
      lock.lock();
      System.out.println("b");
      lock.unlock();
   }
   public static void main(String[] args) {
     Demo demo=new Demo();
     new Thread(new Runnable() {
      @Override
      public void run() {
         demo.a();
      }
   }).start();
   }
}

　　AbstractQueuedSynchronizer（AQS）

公平锁：

公平锁是对锁的获取而言，如果一个锁是公平的，那么锁的获取顺序就是应该符合请求的绝对时间顺序。

import java.util.ArrayList;
import java.util.List;

public class FairLock {
  private boolean isLocked=false;
  private Thread lockingThread=null;
  private List<QueueObject> waitingThreads=new ArrayList<QueueObject>();
  
  private void lock() throws InterruptedException{
    QueueObject queueObject=new QueueObject();
    synchronized (this) {
        waitingThreads.add(queueObject);
    }
    try {
      queueObject.doWait();
    } catch (InterruptedException e) {
      synchronized (this) {
        waitingThreads.remove(queueObject);
      }
      throw e;
    }
  }

  public synchronized void unlock(){
    if(this.lockingThread!=Thread.currentThread()){
      throw new IllegalMonitorStateException("Calling thread has not locked this lock");
    }
    isLocked=false;
    lockingThread=null;
    if(waitingThreads.size()>0){
      waitingThreads.get(0).doNotify();
    }
  }
}

public class QueueObject {
  private boolean isNotified=false;
  public synchronized void doWait() throws InterruptedException{
    while(!isNotified){
      this.wait();
    }
    this.isNotified=false;
  }
  public synchronized void doNotify(){
    this.isNotified=true;
    this.notify();
  }
  public boolean equals(Object o){
    return this==o;
  }
}

　　aqs实现锁重入：

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

public class MyLock2 implements Lock{
  private Helper helper=new Helper();
  private class Helper extends AbstractQueuedSynchronizer{
     @Override
     protected boolean tryAcquire(int arg){
       //如果第一个线程进来，可以拿到锁，可以返回true
       
       //第二个线程进来，拿不到锁，返回false.有种特列，
       //如果当前进来的线程的和当前保存的线程是同一个线程，则可以拿到锁，但是有代价。要更新状态的值
       
       //如何判断是第一个线程进来，还是其他线程
       int state=getState();
       Thread t=Thread.currentThread();
       if(state==0){
         if(compareAndSetState(0, arg)){
           setExclusiveOwnerThread(Thread.currentThread());
           return true;
         }
       }else if(getExclusiveOwnerThread()==t){
      setState(state+1);
      return true;
    }
       
       return false;
     }
     @Override
     protected boolean tryRelease(int arg){
       //锁的获取和释放肯定是一一对应的，那么调用此方法的线程一定是当前线程
       if(Thread.currentThread()!=getExclusiveOwnerThread()){
         throw new RuntimeException();
       }
       int state=getState()-arg;
       boolean flag=false;
       if(getState()==0){
         setExclusiveOwnerThread(null);
         flag=true;
       }
       setState(state);
       return flag;
     }
     Condition newCondition(){
       return new ConditionObject();
     }
  }
  
  @Override
  public void lock() {
    helper.acquire(1);
  }

  @Override
  public void lockInterruptibly() throws InterruptedException {
    helper.acquireInterruptibly(1);
  }

  @Override
  public Condition newCondition() {
    return helper.newCondition(); 
  }

  @Override
  public boolean tryLock() {
    return helper.tryAcquire(1);
  }

  @Override
  public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
    return helper.tryAcquireNanos(1, unit.toNanos(time));
  }

  @Override
  public void unlock() {
    helper.release(1);
  }

}

public class Main {
  private int value;
  private MyLock2 lock=new MyLock2();
  public int next(){
    lock.lock();
    try {
      Thread.sleep(300);
      return value++;
    } catch (InterruptedException e) {
      throw new RuntimeException();
    }finally {
      lock.unlock();
    }
  }
  public void a(){
    lock.lock();
    System.out.println("a");
    b();
    lock.unlock();
  }
  public void b(){
    lock.lock();
    System.out.println("b");
    lock.unlock();
  }
  public static void main(String[] args) {
    Main m=new Main();
    new Thread(new Runnable() {
      @Override
      public void run() {
        m.a();
      }
    }).start();
//    new Thread(new Runnable() {
//      @Override
//      public void run() {
//        while(true){
//          System.out.println(Thread.currentThread().getId()
//              +""+ m.next());
//        }
//      }
//    }).start();
//    new Thread(new Runnable() {
//      @Override
//      public void run() {
//        while(true){
//          System.out.println(Thread.currentThread().getId()
//              +""+ m.next());
//        }
//      }
//    }).start();
  }

}