登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 安全 ›Java源码分析系列笔记-5.手写AQS

Java源码分析系列笔记-5.手写AQS

绘纵 2025-6-23 18:42:11
目录

  • 1. 需求
  • 2. 定义属性

    • 2.1. 锁的排他性
    • 2.2. 锁的状态
    • 2.3. 阻塞、唤醒线程
    • 2.4. 使用队列保存抢占锁失败的线程

  • 3. 添加加锁、解锁操作

    • 3.1. 基本流程
    • 3.2. 唤醒后继续抢占锁
    • 3.3. 加入公平锁的特性

  • 4. 最终定版
  • 5. 测试
  • 6. 流程

我们可以自己动手写一个简单的AQS，以更好地理解AQS实际的源码
1. 需求


  • 锁是排他的，一旦这个锁被某个线程占有，只要这个锁没被释放，他就不能被其他线程占有。因此需要保存当前占有锁的线程
  • 要有一个单独的字段表示当前锁的状态，是空闲还是已被占有
  • 同一时间有很多线程抢占锁，只有一个线程能成功，那其他线程怎么办呢？
    一是要让其他线程暂时停止抢占锁，即阻塞这些线程；既然有了阻塞，那必然有唤醒操作，占有锁的线程在释放锁的同时需要唤醒其他阻塞等待锁的线程
  • 另外需要用一个队列保存抢占锁失败的线程以便后续唤醒继续抢占锁，注意这个队列的操作得是线程安全的。
2. 定义属性

2.1. 锁的排他性

1.考虑用一个字段Thread lockHolder表示当前占有锁的线程，在多线程情况下为了保证这个变量改动后能及时被其他线程感知，使用volatile修饰
  1. public class MyLock
  2. {
  3.     //表示当前持有锁的线程
  4.     private volatile Thread lockHolder;
  5. }
复制代码
2.2. 锁的状态


  • 使用int state表示锁的状态，0表示空闲未被占有，1表示已被占有，对他的操作必须保证是原子的，使用CAS；同样在多线程情况下为了保证这个变量改动后能及时被其他线程感知，使用volatile修饰
  1. public class MyLock
  2. {
  3.     //表示加锁状态。记录加锁的次数
  4.     private volatile int state = 0;
  5.     //...
  6. }
复制代码
Java中使用CAS操作需要一个Unsafe类的实例，如下：
  1. public class MyLock
  2. {
  3.     //...
  4.    
  5.     private static final Unsafe unsafe = UnsafeInstance.getInstance();
  6.     //state变量的偏移地址。通过unsafe实现CAS操作的时候需要用到
  7.     private static final long stateOffset;
  9.     static
  10.     {
  11.         try
  12.         {
  13.             stateOffset = unsafe.objectFieldOffset(MyLock.class.getDeclaredField("state"));
  14.         }catch (Exception e)
  15.         {
  16.             throw new Error();
  17.         }
  18.     }
  19.     //CAS操作设置state
  20.     public final boolean compareAndSwapState(int except, int update)
  21.     {
  22.         return unsafe.compareAndSwapInt(this, stateOffset, except, update);
  23.     }
  26.     //通过反射的方式获取Unsafe实例
  27.     private static class UnsafeInstance
  28.     {
  29.         public static Unsafe getInstance()
  30.         {
  31.             try
  32.             {
  33.                 Field field = Unsafe.class.getDeclaredField("theUnsafe");
  34.                 field.setAccessible(true);
  35.                 return (Unsafe) field.get(null);
  36.             }
  37.             catch (Exception e)
  38.             {
  39.                 e.printStackTrace();
  40.             }
  41.             return null;
  42.         }
  43.     }
  44. }
复制代码
2.3. 阻塞、唤醒线程


  • 使用LockSupport.unpark阻塞线程，使用LockSupport.park唤醒线程
2.4. 使用队列保存抢占锁失败的线程


  • 线程安全的queue考虑使用ConcurrentLinkedQueue，如下
  1. public class MyLock
  2. {
  3.     //保存未获取的线程
  4.     private ConcurrentLinkedQueue<Thread> waiters = new ConcurrentLinkedQueue<>();
  5.     //...
  6. }
复制代码

  • 整理上述代码
  1. public class MyLock
  2. {
  3.     //表示加锁状态。记录加锁的次数
  4.     private volatile int state = 0;
  5.     //表示当前持有锁的线程
  6.     private volatile Thread lockHolder;
  7.     //保存未获取的线程
  8.     private ConcurrentLinkedQueue<Thread> waiters = new ConcurrentLinkedQueue<>();
  10.     //==================UNSAFE======================//
  11.     private static final Unsafe unsafe = UnsafeInstance.getInstance();
  12.     //state变量的偏移地址。通过unsafe实现CAS操作的时候需要用到
  13.     private static final long stateOffset;
  15.     static
  16.     {
  17.         try
  18.         {
  19.             stateOffset = unsafe.objectFieldOffset(MyLock.class.getDeclaredField("state"));
  20.         }catch (Exception e)
  21.         {
  22.             throw new Error();
  23.         }
  24.     }
  25.     //CAS操作设置state
  26.     public final boolean compareAndSwapState(int except, int update)
  27.     {
  28.         return unsafe.compareAndSwapInt(this, stateOffset, except, update);
  29.     }
  32.     //通过反射的方式获取Unsafe实例
  33.     private static class UnsafeInstance
  34.     {
  35.         public static Unsafe getInstance()
  36.         {
  37.             try
  38.             {
  39.                 Field field = Unsafe.class.getDeclaredField("theUnsafe");
  40.                 field.setAccessible(true);
  41.                 return (Unsafe) field.get(null);
  42.             }
  43.             catch (Exception e)
  44.             {
  45.                 e.printStackTrace();
  46.             }
  47.             return null;
  48.         }
  49.     }  
复制代码
3. 添加加锁、解锁操作

3.1. 基本流程

伪代码如下：

  • 检查锁的状态
  • 如果没有线程占用锁那么尝试抢占锁（CAS原子操作）
  • 抢占成功设置当前占有锁的线程
  • 抢占失败入队阻塞
  1. //加锁的操作
  2. public void lock()
  3. {
  5.     Thread currentThread = Thread.currentThread();
  6.     int state = getState();
  7.     //state==0表示没有加锁
  8.     if (state == 0)
  9.     {
  10.         //CAS设置成功即加锁成功
  11.         if (compareAndSwapState(0, 1))
  12.         {
  13.             setLockHolder(currentThread);//设置当前持有锁的线程
  14.             return;
  15.         }
  16.     }
  17.    
  19.     //获取锁失败，入队
  20.     waiters.add(currentThread);
  22.     //获取锁失败阻塞当前线程
  23.     LockSupport.park(currentThread);//由unpark唤醒
  24.    
  25. }
复制代码

  • 解锁
    伪代码如下：
  • 解锁的线程（即当前线程）必须是占有锁的线程
  • 是的话使用CAS解锁
  • 解锁成功则置当前占有锁的线程为空，必须唤醒阻塞的线程
  1. public void unlock()
  2. {
  3.     //加锁和解锁的线程必须相同
  4.     if (Thread.currentThread() != lockHolder)
  5.     {
  6.         throw new RuntimeException("current thread is not lockHolder");
  7.     }
  9.     //CAS设置state成功，解锁
  10.     int state = getState();
  11.     if (compareAndSwapState(state, 0))
  12.     {
  13.         setLockHolder(null);
  14.         //唤醒等待锁的所有线程
  15.         for (Thread waiter : waiters)
  16.         {
  17.            LockSupport.unpark(head);//唤醒park
  18.         }
  19.         
  20.     }
  21. }
复制代码
3.2. 唤醒后继续抢占锁

上面的加锁代码被唤醒后需要再次尝试获取锁，如果失败则阻塞；被唤醒后再次尝试获取锁.....
直到成功设置当前线程为占有锁的线程，并且把当前线程从等待队列中移除
可以看出这是一个死循环，修改加锁代码如下：
  1. public void lock()
  2. {
  3.     //加锁成功
  4.     if (acquire())
  5.     {
  6.         return;
  7.     }
  9.     //获取锁失败，入队
  10.     Thread currentThread = Thread.currentThread();
  11.     waiters.add(currentThread);
  13.     for (;;)
  14.     {
  15.         //不停的尝试获取锁
  16.         if (acquire())
  17.         {
  18.             return;
  19.         }
  20.         //获取锁失败阻塞当前线程
  21.         LockSupport.park(currentThread);//由unpark唤醒
  22.     }
  23. }
  25. private boolean acquire()
  26. {
  27.     Thread currentThread = Thread.currentThread();
  28.     int state = getState();
  29.     //state==0表示没有加锁
  30.     if (state == 0)
  31.     {
  32.         //CAS设置成功即加锁成功
  33.         if (compareAndSwapState(0, 1))
  34.         {
  35.             waiters.remove(Thread.currentThread());//拿到锁了从等待队列中移除
  36.             setLockHolder(currentThread);//设置当前持有锁的线程
  37.             return true;
  38.         }
  39.     }
  40.     return false;
  41. }
复制代码
3.3. 加入公平锁的特性

所谓公平锁就是遵循先到先得的原则。加锁失败的线程会放入队列中进而阻塞，当占有锁的线程释放锁成功后应该唤醒等待时间最长的线程（队头），让他去尝试抢占锁。
修改代码如下：
  1. public void lock()
  2. {
  3.     //加锁成功
  4.     if (acquire())
  5.     {
  6.         return;
  7.     }
  9.     //获取锁失败，入队
  10.     Thread currentThread = Thread.currentThread();
  11.     waiters.add(currentThread);
  13.     for (;;)
  14.     {
  15.         //队列中为空（没有人等待）或者是队头（我才是第一个等待）才能去获取锁这才公平
  16.         //不停的尝试获取锁
  17.         if ((waiters.isEmpty() || currentThread == waiters.peek()) && acquire())
  18.         {
  19.             return;
  20.         }
  21.         //获取锁失败阻塞当前线程
  22.         LockSupport.park(currentThread);//由unpark唤醒
  23.     }
  24. }
  26. private boolean acquire()
  27. {
  28.     Thread currentThread = Thread.currentThread();
  29.     int state = getState();
  30.     //state==0表示没有加锁
  31.     if (state == 0)
  32.     {
  33.         //队列为空（即前面没人等待锁我才去尝试加锁，这样才公平）
  34.         //又或者当前线程就是队头才去尝试加锁
  35.         //CAS设置成功即加锁成功
  36.         if ((waiters.isEmpty() || currentThread == waiters.peek()) && compareAndSwapState(0, 1))
  37.         {
  38.             waiters.poll();//拿到锁了从等待队列中移除
  39.             setLockHolder(currentThread);//设置当前持有锁的线程
  40.             return true;
  41.         }
  42.     }
  43.     return false;
  44. }
  46. public void unlock()
  47. {
  48.     //加锁和解锁的线程必须相同
  49.     if (Thread.currentThread() != lockHolder)
  50.     {
  51.         throw new RuntimeException("current thread is not lockHolder");
  52.     }
  54.     //CAS设置state成功，解锁
  55.     int state = getState();
  56.     if (compareAndSwapState(state, 0))
  57.     {
  58.         setLockHolder(null);
  59.         //唤醒等待锁的队头线程
  60.         Thread head = waiters.peek();
  61.         if (head != null)
  62.         {
  63.             LockSupport.unpark(head);//唤醒park
  64.         }
  65.     }
  66. }
复制代码
4. 最终定版
  1. public class MyLock
  2. {
  3.     //表示加锁状态。记录加锁的次数
  4.     private volatile int state = 0;
  5.     //表示当前持有锁的线程
  6.     private volatile Thread lockHolder;
  7.     //保存未获取的线程
  8.     private ConcurrentLinkedQueue<Thread> waiters = new ConcurrentLinkedQueue<>();
  10.     public void lock()
  11.     {
  12.         //加锁成功
  13.         if (acquire())
  14.         {
  15.             return;
  16.         }
  18.         //获取锁失败，入队
  19.         Thread currentThread = Thread.currentThread();
  20.         waiters.add(currentThread);
  22.         for (;;)
  23.         {
  24.             //队列中为空（没有人等待）或者是队头（我才是第一个等待）才能去获取锁这才公平
  25.             //不停的尝试获取锁
  26.             if ((waiters.isEmpty() || currentThread == waiters.peek()) && acquire())
  27.             {
  28.                 return;
  29.             }
  30.             //获取锁失败阻塞当前线程
  31.             LockSupport.park(currentThread);//由unpark唤醒
  32.         }
  33.     }
  35.     private boolean acquire()
  36.     {
  37.         Thread currentThread = Thread.currentThread();
  38.         int state = getState();
  39.         //state==0表示没有加锁
  40.         if (state == 0)
  41.         {
  42.             //队列为空（即前面没人等待锁我才去尝试加锁，这样才公平）
  43.             //又或者当前线程就是队头才去尝试加锁
  44.             //CAS设置成功即加锁成功
  45.             if ((waiters.isEmpty() || currentThread == waiters.peek()) && compareAndSwapState(0, 1))
  46.             {
  47.                 waiters.poll();//拿到锁了从等待队列中移除
  48.                 setLockHolder(currentThread);//设置当前持有锁的线程
  49.                 return true;
  50.             }
  51.         }
  52.         return false;
  53.     }
  55.     public void unlock()
  56.     {
  57.         //加锁和解锁的线程必须相同
  58.         if (Thread.currentThread() != lockHolder)
  59.         {
  60.             throw new RuntimeException("current thread is not lockHolder");
  61.         }
  63.         //CAS设置state成功，解锁
  64.         int state = getState();
  65.         if (compareAndSwapState(state, 0))
  66.         {
  67.             setLockHolder(null);
  68.             //唤醒等待锁的队头线程
  69.             Thread head = waiters.peek();
  70.             if (head != null)
  71.             {
  72.                 LockSupport.unpark(head);//唤醒park
  73.             }
  74.         }
  75.     }
  77.     public int getState()
  78.     {
  79.         return state;
  80.     }
  82.     public void setState(int state)
  83.     {
  84.         this.state = state;
  85.     }
  87.     public Thread getLockHolder()
  88.     {
  89.         return lockHolder;
  90.     }
  92.     public void setLockHolder(Thread lockHolder)
  93.     {
  94.         this.lockHolder = lockHolder;
  95.     }
  98.     //==================UNSAFE======================//
  100.     private static final Unsafe unsafe = UnsafeInstance.getInstance();
  101.     //state变量的偏移地址。通过unsafe实现CAS操作的时候需要用到
  102.     private static final long stateOffset;
  104.     static
  105.     {
  106.         try
  107.         {
  108.             stateOffset = unsafe.objectFieldOffset(MyLock.class.getDeclaredField("state"));
  109.         }catch (Exception e)
  110.         {
  111.             throw new Error();
  112.         }
  113.     }
  114.     //CAS操作设置state
  115.     public final boolean compareAndSwapState(int except, int update)
  116.     {
  117.         return unsafe.compareAndSwapInt(this, stateOffset, except, update);
  118.     }
  121.     //通过反射的方式获取Unsafe实例
  122.     private static class UnsafeInstance
  123.     {
  124.         public static Unsafe getInstance()
  125.         {
  126.             try
  127.             {
  128.                 Field field = Unsafe.class.getDeclaredField("theUnsafe");
  129.                 field.setAccessible(true);
  130.                 return (Unsafe) field.get(null);
  131.             }
  132.             catch (Exception e)
  133.             {
  134.                 e.printStackTrace();
  135.             }
  136.             return null;
  137.         }
  138.     }
  140.    
  141. }
复制代码
5. 测试
  1. private static int result = 0;
  2. public static void main(String[] args) throws InterruptedException
  3. {
  4.     final int threadCound = 10000;
  5.     final CyclicBarrier barrier = new CyclicBarrier(threadCound);
  6.     final CountDownLatch countDownLatch = new CountDownLatch(threadCound);
  7.     final MyLock lock = new MyLock();
  9.     for (int i = 0; i < threadCound; i++)
  10.     {
  11.         String name = "thread-" + i;
  12.         new Thread(()->{
  13.             try
  14.             {
  15.                 barrier.await();
  16.                 lock.lock();
  17.                 result++;
  18.                 System.out.println(Thread.currentThread() + " result: " + result);
  19.             }
  20.             catch (Exception e)
  21.             {
  22.                 e.printStackTrace();
  23.             }
  24.             finally
  25.             {
  26.                 lock.unlock();
  27.                 countDownLatch.countDown();
  28.             }
  29.         }, name).start();
  30.     }
  32.     countDownLatch.await();
  34.     System.out.println(result);
  36. }
复制代码
6. 流程

1.png


来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
绘纵
2025-6-23 18:42:11

0

粉丝关注

10

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫