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对象的某些方法就行了；
packagecom.example.demo.Lock;
importjava.util.concurrent.TimeUnit;
importjava.util.concurrent.locks.AbstractQueuedSynchronizer;
importjava.util.concurrent.locks.Condition;
importjava.util.concurrent.locks.Lock;
publicclassMyNonLockimplementsLock,java.io.Serializable{
//创建一个具体的MySync来做具体的工作
privatefinalMySyncmySync=newMySync();
@Override
publicvoidlock(){
mySync.acquire(1);
}
@Override
publicbooleantryLock(){
returnmySync.tryAcquire(1);
}
@Override
publicbooleantryLock(longtime,TimeUnitunit)throwsInterruptedException{
returnmySync.tryAcquireNanos(1,unit.toNanos(time));
}
//带了Interruptibly的方法表示对中断进行响应，就是当一个线程在阻塞队列中被挂起的时候，
//其他线程调用该线程的中断方法中断了该线程，该线程会抛出InterruptedException异常
@Override
publicvoidlockInterruptibly()throwsInterruptedException{
mySync.acquireInterruptibly(1);
}
@Override
publicvoidunlock(){
mySync.release(1);
}
//很方便的获取条件变量
@Override
publicConditionnewCondition(){
returnmySync.newCondition();
}
privatestaticclassMySyncextendsAbstractQueuedSynchronizer{
//锁是否已经被持有
protectedbooleanisHeldExclusively(){
returngetState()==1;
}
//如果state为0，就尝试获取锁，将state修改为1
publicbooleantryAcquire(intacquires){
assertacquires==1;
if(compareAndSetState(0,1)){
setExclusiveOwnerThread(Thread.currentThread());
returntrue;
}
returnfalse;
}
//尝试释放锁，将state设置为0
protectedbooleantryRelease(intreleases){
assertreleases==1;
if(getState()==0){
thrownewIllegalMonitorStateException();
}
setExclusiveOwnerThread(null);
setState(0);
returntrue;
}
//提供条件变量接口
ConditionnewCondition(){
returnnewConditionObject();
}
}
}
三.生产者消费者模式
我们还可以根据我们自己实现的锁MyNonLock实现一下生产者消费者模式，注意，这个锁是不可重入锁，不需要记录持有锁的线程获取锁的次数，而且state的值为0表示当前锁没有被占用，为1表示已经被占用了；
packagecom.example.demo.study;
importjava.util.Queue;
importjava.util.concurrent.LinkedBlockingQueue;
importjava.util.concurrent.locks.Condition;
importcom.example.demo.Lock.MyNonLock;
publicclassStudy0202{
//我们往这个队列中添加字符串
finalstaticQueuequeue=newLinkedBlockingQueue();
//创建我们自己的锁对象
finalstaticMyNonLocklock=newMyNonLock();
//当队列queue中字符串满了，其他的生产线程就丢到这个条件队列里面
finalstaticConditionfull=lock.newCondition();
//当队列queue是空的，其余的消费线程就丢到这个条件队列里面
finalstaticConditionempty=lock.newCondition();
//队列queue中存字符串最多只能是3个
finalstaticintqueue_MAX_SIZE=3;
//往队列queue中压入字符串
publicstaticvoidadd(){
lock.lock();
try{
//当队列满了，就将其他生产线程丢进full的条件队列中
while(queue.size()==queue_MAX_SIZE){
full.await();
}
System.out.println("prd:"+"hello");
//往队列queue中添加字符串
queue.add("hello");
//生产成功，唤醒消费条件队列中的所有线程赶紧去消费
empty.signalAll();
}catch(Exceptione){
//
}finally{
lock.unlock();
}
}
//从队列queue弹出字符串
publicstaticvoidpoll(){
lock.lock();
try{
//当队列queue中一个字符串都没有，就将剩下的消费线程丢进enpty对应的队列中
while(queue.size()==0){
empty.await();
}
//消费队列queue中的字符串
Stringpoll=queue.poll();
System.out.println("consumer:"+poll);
//消费成功，就唤醒full中所有的生产线程去生产字符串
full.signalAll();
}catch(Exceptione){
//
}finally{
lock.unlock();
}
}
publicstaticvoidmain(String[]args){
//生产者线程
for(inti=0;i<5;i++){
newThread(()->{
add();
}).start();
}
//消费者线程
for(inti=0;i<5;i++){
newThread(()->{
poll();
}).start();
}
}
}
可以看到队列中最多只能是3个字符串，最后都能被消费完毕！
以上就是基于AQS实现一个同步器的详细内容，更多关于AQS实现同步器的资料请关注毛票票其它相关文章！
声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：czq8825#qq.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。