Java并发编程的艺术之队列同步器

傷城~ 2022-10-18 14:56 183阅读 0赞

### 文章目录 ###

*  1 问题背景
 *  2 简介
 *  3 简要原理
 *  4 同步器与锁的区别
 *  5 同步组件中如何编写同步器
 *  6 同步器可重写的方法
 *  7 总结
 *  8 例子

# 1 问题背景 #

> 前面了解了[Java并发编程之Lock接口][Java_Lock]，今天学习队列同步器

> 笔记来自《Java并发编程的艺术》读后感

# 2 简介 #

> AbstractQueuedSynchronized，队列同步器，是构建锁或其他同步组件的基础框架。它使用一个int型成员变量表示同步状态，通过内置的FIFO队列完成访问共享资源的线程的安排工作。并发包的作者希望它称为大部分同步需求的基础。

# 3 简要原理 #

> 使用同步器的方式是用子类继承同步器并实现它的抽象方法。子类被推荐定义为自定义同步组件中的静态内部类。前面提到同步器用一个int变量表示同步状态，因此同步器围绕着管理这个同步状态提供了3个方法：`getState()、setState(int newState)、compareAndSetState(int expect, int update)`。

# 4 同步器与锁的区别 #

> 在锁（锁也可以称为同步组件，自定义的锁可以称为自定义同步组件）中聚合同步器，利用同步器实现锁的语义。

> 锁：锁是面向使用者的，定义了使用者与锁的交互接口，隐藏了实现细节  
> 同步器：同步器是面向锁的实现者，它简化了锁的实现方式，**屏蔽了** 同步状态管理、线程的排队、等待与唤醒等**底层操作**。

> 总结：**锁和同步器隔离使用者和实现者所需关注的领域**。

# 5 同步组件中如何编写同步器 #

> 前面简要原理粗略讲了同步器的使用方式，下面从同步组件的角度全局阐述在同步组件中如何编写同步器

> 同步器是基于模板方法设计模式设计的。因此使用同步器的方式和使用模板方法设计模式大同小异。使用者需继承同步器并重写指定的方法。同步器组合在自定义同步组件的实现中。使用者调用同步器提供的模板方法，而模板方法调用使用者重写的方法。重写同步器的方法时，需要使用以下的3个方法访问或修改同步状态：`getState()、setState(int newState)、compareAndSetState(int expect, int update)`。

> 大致框架如下伪代码所示：

public class 队列同步器 { 
        // 待重写的方法之一
        protected boolean tryAcquire(int arg) { 
            throw new UnsupportedOperationException();
        }
        
        // 待重写的方法之一
        protected boolean tryRelease(int arg) { 
            throw new UnsupportedOperationException();
        }
    
        // 模板方法之一
        public final void acquire(int arg) { 
            if (!tryAcquire(arg) &&
                acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
                selfInterrupt();
        }
    }

> 如上所示，模板方法之一`acquire()`调用待重写的方法之一`tryAcquire()`

public 自定义同步组件的实现 { 
    
        public static class 同步器的实现 extends 队列同步器 { 
            // 重写方法
            @Override
            protected boolean tryAcquire(int arg) { 
            	xxx;
            }
            // 重写方法
            @Override
    	    protected boolean tryRelease(int arg) { 
    	        xxx;
    	    }
    
    		// 模板方法之一
    	    public final void acquire(int arg) { 
    	        if (!tryAcquire(arg) &&
    	            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
    	            selfInterrupt();
    	    }
        }
    
    	private final 同步器的实现 sync = new 同步器的实现();
    	
    	// 使用者调用该方法
    	public void lock() {  sync.acquire(1); }
    }

# 6 同步器可重写的方法 #

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>protected boolean tryAcquire(int arg)</td> 
   <td>独占式获取同步状态，实现该方法需要查询同步状态并判断是否符合预期，然后再进行CAS设置同步状态</td> 
  </tr> 
  <tr> 
   <td>protected boolean tryRelease(int arg)</td> 
   <td>独占式释放同步状态，等待获取同步状态的线程将有机会获取同步状态</td> 
  </tr> 
  <tr> 
   <td>protected int tryAcquireShared(int arg)</td> 
   <td>共享式获取同步状态，返回大于等于0的值，表示获取成功；反之获取失败</td> 
  </tr> 
  <tr> 
   <td>protected boolean tryReleaseShared(int arg)</td> 
   <td>共享式释放同步状态</td> 
  </tr> 
  <tr> 
   <td>protected boolean isHeldExclusively()</td> 
   <td>当前同步器是否在独占模式下被线程占用，一般地，该方法表示是否被当前线程独占</td> 
  </tr> 
 </tbody> 
</table>

# 7 总结 #

> 自定义同步组件中聚合同步器的实现。同步器的实现类推荐被定义为同步组件中的静态内部类。同步器的实现类重写指定的方法，同步器的模板方法调用重写的方法。同步组件中定义与使用者交互的方法，该方法调用模板方法。

> 同步器的模板方法基本上分为3类：独占式获取与释放同步状态、共享式获取与释放同步状态、查询同步队列中的等待线程情况。

> 自定义同步组件将使用同步器提供的模板方法实现自己的同步语义。

# 8 例子 #

> 实现一个独占锁。

public class Mutex { 
    
        public static class Sync extends AbstractQueuedSynchronizer { 
            // 当状态为0时获取锁
            @Override
            protected boolean tryAcquire(int arg) { 
                if (compareAndSetState(0, 1)) { 
                    setExclusiveOwnerThread(Thread.currentThread());
                    return true;
                }
                return false;
            }
    
            // 释放锁，设置状态为0
            @Override
            protected boolean tryRelease(int arg) { 
                 if (getState() == 0) { 
                     throw new IllegalMonitorStateException();
                 }
                 setExclusiveOwnerThread(null);
                 setState(0);
                return true;
            }
    
            // 是否处于占用状态
            @Override
            protected boolean isHeldExclusively() { 
                return getState() == 1;
            }
        }
    
        /** * 将操作代理到Sync上 */
        private final Sync sync = new Sync();
    
         public void lock() { 
             sync.acquire(1);
         }
    
         public void release() { 
             sync.release(1);
         }
    }

[Java_Lock]: https://blog.csdn.net/qq_40634846/article/details/118568399