基于AQS自己实现一个同步器

2020-02-04 16:01:20来源:博客园 阅读 ()

新老客户大回馈,云服务器低至5折

基于AQS自己实现一个同步器

  前面说了这个多,我们可以自己尝试实现一个同步器,我们可以简单的参考一下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个字符串,最后都能被消费完毕!

 


原文链接:https://www.cnblogs.com/wyq1995/p/12256550.html
如有疑问请与原作者联系

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:SSM整合

下一篇:Springboot---显示图片/字符串/map集合/list集合