aqs是一个java_Java 基于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 queue = new LinkedBlockingQueue();

// 创建我们自己的锁对象

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实现同步器的资料请关注脚本之家其它相关文章！