前面说了这个多,我们可以自己尝试实现一个同步器,我们可以简单的参考一下ReentrantLock这个类的实现方式,我们就简单的实现一个不可重入的独占锁吧!
一.简单分析ReentrantLock的结构
下图所示,直接实现了Lock这个接口,然后定义了一个内部类继承AQS,暂时不考虑公平锁和非公平锁,前面说AQS的时候说过,留有tryAcquire,tryRelease这两个方法在具体子类中根据实际情况实现的,可想而知这个内部类主要的是实现tryAcquire,tryRelease;
我们看看Lock接口,这些方法就是我们需要实现的;主要是获取锁和释放锁,还有一个实现条件变量的方法;
这里注意一下,有的方法后面带有Interruptibly这种字样的,这个方法表示如果该线程假如在阻塞队列中挂起了,这时有另外一个线程去调用这个线程的中断方法,那么就会立即抛出异常;不带Interruptibly就是不会对中断进行响应!
我们如果看看ReentrantLock里面的lock,unlock等方法的实现,可以知道都是调用的Sync的方法,也就是AQS中的一些方法,所以在这里我们可以把Sync看做是一个工具类,我们主要是使用Lock接口的这些方法来实现我们锁的功能;
二.创建一个锁MyNonLock
我们只需要创建一个类实现Lock类,然后这个类中有一个内部类MySync继承AQS,然后在Lock的那些实现方法中调用MySync对象的某些方法就行了;
package com.example.demo.Lock; 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 MyNonLock implements Lock, java.io.Serializable { //创建一个具体的MySync来做具体的工作 private final MySync mySync = new MySync(); @Override public void lock() { mySync.acquire(1); } @Override public boolean tryLock() { return mySync.tryAcquire(1); } @Override public boolean tryLock(long time, TimeUnit unit) throws InterruptedException { return mySync.tryAcquireNanos(1, unit.toNanos(time)); } //带了Interruptibly的方法表示对中断进行响应,就是当一个线程在阻塞队列中被挂起的时候, //其他线程调用该线程的中断方法中断了该线程,该线程会抛出InterruptedException异常 @Override public void lockInterruptibly() throws InterruptedException { mySync.acquireInterruptibly(1); } @Override public void unlock() { mySync.release(1); } //很方便的获取条件变量 @Override public Condition newCondition() { return mySync.newCondition(); } private static class MySync extends AbstractQueuedSynchronizer { // 锁是否已经被持有 protected boolean isHeldExclusively() { return getState() == 1; } // 如果state为0,就尝试获取锁,将state修改为1 public boolean tryAcquire(int acquires) { assert acquires == 1; if (compareAndSetState(0, 1)) { setExclusiveOwnerThread(Thread.currentThread()); return true; } return false; } // 尝试释放锁,将state设置为0 protected boolean tryRelease(int releases) { assert releases == 1; if (getState() == 0) { throw new IllegalMonitorStateException(); } setExclusiveOwnerThread(null); setState(0); return true; } //提供条件变量接口 Condition newCondition() { return new ConditionObject(); } } }
三.生产者消费者模式
我们还可以根据我们自己实现的锁MyNonLock实现一下生产者消费者模式,注意,这个锁是不可重入锁,不需要记录持有锁的线程获取锁的次数,而且state的值为0表示当前锁没有被占用,为1表示已经被占用了;
package com.example.demo.study; import java.util.Queue; import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.locks.Condition; import com.example.demo.Lock.MyNonLock; public class Study0202 { // 我们往这个队列中添加字符串 final static Queue<String> queue = new LinkedBlockingQueue<String>(); // 创建我们自己的锁对象 final static MyNonLock lock = new MyNonLock(); // 当队列queue中字符串满了,其他的生产线程就丢到这个条件队列里面 final static Condition full = lock.newCondition(); // 当队列queue是空的,其余的消费线程就丢到这个条件队列里面 final static Condition empty = lock.newCondition(); // 队列queue中存字符串最多只能是3个 final static int queue_MAX_SIZE = 3; //往队列queue中压入字符串 public static void add() { lock.lock(); try { // 当队列满了,就将其他生产线程丢进full的条件队列中 while (queue.size() == queue_MAX_SIZE) { full.await(); } System.out.println("prd:" + "hello"); // 往队列queue中添加字符串 queue.add("hello"); // 生产成功,唤醒消费条件队列中的所有线程赶紧去消费 empty.signalAll(); } catch (Exception e) { // } finally { lock.unlock(); } } //从队列queue弹出字符串 public static void poll() { lock.lock(); try { // 当队列queue中一个字符串都没有,就将剩下的消费线程丢进enpty对应的队列中 while (queue.size() == 0) { empty.await(); } // 消费队列queue中的字符串 String poll = queue.poll(); System.out.println("consumer:" + poll); // 消费成功,就唤醒full中所有的生产线程去生产字符串 full.signalAll(); } catch (Exception e) { // } finally { lock.unlock(); } } public static void main(String[] args) { // 生产者线程 for (int i = 0; i < 5; i++) { new Thread(() -> { add(); }).start(); } // 消费者线程 for (int i = 0; i < 5; i++) { new Thread(() -> { poll(); }).start(); } } }
可以看到队列中最多只能是3个字符串,最后都能被消费完毕!
以上就是基于AQS实现一个同步器的详细内容,更多关于AQS实现同步器的资料请关注鸟哥教程(niaoge.com)其它相关文章!
声明:本文内容来源于网络,版权归原作者所有,内容由互联网用户自发贡献自行上传,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任。如果您发现有涉嫌版权的内容,欢迎发送邮件至:notice#niaoge.com(发邮件时,请将#更换为@)进行举报,并提供相关证据,一经查实,本站将立刻删除涉嫌侵权内容。