ReentranLock源码分析

最新推荐文章于 2021-09-29 21:31:57 发布
最新推荐文章于 2021-09-29 21:31:57 发布
阅读量457 收藏 1
点赞数 1
分类专栏： jdk具体实现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kking_edc/article/details/108539685
版权

一、简介

1.1 数据结构

ReetrantLock的底层是借助AbstractQueuedSynchronized实现，所以其数据结构依附于AbstractQueuedSynchronized的数据结构。

1.2 继承关系

public class ReentrantLock implements Lock, java.io.Serializable

ReetranLock实现了Lock接口，Lock接口中定义了lock与unlock相关操作，并且还存在newCondition方法，表示生成一个条件。

1.3 原理

ReentrantLock主要利用CAS+AQS队列来实现，它支持公平所和非公平锁，两者的实现类似：

先通过CAS尝试获取锁，如果此时已经有线程占据了锁，那就加入AQS队列并且被挂起。当锁释放之后，排在CLH队列队首的线程会被唤醒，然后CAS再次尝试获取锁。在这个时候：

  • 非公平锁：如果同时还有另一个线程来尝试获取，那么有可能会让这个线程抢先获取
  • 公平锁：如果同时还有另一个线程来尝试获取，当它发现自己不是在队首的话，就会排到队尾，由队首的线程获取到锁。

1.4 AQS

AQS是一个用于构建锁和同步容器的框架。concurrent包内许多类都是基于AQS构建，例如ReentrantLock，Semphore，CountDownLatch等，AQS解决了在实现同步容器时设计的大量细节问题。
在这里插入图片描述
AQS使用一个FIFO的队列表示排队等待锁的线程，队列头节点称为”哨兵节点“或”哑节点“，它不与任何线程关联。其他的节点与等待线程关联，每个节点维护一个等待状态waitStatus。

1.5 使用示例

private Lock lock = new ReentrantLock();
 
public void test(){
    lock.lock();
    try{
        doSomeThing();
    }catch (Exception e){
        // ignored
    }finally {
        lock.unlock();
    }
}

二、源码分析

2.1 内部类

ReetrantLock总共有三个内部类，并且三个内部类是紧密相关的，三个类的关系如下：
在这里插入图片描述
说明：ReentrantLock类内部总共存在Sync、NonfairSync、FairSync三个类，NonfairSync与FairSync类继承自Sync类，Sync类继承自AbstractQueuedSynchronizer抽象类。下面逐个进行分析。

2.2 Sync类

     //使用ASQ state来指示这个锁被持有了多少次
    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;

       //获取锁
        abstract void lock();

         //非公平方式获取
        final boolean nonfairTryAcquire(int acquires) {
        	//当前线程
            final Thread current = Thread.currentThread();
            //获取状态
            int c = getState();
            if (c == 0) {//表示没有线程正在竞争该锁
            	//CAS设置成功，状态0表示锁没有被占用
                if (compareAndSetState(0, acquires)) {
                	//设置当前线程独占
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            //当前线程拥有该锁
            else if (current == getExclusiveOwnerThread()) {
            	//增加重入次数
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                //设置状态
                setState(nextc);
                return true;
            }
            return false;
        }

		//试图在共享模式下获取对象状态，此方法应该查询是否允许它在共享模式下获取对象状态，如果允许，则获取它
        protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            //当前线程不为独占线程
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

		//判断资源是否被当前线程占有
        protected final boolean isHeldExclusively() {
            // While we must in general read state before owner,
            // we don't need to do so to check if current thread is owner
            return getExclusiveOwnerThread() == Thread.currentThread();
        }

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

        // Methods relayed from outer class
		//返回资源的占用线程
        final Thread getOwner() {
            return getState() == 0 ? null : getExclusiveOwnerThread();
        }

        final int getHoldCount() {
            return isHeldExclusively() ? getState() : 0;
        }

        final boolean isLocked() {
            return getState() != 0;
        }

        /**
         * Reconstitutes the instance from a stream (that is, deserializes it).
         */
        private void readObject(java.io.ObjectInputStream s)
            throws java.io.IOException, ClassNotFoundException {
            s.defaultReadObject();
            setState(0); // reset to unlocked state
        }
    }

Sync类方法和作用如下：

方法作用
lock锁定，并未实现，留给具体子类实现
nonfairTryAcquire非公平方式获取
tryRelease试图在共享模式下获取对象状态，此方法应该查询是否允许它在共享模式下获取对象状态，如果允许，则获取它
isHeldExclusively判断资源是否被当前线程占有
newCondition新生一个条件
getOwner返回占有资源的线程
getHoldCount返回状态
isLocked资源是否被占用
readObject自定义反序列化逻辑

2.3 NonfairSync类

NonfairSync类继承了Sync类，采用非公平策略获取锁，其实现了Sync类中抽象的lock方法，具体实现如下：

首先用一个CAS操作，判断state是否为0（表示当前锁未被占用），如果是0则把它置为1，并且设置当前线程为该锁的独占线程，表示获取锁成功。当多个线程同时尝试占用同一个锁时，CAS操作只能保证一个线程操作成功，剩下的线程就进入等待队列。

“非公平性”也就体现在这里，如果占用锁的线程刚释放锁，state置为0，而排队等待锁的线程还未唤醒时，新来的线程就直接抢占了该锁，那么就“插队“了

	    // 获得锁
        final void lock() {
            if (compareAndSetState(0, 1)) 
                // 把当前线程设置独占锁
                setExclusiveOwnerThread(Thread.currentThread());
            else // 锁已经被占用，或者set失败
                // 以独占模式获取对象，忽略中断
                acquire(1); 
        }

若当前有三个线程去竞争锁，假设线程A的CAS操作成功了，拿到了锁返回，那么线程B和C则设置state失败，进入else，执行acquire方法

2.3.1 acquire在AQS中实现
public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }
2.3.1.1 acquire第一步：尝试获取锁，如果获取锁成功，方法直接返回

tryAcquire的实现

protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }

这里调用了nonfairTryAcquire

nonfairTryAcquire的实现

整个流程是：
检查state字段，若为0，表示锁未被占用，那么尝试占用，若不为0，检查当前锁是否被自己占用，若被自己占用，则更新state字段，表示重入锁的次数，如果以上两点都没有成功，则获取锁失败，返回false

/**
         * Performs non-fair tryLock.  tryAcquire is implemented in
         * subclasses, but both need nonfair try for trylock method.
         */
        final boolean nonfairTryAcquire(int acquires) {
        	//获取当前线程
            final Thread current = Thread.currentThread();
            //获取state变量
            int c = getState();
            //没有线程占用锁的情况
            if (c == 0) {
            	//占用锁成功，设置独占线程为当前线程
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            //当前线程已经占用该锁
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                //更新state值为新的重入次数
                setState(nextc);
                return true;
            }
            //获取锁失败
            return false;
        }
2.3.1.2 acquire第二步：入队

由上面可知，线程A已经占用了锁，所以B和C执行tryAcquire失败，并且进入等待队列。

addWaiter实现：

addWaiter函数是在AQS中实现的

//将新节点和当前线程关联并且入队列
private Node addWaiter(Node mode) {
		//初始化节点，设置关联线程和模式（独占or共享）
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
        Node pred = tail;
        //尾节点不为空，说明队列已经初始化过
        if (pred != null) {
            node.prev = pred;
            //设置新节点为尾节点
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        //尾节点为空，说明队列还未初始化，需要初始化head节点并入对新节点
        enq(node);
        return node;
    }

此时B、C线程同时尝试入队列，由于队列尚未初始化，tail==null，故至少会有一个线程走到enq（node）。我们假设这两个线程同时走到了enq（node）里。

2.1.2.5 enq

这里体现了经典的自旋+CAS操作来实现非阻塞的原子操作。由于compareAndSetHead的实现使用了unsafe类提供的CAS操作，所以只有一个线程会创建head节点成功。假设线程B成功，之后B、C开始第二轮循环，此时tail不为空，两个线程都走到else里面。假设B线程compareAndSetTail成功，那么B就可以返回了，C由于入队失败还需要第三轮循环。最终所有线程都可以成功入队

private Node enq(final Node node) {
		//开始自旋
        for (;;) {
            Node t = tail;
            if (t == null) { // Must initialize
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

当B、C入队后，此时AQS队列如下：
在这里插入图片描述

2.3.1.2 acquire第二步：挂起

此时B和C相继执行acquireQueued(final Node node, int arg)。这个方法让已经入队的线程尝试获取锁，若失败则会被挂起
。

acquireQueued实现：

//已经入队的线程尝试获取锁
final boolean acquireQueued(final Node node, int arg) {
		//表示是否成功获取锁
        boolean failed = true;
        try {
        	//标记线程是否被中断过
            boolean interrupted = false;
            for (;;) {
            	//获取前驱节点
                final Node p = node.predecessor();
                //如果前驱结点是head，即该结点已经成为老二，那么便有资格去尝试获取锁
                if (p == head && tryAcquire(arg)) {
                	//获取成功，将当前结点设置为head结点
                    setHead(node);
                    //原head结点出队，在某个时间点被GC回收
                    p.next = null; // help GC
                    //获取成功
                    failed = false;
                    //返回是否被中断过
                    return interrupted;
                }
                //判断获取失败后是否可以挂起，若可以挂起
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    //线程若被中断，设置interrupted为true
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

假设B和C在竞争锁的过程中A一直持有锁，那么它们的tryAcquire操作都会失败，因此会走到第二个if语句中。接下来看下shouldParkAfterFailedAcquire和parkAndCheckInterrupt都做了哪些事

shouldParkAfterFailedAcquire实现：

//判断当前线程获取锁失败之后是否需要挂起
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
		//前驱结点的状态
        int ws = pred.waitStatus;
        //前驱结点状态为signal，返回true
        if (ws == Node.SIGNAL)
            /*
             * This node has already set status asking a release
             * to signal it, so it can safely park.
             */
            return true;
        //前驱结点状态为CANCELLED
        if (ws > 0) {
        	//从队尾向前寻找第一个状态不为CANCELLED的节点
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
            /*
             * waitStatus must be 0 or PROPAGATE.  Indicate that we
             * need a signal, but don't park yet.  Caller will need to
             * retry to make sure it cannot acquire before parking.
             */
            //将前驱结点的状态设置为SIGNAL
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

parkAndCheckInterrupt实现：

//挂起当前线程，返回线程中断状态并重置
private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);
        return Thread.interrupted();
    }

线程入队后能够挂起的前提是，它的前驱结点的状态为SIGNAL，它的含义是”Hi，前面的兄弟，如果你获取锁并且出队后，记得把我唤醒！“。所以shouldParkAfterFailedAcquired会先判断当前结点的前驱结点是否状态符合要求，若符合则返回true，然后调用parkAndCheckInterrupt，将自己挂起。如果不符合，再看前驱结点是否>0（CANCELLED），若是那么向前遍历直到找到第一个符合要求的前驱，若不是则将前驱结点的状态设置为SIGNAL。

整个流程中，如果前驱结点的状态不是SIGNAL，那么自己就不能安心挂起，需要去找个安心的挂起点，同时可以再尝试下看有没有机会去竞争锁。

最终队列可能如下图所示：

在这里插入图片描述

2.3.2 unlock()

public void unlock() {
        sync.release(1);
    }

public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

解锁的过程相比加锁容易很多。流程大致为先尝试释放锁，若释放成功，那么查看头节点的状态是否为SIGNAL，如果是则唤醒头结点的下个结点关联的线程，如果释放失败那么返回false表示解锁失败。这里我们可以发现，每次都只唤起头节点的下一个结点关联的线程。

最后看下tryRelease的执行过程：

protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

这里入参为1，tryRelease的过程为：当前释放锁的线程若不持有锁，则抛出异常，若持有锁，计算释放后的state值是否为0，若为0表示锁已经被成功释放，并且清空独占线程，最后更新state值，返回free

以下用一张流程图总结了非公平锁的获取锁的过程
在这里插入图片描述

2.4 FairSyn类

公平锁和非公平锁的不同之处在于，公平锁在获取锁的时候，不会先去检查state状态，而是直接执行acquire(1)

// 公平锁
    static final class FairSync extends Sync {
        // 版本序列化
        private static final long serialVersionUID = -3000897897090466540L;

        final void lock() {
            // 以独占模式获取对象，忽略中断
            acquire(1);
        }

        // 尝试公平获取锁
        protected final boolean tryAcquire(int acquires) {
            // 获取当前线程
            final Thread current = Thread.currentThread();
            // 获取状态
            int c = getState();
            if (c == 0) { // 状态为0
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) { // 不存在已经等待更久的线程并且比较并且设置状态成功
                    // 设置当前线程独占
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) { // 状态不为0，即资源已经被线程占据
                // 下一个状态
                int nextc = c + acquires;
                if (nextc < 0) // 超过了int的表示范围
                    throw new Error("Maximum lock count exceeded");
                // 设置状态
                setState(nextc);
                return true;
            }
            return false;
        }
    }

跟踪lock方法的源码可知，当资源空闲时，它总是会先判断sync队列（AbstractQueuedSynchronizer中的数据结构）是否有等待时间更长的线程，如果存在，则将该线程加入到等待队列的尾部，实现了公平获取原则。其中，FairSync类的lock的方法调用如下，只给出了主要的方法。
在这里插入图片描述
可以看出只要资源被其他线程占用，该线程就会添加到sync queue中的尾部，而不会先尝试获取资源。这也是和Nonfair最大的区别，Nonfair每一次都会尝试去获取资源，如果此时该资源恰好被释放，则会被当前线程获取，这就造成了不公平的现象，当获取不成功，再加入队列尾部。

三、使用实例

3.1 公平锁

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class test {
    public static void main(String[] args) throws Exception {
        Lock lock=new ReentrantLock(true);
        MyThread t1=new MyThread("t1",lock);
        MyThread t2=new MyThread("t2",lock);
        MyThread t3=new MyThread("t3",lock);
        t1.start();
        t2.start();
        t3.start();
    }
}

class MyThread extends Thread{
    private Lock lock;
    public MyThread(String name,Lock lock){
        super(name);
        this.lock=lock;
    }

    public void run(){
        lock.lock();
        try{
            System.out.println(Thread.currentThread()+" running");
            try{
                Thread.sleep(500);
            }catch (InterruptedException e) {
                e.printStackTrace();
            }
        }finally {
            lock.unlock();
        }
    }

}

运行结果（某一次）：

Thread[t1,5,main] running
Thread[t2,5,main] running
Thread[t3,5,main] running

该示例使用的是公平策略，由结果可知，可能回存在如下一种时序：
在这里插入图片描述
说明：首先，t1线程的lock操作 -> t2线程的lock操作 -> t3线程的lock操作 -> t1线程的unlock操作 -> t2线程的unlock操作 -> t3线程的unlock操作。根据这个时序图来进一步分析源码的工作流程。

  1. t1线程执行lock.lock，下图给出了方法调用中的主要方法
    在这里插入图片描述
    说明：由调用流程可知，t1线程成功获取了资源，可以继续执行
  2. t2线程执行lock.lock，下图给出了方法调用中的主要方法
    在这里插入图片描述
    说明：由上图可知，最后的结果是t2线程会被禁止，因为调用了LockSupport.park
  3. t3线程执行lock.lock，下图给出了方法调用中的主要方法
    在这里插入图片描述
  4. t1线程调用了lock.unlock，下图给出了方法调用中的主要方法
    在这里插入图片描述
    说明：如上图所示，最后，head的状态会变为0，t2线程会被unpark，即t2线程可以继续运行。此时t3线程还是被禁止。
  5. t2获得CPU资源，继续运行，由于t2之前被park了，现在需要恢复之前的状态，下图给出了方法调用中的主要方法
    在这里插入图片描述
    说明：在setHead函数中会将head设置为之前head的下一个结点，并且将pre域与thread域都设置为null，在acquireQueued返回之前，sync queue就只有两个结点了。
  6. t2执行lock.unlock，下图给出了方法调用中的主要方法。

在这里插入图片描述
说明：由上图可知，最终unpark t3线程，让t3线程可以继续运行。
7. t3线程获取cpu资源，恢复之前的状态，继续运行。
在这里插入图片描述
8. t3执行lock.unlock，下图给出了方法调用中的主要方法
在这里插入图片描述
说明：最后的状态和之前的状态是一样的，队列中有一个空节点，头结点为尾节点均指向它。

参考

你回到了你的家
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ReentrantLock 源码
老男孩的架构路
09-26 623
ReentrantLock 中的 lock 方法，主要调用内部类 Sync 中的抽象 lock 方法。该方法主要有两套实现，一套是公平锁，一套是非公平锁。
ReentrantLock介绍及使用(超详细)
热门推荐
Mr.绵羊的知识星球
02-17 1万+
1. Reentrantlock介绍及使用 2. 公平锁和非公平锁 3. Reentrantlock的使用案例 4. Reentrantlock使用时注意事项
Java 中的Lock锁对象(ReentrantLock/ReentrantReadWriteLock)详解
swadian2008的博客
08-29 3132
当有线程获取读锁时，如果当前没有线程持有写锁，则读锁将立即被获取，读锁计数器加一，表示当前有一个线程持有读锁。在 getValue() 方法中，线程会获取锁，返回共享变量 value 的值，最后释放锁。例如，如果一个线程在尝试获取锁的过程中遇到了饥饿现象（即一直获取不到锁），那么系统可能会采用类似于睡眠的方式，让该线程暂时让出 CPU 资源，等待一段时间后再次尝试获取锁。接着，它获取读锁，释放写锁，这样就实现了锁降级。这是因为写锁是独占锁，不能被多个线程同时持有，而读锁是共享锁，可以被多个线程同时持有。
第五章 ReentrantLock源码解析1--获得非公平锁与公平锁lock()
weixin_34268753的博客
01-15 257
最常用的方式： int a = 12; //注意：通常情况下，这个会设置成一个类变量，比如说Segement中的段锁与copyOnWriteArrayList中的全局锁 final ReentrantLock lock = new ReentrantLock(); lock.lock();//获取锁...
深入理解Java并发锁ReetrantLock
流星飘雨啊
11-28 633
我们平时在项目中遇到线程安全问题，大多使用同步来解决同步问题，同步是隐式锁，它的加锁与释放，无需我们关注，虚拟机会处理。而ReetrantLock的加锁与释放都需要我们手动处理。下面我们将从源码角度来分析ReetrantLock原理。若有不足，欢迎大家留言，以便及时改正。 一：ReetrantLock实现了锁接口，以及三个内部类，Sync，FairSync（公平锁），NonfairSync（非公...
Reentranlock重入锁源码流程图，私聊关注免费给
07-14
重入锁非公平实现方式 线程的状态标识 变量 waitStatus 则表示当前 Node 结点的等待状态，共有5种取值 CANCELLED、SIGNAL、CONDITION、PROPAGATE、0。...所以源码中很多地方用>0、来判断结点的状态是否正常。
JUC(一)-AQS源码分析
01-21
AQS源码分析一、锁的介绍1.1 乐观锁/悲观锁1.2 共享锁/独占锁1.3 公平锁/非公平锁1.4 小结二、AQS框架结构介绍2.1 类图2.2 AQS数据结构三、源码详解3.1 acquire源码详解3.2 release源码详解四、从ReentranLock看公平...
AQS流程图ReentranLock.vsdx
11-10
AQS流程图ReentranLock.vsdx
60.Lock-ReentranLock-ReentrantReadWriteLock.mp4
04-06
在学习Java过程中，自己收集了很多的Java的学习资料，分享给大家，有需要的欢迎下载，希望对大家有用，一起学习，一起进步。
AQS流程图.html
11-25
java锁AQS基础逻辑
java并发之ReetranLock
06-24
java并发之ReetranLock是并发包中的技术，在并发中常用到
java中lock源代码_ReetrantLock源码解析-Java8
weixin_28787115的博客
02-28 144
一.ReentrantLock介绍1.1介绍ReentrantLock，可重入锁，首先是一个锁，独占锁，可重入(也就是当前线程获取锁后，还可以再次获取该锁)；1.2API介绍ReentrantLock有多个接口，这也是相对于synchronized的一个优势吧，可以灵活地对锁进行控制，而不用像synchronized(没有获得monitor则只能阻塞死等)。// 创建reetrantLock对象，...
ReentrantLock源码分析
he_321的博客
03-28 1045
ReentrantLock实现源码分析
你真的理解公平锁和非公平锁吗？「ReentranLock源码分析」
个人站点：javatv.net
09-29 425
阅读本文之前，想想你理解的非公平锁和公平锁是怎样的？再看和我理解的差别在哪里，纯引战，不娱乐???? 什么是ReentrantLock reentrant 翻译为可重入的，因此从字面上翻译为可重入锁，我们知道可重入是指：同一个线程对于已经获得到的锁，可以多次继续申请到该锁的使用权。ReentrantLock 在调用 lock()方法时，已经获取到锁的线程，能够再次调用lock()方法获取锁而不被阻塞。 如果要实现该特性，则需要解决以下两个问题： 线程再次获取锁。锁需要去识别获取锁的线程是否为当前占据锁的线
AbstractQueuedSynchronizer
ijbuhv的专栏
02-02 225
节点状态: signal:表示其后续节点需要在其取消或者释放之后唤醒，再将后续节点唤醒时会将状态会切换为0 condition:表示当前节点需要等待condition，这是在condition队列中的 cancelled:表示当前节点已经被取消 propagate:这个状态是让唤醒传播下去，因为在共享模式下，可能会有多个节点出队， 几个原则 pre节点一定是当前节点对应的线程才会坐更改，所以对于其更新不需要用cas操作 next为null的不一定是tail节点,next节点主要是提升...
freeRTOS与裸机程序相比有什么区别？？
weixin_33851177的博客
12-29 3844
FreeRTOS命名及变量规则 初学FreeRTOS的用户对其变量和函数的命名比较迷惑， FreeRTOS的核心源代码遵从MISRA编码标准指南，关于MISRA编码标准，可以查看文章https://wenku.baidu.com/view/5e7b2f4ee518964bcf847c99.html。下面专门做一下介绍： 变量  uint32_t定义的变量都加上前缀ul。u代表uns...
FreeRTOS参数配置
WIP56的博客
08-19 247
FreeRTOS参数配置 reeRTOSConfig.h具体详细解释 FreeRTOS参数配置
ReetranLock 源码解析
c_c_y_CC的博客
12-11 192
ReetranLock 类 1. 方法含义 方法 说明 lock() 阻塞的获得锁 tryLock() 非阻塞式获取锁 unlock() 释放锁 newCondition() tryLock(long timeout, TimeUnit unit) 2. 方法解析 public void lock() { // 直接调用同步器的lock() ...
reentranlock怎么用
最新发布
03-09
reentrantlock 是 Java 中的一个锁机制，它可以实现可重入锁，即同一个线程可以多次获得同一个锁。使用 reentrantlock 可以通过 lock() 方法获取锁，通过 unlock() 方法释放锁。同时，reentrantlock 还提供了一些...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值