`

通过AQS实现一个互斥锁

阅读更多

 

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

/**
 * 通过AQS实现的互斥锁
 * <br/>
 * AQS: 用来构建锁或者其他同步组件的框架。它使用了一个int变量表示同步状态(更改状态使用CAS方式),通过内置的FIFO队列来完成资源获取线程的排队工作。
 *
 * 通过AQS实现自定义的同步组件一般步骤:
 * 0.继承AQS,然后根据实现同步的模式,覆写对应的方法。这些方法可以是独占的方式、共享的方式
 * 1.实现AQS的类需要调用compareAndSetState(),getState(),setState() 来进行状态的控制
 * 2.外部的同步组件类,实现Lock接口,然后通过AQS对应的模板方法区实现lock方法。
 * Created by Administrator on 2018/8/27.
 */
public class MutexLock implements Lock {

    private static final int LOCK = 1;
    private static final int UNLOCK = 0;

    private final Sync sync = new Sync();

    @Override
    public void lock() {
        sync.acquire(LOCK);
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(LOCK);
    }

    @Override
    public boolean tryLock() {
        return sync.tryAcquire(LOCK);
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return false;
    }

    @Override
    public void unlock() {
        sync.release(UNLOCK);
    }

    @Override
    public Condition newCondition() {
        return sync.newCondition();
    }

    public boolean isLock() {
        return sync.isHeldExclusively();
    }
    
    /**
     * 一般同步器都使用静态内部类去控制外部类的状态
     */
    private static class Sync extends AbstractQueuedSynchronizer {
        /**
         * 独占模式
         * *
         */
        // 获取锁
        @Override
        protected boolean tryAcquire(int arg) {
            if (compareAndSetState(UNLOCK, LOCK)) { //状态为0的时候获取锁
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

        //释放锁
        @Override
        protected boolean tryRelease(int arg) {
            if (getState() == UNLOCK) throw new IllegalMonitorStateException();
            setExclusiveOwnerThread(null);
            setState(UNLOCK);
            return true;
        }
        
        //锁是否被占用
        @Override
        protected boolean isHeldExclusively() {
            return getState() == LOCK;
        }

/*        //共享模式
        @Override
        protected int tryAcquireShared(int arg) {
            return super.tryAcquireShared(arg);
        }

        @Override
        protected boolean tryReleaseShared(int arg) {
            return super.tryReleaseShared(arg);
        }*/

        final ConditionObject newCondition() {
            return new ConditionObject();
        }

    }

}

 

0
0
分享到:
评论

相关推荐

    Java并发编程:深入解析抽象队列同步器(AQS)及其在Lock中的应用

    重点在于ReentrantLock的分析,它是基于AQS实现的互斥锁。相比synchronized,它提供了更多特性,如手动加锁解锁,以及公平和非公平锁的选择。公平锁(FairSync)和非公平锁(NonfairSync)的实现是通过AQS的扩展来...

    Java并发编程解析 | 解析AQS基础同步器的设计与实现

    "Java并发编程解析 | 解析AQS基础同步器的设计与实现" 在Java领域中,解决并发编程问题的...在Java领域中,AQS是基于MESA模型的管程技术的实现,MESA模型中引入了条件变量的概念,每个条件变量对应有一个等待队列。

    7、深入理解AQS独占锁之ReentrantLock源码分析(1).pdf

    AQS是Java中用于构建锁和其他同步组件的一个基础框架。它提供了一套完整的机制来实现独占锁、共享锁等功能。AQS的核心在于维护了一个volatile int类型的state变量,并提供了getState()、setState()、...

    笔记-4、显式锁和AQS1

    4. **可重入性**:synchronized和ReentrantLock(Lock的一个实现)都是可重入的,意味着一个线程在持有锁的情况下可以再次获取该锁,防止死锁的发生。 5. **公平性和非公平性**:ReentrantLock提供了公平锁和非公平...

    深入学习Java同步机制中的底层实现

    首先,`ReentrantLock`是一个可重入互斥锁,允许同一个线程多次获取锁,避免死锁。它的实现依赖于内部的`Sync`类,这是一个继承自`AbstractQueuedSynchronizer`的子类。`Sync`通过`tryAcquire`和`tryRelease`方法来...

    【并发编程】简单化理解AQS和ReentrantLock.pdf

    互斥锁确保同一时间只有一个线程访问临界区,读写锁允许同时有多个读操作但不允许写操作与任何读写操作同时进行。 - **信号量**:用来控制多个线程对共享资源的访问,可以通过调整信号量值来控制并发数量。 - **原子...

    基于JDK源码解析Java领域中的并发锁之设计与实现.pdf

    通过以上分析,我们可以看到Java并发包提供了丰富的并发锁机制,从简单的synchronized关键字到复杂的AQS、LockSupport、Condition等,这些都是为了解决并发编程中的互斥和同步问题。在实际应用中,开发者需要根据...

    java锁详解.pdf

    Mark Word 中有一个锁标志位,用于标识对象的锁状态。 2. 锁的分类:synchronized 锁可以分为轻量级锁、偏向锁和重量级锁三种。 3. 轻量级锁:轻量级锁是 synchronized 锁的一种实现方式,使用 CAS 操作来更新对象的...

    The java. util. concurrent synchronizer framework.pdf

    在Java 5.0版本中,Java并发包引入了AQS框架,用于简化各种同步器的构建,例如互斥锁、读写锁、信号量、屏障、未来对象、事件指示器和交接队列等。这些同步器可以使用AQS框架快速构建,从而提高开发效率并减少实现的...

    第五章 ReentrantLock源码解析1--获得非公平锁与公平锁lock()1

    ReentrantLock是由Java提供的可重入互斥锁,支持公平锁和非公平锁两种模式。非公平锁的特性是获取锁的线程不论先后,都有机会获得锁,而公平锁则遵循先进先出的原则,保证线程按照请求锁的顺序进行。 2. **...

    ReentrantLock解析

    在Java并发编程中,ReentrantLock是JDK提供的一个可重入互斥锁,它是java.util.concurrent.locks包下的核心类。与synchronized关键字相比,ReentrantLock提供了更高的灵活性,如尝试加锁、定时加锁和公平锁等功能。...

    java并发编程-AQS和JUC实战

    - **基本介绍**: `ReentrantLock` 是一个实现了 `Lock` 接口的可重入互斥锁,提供比 `synchronized` 更丰富的功能。与 `synchronized` 不同的是,`ReentrantLock` 是一个非内置锁,必须通过显式的调用来获取和释放锁...

    java进阶提高学习教程-14锁机制.pptx

    在 Java 中,锁有多种不同的实现机制,如可重入锁、读写锁、互斥锁、悲观锁、乐观锁、公平锁、锁消除、独享锁、共享锁等。 可重入锁 可重入锁,也叫做递归锁,指的是同一线程外层函数获得锁之后,内层递归函数仍然...

    Java 读写锁实现原理浅析

    Java 读写锁实现原理浅析是 Java 并发编程中一个非常重要的主题。在多线程编程中,读写锁是解决读写并发问题的常用机制。本文主要介绍了 Java 读写锁实现原理浅析,包括读写锁的定义、读写锁的实现原理、...

    Java同步框架AbstractQueuedSynchronizer详解

    开发者可以通过继承AQS来实现自己的同步器,例如实现一个互斥锁、读写锁、信号量等。 AQS的实现原理是基于队列的数据结构,每个线程都可以被看作是一个节点,节点之间可以形成队列。AQS通过对队列的操作来实现同步...

    带你看看Java-AQS同步器 源码解读四 条件队列Condition上

    在实际编程中,我们常常使用`ReentrantLock`,它是基于AQS实现的可重入互斥锁。`ReentrantLock`的`Condition`接口实现提供了类似`synchronized`关键字的等待/通知机制,但更加强大且易于调试。例如,`ReentrantLock`...

    多线程J.U.C框架(完整)

    - **独占模式**:一次只有一个线程可以获得同步状态,适用于实现互斥锁。 - **共享模式**:允许多个线程同时获得同步状态,适用于实现信号量等组件。 #### 2. J.U.C框架的需求分析 ##### 功能需求 - **阻塞与非...

    并发编程之synchronized&Lock&AQS详解(1)1

    `synchronized`在JVM层面是基于监视器锁(Monitor)实现的,依赖于操作系统的Mutex lock(互斥锁),早期版本性能较低,但1.5以后通过一系列优化,如锁粗化、锁消除、轻量级锁、偏向锁和自旋锁等,性能得到了显著提升...

    Java concurrency之锁_动力节点Java学院整理

    它的核心原则是互斥性,即同一时间只有一个线程能持有同步锁并执行相应的代码块。同步锁有两种形式:方法同步和代码块同步。同步锁的实现基于 monitors,每个对象都有一个与之关联的monitor,当一个线程进入...

Global site tag (gtag.js) - Google Analytics