AQS源码剖析，完整流程解读

news2024/11/25 1:01:31

目录

  • 1 AQS是什么
  • 2 AQS加锁流程
  • 3 结构
  • 4 AQS方法概览
  • 5 AQS源码剖析
    • 5.1 加锁方法
    • 5.2 释放锁
    • 5.3 await等待
    • 5.4 signal唤醒

1 AQS是什么

​ AQS即AbstractQueuedSynchronizer缩写，翻译为抽象队列同步器，是一种用来构建锁和同步器的框架。 平时使用较多的ReentrantLock、CountDownLatch就是基于AQS实现。

​ AQS 核心思想： 如果有线程来请求共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制 AQS 是基于 CLH 锁 （Craig, Landin, and Hagersten locks） 实现的。

​ CLH 锁是对自旋锁的一种改进，是一个虚拟的双向队列加粗样式（虚拟的双向队列即不存在队列实例，仅存在结点之间的关联关系），暂时获取不到锁的线程将被加入到该队列中。AQS 将每条请求共享资源的线程封装成一个 CLH 队列锁的一个结点（Node）来实现锁的分配。在 CLH 队列锁中，一个节点表示一个线程，它保存着线程的引用（thread）、 当前节点在队列中的状态（waitStatus）、前驱节点（prev）、后继节点（next）。

AQS基于CLH队列分配的模式有两种：默认独占模式和共享模式

​ 当以独占模式获取时，尝试通过其他线程获取不能成功。多线程获取的共享模式可能成功。除了在机械意义上，这个类不理解这些差异，当共享模式获取成功时，下一个等待线程（如果存在）也必须确定它是否也可以获取。在不同模式下等待的线程共享相同的FIFO队列。通常，实现子类只支持这些模式之一，但是两者都可以在ReadWriteLock发挥作用。仅支持独占或仅共享模式的子类不需要定义支持未使用模式的方法。

2 AQS加锁流程

AQS的加锁流程并不复杂，只要理解了同步队列和条件队列，以及它们之间的数据流转，就算彻底理解了AQS。

  1. 当多个线程竞争AQS锁时，如果有个线程获取到锁，就把ower线程设置为自己

  2. 没有竞争到锁的线程，在同步队列中阻塞（同步队列采用双向链表，尾插法）。

  3. 持有锁的线程调用await方法，释放锁，追加到条件队列的末尾（条件队列采用单链表，尾插法）。

  4. 持有锁的线程调用signal方法，唤醒条件队列的头节点，并转移到同步队列的末尾。

  5. 同步队列的头节点优先获取到锁

整体流程图如下：

可能同步队列和条件队列的概念还比较模糊，分别什么情况下线程会进入指定队列呢？

简单来说是获取锁没成功的时候线程进入同步队列排队，当占用锁的线程调用了await方法，该线程会进入条件队列，等待被唤醒。详细如下：

首先要明白调用lock方法的流程是：调用时马上尝试获取锁，如获取不到，则加入到AQS的等待队列中去，获取不到锁的线程都在AQS的队列中依调用顺序存放。而Condition自己也维护了一个队列，该队列的作用是维护一个等待signal信号的队列，两个队列的作用是不同。

总的来说，每个线程仅仅会同时存在于以上两个队列中的一个，其中，Conditon的等待队列中存放的是调用了await方法的线程，AQS存放的是调用了lock方法的线程，流程如下（以ReentrantLock举例）：

  1. 线程1调用reentrantLock.lock时，线程被加入到AQS的等待队列中。

  2. 线程1调用await方法被调用时，该线程从AQS中移除，对应操作是锁的释放。

  3. 接着马上被加入到Condition的等待队列中，以为着该线程需要signal信号。

  4. 线程2，因为线程1释放锁的关系，被唤醒，并判断可以获取锁，于是线程2获取锁，并被加入到AQS的等待队列中。

  5. 线程2调用signal方法，这个时候Condition的等待队列中只有线程1一个节点，于是它被取出来，并被加入到AQS的等待队列中。 注意，这个时候，线程1 并没有被唤醒。

  6. signal方法执行完毕，线程2调用reentrantLock.unLock()方法，释放锁

说得直白点，线程1，和线程2都是在 不过是在 以上两个等待队列中来回切换，每个队列表示的意义不同。

3 结构

AbstractQueuedSynchronizer类的主要变量如下

// 继承自AbstractOwnableSynchronizer
public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer {
  
    // 同步状态，0表示无锁，每次加锁+1，释放锁-1
    private volatile int state;

    // 同步队列的头尾节点
    private transient volatile Node head;
    private transient volatile Node tail;

    // Node节点，用来包装线程，放到队列中
    static final class Node {
        // 节点中的线程
        volatile Thread thread;

        // 节点状态
        volatile int waitStatus;

        // 同步队列的前驱节点和后继节点
        volatile Node prev;
        volatile Node next;

        // 条件队列的后继节点
        Node nextWaiter;
    }

    // 条件队列
    public class ConditionObject implements Condition {
        // 条件队列的头尾节点
        private transient Node firstWaiter;
        private transient Node lastWaiter;
    }
}

无论是同步队列还是条件队列中线程都需要包装成Node节点。但是同步队列中是使用prev和next组成双向链表，nextWaiter只用来表示是共享模式还是排他模式。

条件队列没有使用到Node中prev和next属性，而是使用nextWaiter组成单链表。

这个复用对象的设计思想值得我们学习。

同步队列head节点是个哑节点，里面并没有存储线程对象。当然head节点也可以看成是给当前持有锁的线程使用的。

Node节点的状态（waitStatus）共有5种：

  • 1 cancelled：表示线程已经被取消
  • 0 初始化：Node节点的默认值
  • -1 signal: 表示节点线程在释放锁后要唤醒同步队列中的下一个节点线程
  • -2 condition: 当前节点在条件队列中
  • -3 propagate: 释放共享资源的时候会向后传播释放其他共享节点(用于共享模式)

4 AQS方法概览

AQS支持独占和共享两种访问资源的模式（独占模式又叫排他模式）。

不管是那种模式，加锁和释放锁的流程是基本一致的，都是加锁->不成功重复尝试->释放锁

// 加锁
acquire();
// 加可中断的锁
acquireInterruptibly();
// 一段时间内，加锁不成功，就不加了
tryAcquireNanos(int arg, long nanosTimeout);
// 释放锁
release();

加锁和释放锁的抽象方法有以下几个：

// 加独占锁
protected boolean tryAcquire(int arg) {
    throw new UnsupportedOperationException();
}
// 释放独占锁
protected boolean tryRelease(int arg) {
    throw new UnsupportedOperationException();
}

// 加共享锁
protected int tryAcquireShared(int arg) {
    throw new UnsupportedOperationException();
}
// 释放共享锁
protected boolean tryReleaseShared(int arg) {
    throw new UnsupportedOperationException();
}

// 判断是否是当前线程正在持有锁
protected boolean isHeldExclusively() {
    throw new UnsupportedOperationException();
}

可以看到都是只定义了抽象方法，具体的实现逻辑由子类实现：ReentrantLock，CountDownLatch等等

5 AQS源码剖析

5.1 加锁方法

整体的加锁流程如下：
加锁流程

下面看下具体实现方法。类中定义了加锁方法acquire，进入源码：

// 加锁方法，传参是1
public final void acquire(int arg) {
    // 1. 首先尝试获取锁，如果获取成功，则设置state+1，exclusiveOwnerThread=currentThread（留给子类实现）
    if (!tryAcquire(arg) &&
            // 2. 如果没有获取成功，把线程组装成Node节点，追加到同步队列末尾
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) {
        // 3. 加入同步队列后，将自己挂起
        selfInterrupt();
    }
}

会先尝试获取锁，如果加锁成功，state+1，这也是可重入锁的一种思想。如果失败，加入同步队列末尾排队。

源码中主要的方法就三个tryAcquire、acquireQueued、addWaiter。

tryAcquire方法，只是做了个定义，具体逻辑完全由子类实现，之后会拿ReentrantLock举例。

先看下addWaiter方法源码：

// 追加到同步队列末尾，传参是共享模式or独占模式
private Node addWaiter(Node mode) {
    // 1. 组装成Node节点
    Node node = new Node(Thread.currentThread(), mode);
    Node pred = tail;
    if (pred != null) {
        node.prev = pred;
        // 2. 在多线程竞争不激烈的情况下，通过CAS方法追加到同步队列末尾
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    // 3. 在多线程竞争激烈的情况下，使用死循环保证追加到同步队列末尾
    enq(node);
    return node;
}

此时传的是Node.EXCLUSIVE为独占模式，核心是调用compareAndSetTail方法，就是常说的CAS，不断自旋获取锁。如果竞争激烈会调用enq死循环保证入队，enq源码如下：

// 通过死循环的方式，追加到同步队列末尾
private Node enq(final Node node) {
    for (; ; ) {
        Node t = tail;
        if (t == null) {
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

再看一下addWaiter方法外层的acquireQueued方法，作用就是：

  1. 在追加到同步队列末尾后，再判断一下前驱节点是不是头节点。如果是，说明是第一个加入同步队列的，就再去尝试获取锁。（因为有可能在尝试获取锁之后的一系列操作中，锁正好被释放，所以需要再尝试一次）。
  2. 如果获取锁成功，就把自己设置成头节点。
  3. 如果前驱节点不是头节点，或者获取锁失败，就逆序遍历同步队列，找到可以将自己唤醒的节点。
  4. 最后才放心地将自己挂起
// 追加到同步队列末尾后，再次尝试获取锁
final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (; ; ) {
            // 1. 找到前驱节点
            final Node p = node.predecessor();
            // 2. 如果前驱节点是头结点，就再次尝试获取锁
            if (p == head && tryAcquire(arg)) {
                // 3. 获取锁成功后，把自己设置为头节点
                setHead(node);
                p.next = null;
                failed = false;
                return interrupted;
            }
            // 4. 如果还是没有获取到锁，找到可以将自己唤醒的节点
            if (shouldParkAfterFailedAcquire(p, node) &&
                    // 5. 最后将自己挂起
                    parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

其中shouldParkAfterFailedAcquire方法，找到可以将自己唤醒的节点是什么意思呢？

简单来说是排自己前面最近的有效节点，跟入源码：

// 加入同步队列后，找到能将自己唤醒的节点
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
    // 1. 如果前驱节点的状态已经是SIGNAL状态（释放锁后，需要唤醒后继节点），就无需操作了
    if (ws == Node.SIGNAL)
        return true;
    // 2. 如果前驱节点的状态是已取消，就继续向前遍历
    if (ws > 0) {
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        // 3. 找到了不是取消状态的节点，把该节点状态设置成SIGNAL
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

从代码可以看到，目的就是为了找到不是取消状态的节点，并把该节点的状态设置成SIGNAL。为什么这步是必须的呢？

只有节点状态是SIGNAL，当他释放时才会有唤醒下一个这步动作。当节点刚加入队尾时，它后面不再有其他节点，不需要有唤醒这不动作，所以默认不是SIGNAL状态。

简单理解就是：你来排队买东西，拍下前面的人让他买完后回头叫你一声。

5.2 释放锁

释放锁流程

// 释放锁
public final boolean release(int arg) {
    // 1. 先尝试释放锁，如果释放成功，则设置state-1，exclusiveOwnerThread=null（由子类实现）
    if (tryRelease(arg)) {
        Node h = head;
        // 2. 如果同步队列中还有其他节点，就唤醒下一个节点
        if (h != null && h.waitStatus != 0)
            // 3. 唤醒其后继节点
            unparkSuccessor(h);
        return true;
    }
    return false;
}

其中重点方法有tryRelease和unparkSuccessor，tryRelease也是由子类去实现，下面看下unparkSuccessor方法，唤醒其后继节点，进入源码：

// 唤醒后继节点
private void unparkSuccessor(Node node) {
    int ws = node.waitStatus;
    // 1. 如果头节点不是取消状态，就重置成初始状态
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);

    Node s = node.next;
    // 2. 如果后继节点是null或者是取消状态
    if (s == null || s.waitStatus > 0) {
        s = null;
        // 3. 从队尾开始遍历，找到一个有效状态的节点
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    // 3. 唤醒这个有效节点
    if (s != null)
        LockSupport.unpark(s.thread);
}

5.3 await等待

调用await方法，线程会从头结点让出，排到条件队列末尾，并释放锁，将自己挂起。下面流程图蓝色区域有一步要判断是否在条件队列，因为有可能条件队列就它一个，在刚进入队列到释放锁这段时间内，当前占锁的线程调用了signal方法，它又移到了同步队列末尾。

await等待流程

持有锁的线程可以调用await方法，作用是：释放锁，并追加到条件队列末尾。

// 等待方法
public final void await() throws InterruptedException {
    // 如果线程已中断，则中断
    if (Thread.interrupted())
        throw new InterruptedException();
    // 1. 追加到条件队列末尾
    Node node = addConditionWaiter();
    // 2. 释放锁
    int savedState = fullyRelease(node);
    int interruptMode = 0;
    // 3. 有可能刚加入条件队列就被转移到同步队列了，如果还在条件队列，就可以放心地挂起自己
    while (!isOnSyncQueue(node)) {
        LockSupport.park(this);
        if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
            break;
    }
    // 4. 如果已经转移到同步队列，就尝试获取锁
    if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
        interruptMode = REINTERRUPT;
    if (node.nextWaiter != null)
        // 5. 清除条件队列中已取消的节点
        unlinkCancelledWaiters();
    if (interruptMode != 0)
        reportInterruptAfterWait(interruptMode);
}

其中主要方法addConditionWaiter将该线程加入等待队列中排队，进入源码：

// 追加到条件队列末尾
private Node addConditionWaiter() {
    Node t = lastWaiter;
    // 1. 清除已取消的节点，找到有效节点
    if (t != null && t.waitStatus != Node.CONDITION) {
        unlinkCancelledWaiters();
        t = lastWaiter;
    }
    // 2. 创建Node节点，状态是-2（表示处于条件队列）
    Node node = new Node(Thread.currentThread(), Node.CONDITION);
    // 3. 追加到条件队列末尾
    if (t == null)
        firstWaiter = node;
    else
        t.nextWaiter = node;
    lastWaiter = node;
    return node;
}

5.4 signal唤醒

当前持有锁的线程，调用signal方法，会将条件队列中头结点移到同步队列末尾。

signal方法流程

唤醒条件队列的头节点，并追加到同步队列末尾。

// 唤醒条件队列的头节点
public final void signal() {
    // 1. 只有持有锁的线程才能调用signal方法
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
    // 2. 找到条件队列的头节点
    Node first = firstWaiter;
    if (first != null)
        // 3. 开始唤醒+
        
        doSignal(first);
}

// 实际的唤醒方法
private void doSignal(Node first) {
    do {
        // 4. 从条件队列中移除头节点
        if ((firstWaiter = first.nextWaiter) == null)
            lastWaiter = null;
        first.nextWaiter = null;
        // 5. 使用死循环，一定要转移一个节点到同步队列
    } while (!transferForSignal(first) &&
            (first = firstWaiter) != null);
}

可以看到doSignal方法中，循环调用transferForSignal方法，将节点转移至同步队列，首先是把状态改回去，再次调用加锁时的enq方法，在通知前一节点记得唤醒它。

// 实际转移方法
final boolean transferForSignal(Node node) {
    // 1. 把节点状态从CONDITION改成0
    if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
        return false;

    // 2. 使用死循环的方式，追加到同步队列末尾（前面已经讲过）
    Node p = enq(node);
    int ws = p.waitStatus;
    // 3. 把前驱节点状态设置SIGNAL（通知他，别忘了唤醒自己）
    if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
        LockSupport.unpark(node.thread);
    return true;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/994890.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【C++】常用排序算法

【C++】常用排序算法

0.前言 1.sort #include <iostream> using namespace std;// 常用排序算法 sort #include<vector> #include<algorithm>//利用仿函数 打印输出 class myPrint { public:void operator()(int val){cout << val << " ";} };//利用普通函…
阅读更多...
车载网络测试 - UDS诊断篇 - CANTP常用缩写

车载网络测试 - UDS诊断篇 - CANTP常用缩写

CANTP层规范常用缩写 缩写英文全称中文注释BRSbit rate switch比特率开关BSBlockSize块大小CAN controller area network控制器局域网CAN_DL CAN frame data link layer data length in bytesCAN 帧数据链路层数据长度&#xff08;以字节为单位&#xff09;CAN FDcontroller a…
阅读更多...
[kingbase运维之奇怪的现象]

[kingbase运维之奇怪的现象]

#[kingbase运维之奇怪的现象] ##奇怪的现象 某银行数据中心应用反馈&#xff0c;业务接口日志记录了很多执行慢的SQL&#xff0c;出现的时间是随机的&#xff0c;单独在数据库客户端工具执行会很快返回结果。根据之前的经验推断是业务代码传入的参数类型与数据库表结构字段定义…
阅读更多...
HDD-FAT32 ZIP-FAT32 HDD-FAT16 ZIP-FAT16 HDD-NTFS

HDD-FAT32 ZIP-FAT32 HDD-FAT16 ZIP-FAT16 HDD-NTFS

FAT32、FAT16指的是分区格式&#xff0c; FAT16单个文件最大2G FAT32单个文件最大4G NTFS单个文件大于4G HDD是硬盘启动 ZIP是软盘启动 U盘选HDD HDD-NTFS
阅读更多...
buuctf crypto 【还原大师】解题记录

buuctf crypto 【还原大师】解题记录

1.打开题目就能直接看到密文 2.感觉爆破直接能解&#xff0c;试试爆破&#xff08;参考文章&#xff1a;[buuctf] crypto全解——前84道&#xff08;不建议直接抄flag&#xff09;_buuctf crypto_咸鱼壹号的博客-CSDN博客&#xff09; import hashlib k TASC?O3RJMV?WDJKX?…
阅读更多...
建筑模板9层板和7层板的区别

建筑模板9层板和7层板的区别

建筑模板是建筑施工过程中不可或缺的一环&#xff0c;而在建筑模板的选择中&#xff0c;常见的有9层板和7层板两种选项。它们在结构、特性和应用方面存在一些区别。下面将详细探讨9层板和7层板之间的区别。 首先&#xff0c;9层板和7层板的名称源自其板材的层数。9层板由9层木片…
阅读更多...
Docker容器技术实战-1

Docker容器技术实战-1

1.docker容器 docker就好比传统的货运集装箱 每个虚拟机都有独立的操作系统&#xff0c;互不干扰&#xff0c;在这个虚拟机里可以跑任何东西 如应用 文件系统随便装&#xff0c;通过Guest OS 做了一个完全隔离&#xff0c;所以安全性很好&#xff0c;互不影响 容器 没有虚拟化…
阅读更多...
Tomcat配置ssl、jar包

Tomcat配置ssl、jar包

Tomcat配置ssl 部署tomcat服务&#xff0c;项目做到用https访问&#xff0c;使用nginx去做&#xff0c;访问任意一个子网站&#xff0c;都是https 或者 医美项目需要 上传jdk 456 tomcat war包 [nginx-stable] namenginx stable repo baseurlhttp://nginx.org/packages/…
阅读更多...
AI绘画：StableDiffusion实操教程-斗破苍穹-云韵-常服（附高清图下载）

AI绘画：StableDiffusion实操教程-斗破苍穹-云韵-常服（附高清图下载）

前段时间我分享了StableDiffusion的非常完整的教程&#xff1a;“AI绘画&#xff1a;Stable Diffusion 终极宝典&#xff1a;从入门到精通 ” 不久前&#xff0c;我与大家分享了StableDiffusion的全面教程&#xff1a;“AI绘画&#xff1a;Stable Diffusion 终极宝典&#xff…
阅读更多...
用Navicat备份Mysql演示系统数据库的时候出：Too Many Connections

用Navicat备份Mysql演示系统数据库的时候出：Too Many Connections

今天用Navicat进行数据备份的时候&#xff0c;发现由于数据库连接数目过多导致连接锁定&#xff0c;这种情况在多人协同开发的场景中很常见。当然我这里也因为多个应用使用了数据库连接&#xff0c;所以出现了Too Many Connections。 可能是超过最大连接数了。 1、进入Navicat…
阅读更多...
【JAVA-Day03】JDK安装与IntelliJ IDEA安装、配置环境变量

【JAVA-Day03】JDK安装与IntelliJ IDEA安装、配置环境变量

JDK安装与IntelliJ IDEA安装、配置环境变量 一、JDK 版本介绍1.1 JDK 版本选择JDK 8JDK 11JDK 16JDK 171.2 JDK 下载1.3 JDK 安装1.4 配置环境变量1.5 验证 JDK 安装 二、开发利器——IntelliJ IDEA 的安装2.1 IntelliJ IDEA下载2.2 IntelliJ IDEA安装2.3 IntelliJ IDEA启动2.4…
阅读更多...
编译原理：编译原理简明教程知识点梳理（应对考试版）

编译原理：编译原理简明教程知识点梳理（应对考试版）

前言 姜老师是一个好老师&#xff0c;编译原理没有过是我的问题&#xff0c;我爱姜老师。 写这篇博客涉及到好多符号&#xff0c;可以参考这篇文章latex数学公式详细教程 因为打字过于麻烦&#xff0c;很多内容用平板的手写截图&#xff0c;还有电脑截图替代&#xff0c;不太习…
阅读更多...
【刷题篇】贪心算法（一）

【刷题篇】贪心算法（一）

文章目录 分割平衡字符串买卖股票的最佳时机Ⅱ跳跃游戏钱币找零 分割平衡字符串 class Solution { public:int balancedStringSplit(string s) {int lens.size();int cnt0;int balance0;for(int i0;i<len;i){if(s[i]R){balance--;}else{balance;}if(balance0){cnt;}}return …
阅读更多...
MyBatis框架中各种参数类型绑定的方式

MyBatis框架中各种参数类型绑定的方式

MyBatis框架中各种参数类型绑定的方式 一、MyBatis参数绑定 MyBatis框架中&#xff0c;通过Mapper接口和Mapper映射文件的方式来操作数据库的时候&#xff0c;可能需要通过Mapper接口中的方法传递相应的参数拼接到SQL语句上面&#xff0c;那么Mybatis将传递的参数映射到对应S…
阅读更多...
用python实现基本数据结构【03/4】

用python实现基本数据结构【03/4】

说明 如果需要用到这些知识却没有掌握&#xff0c;则会让人感到沮丧&#xff0c;也可能导致面试被拒。无论是花几天时间“突击”&#xff0c;还是利用零碎的时间持续学习&#xff0c;在数据结构上下点功夫都是值得的。那么Python 中有哪些数据结构呢&#xff1f;列表、字典、集…
阅读更多...
03_瑞萨GUI(LVGL)移植实战教程之驱动触摸屏(I2C)

03_瑞萨GUI(LVGL)移植实战教程之驱动触摸屏(I2C)

本系列教程配套出有视频教程&#xff0c;观看地址&#xff1a;https://www.bilibili.com/video/BV1gV4y1e7Sg # 3. 驱动触摸屏(I2C) 本次实验我们在上一次实验的基础上驱动I2C触摸屏。从这次实验开始&#xff0c;我们不需要重新创建工程&#xff0c;而是在上一次实验项目的基础…
阅读更多...
【Unity编辑器扩展】| SceneView面板扩展

【Unity编辑器扩展】| SceneView面板扩展

前言【Unity编辑器扩展】| SceneView面板扩展一、Scene界面添加右键菜单二、自定义菜单的方式三、Scene视图中禁用选择对象四、OnSceneGUI()五、Gizmos5.1 绘制线框5.2 拓展方法六、Handles总结前言 前面我们介绍了Unity中编辑器扩展的一些基本概念及基础知识，还有编辑器扩展中…
阅读更多...
IDEA中的MySQL数据库所需驱动包的下载和导入方法

IDEA中的MySQL数据库所需驱动包的下载和导入方法

文章目录 下载驱动导入方法 下载驱动 MySQL数据库驱动文件下载方法&#xff1a; 最新版的MySQL版本的驱动获取方法&#xff0c;这个超链接是下载介绍的博客 除最新版以外的MySQL版本的驱动获取方法&#xff0c;选择Platform Independent&#xff0c;选择第二个zip压缩包虾藻…
阅读更多...
华清远见第六课程作业day3

华清远见第六课程作业day3

类 栈 #include <iostream>using namespace std;class Sta{ private:int *data;int top; public:Sta():data(new int(128)){top-1;cout<<"stack::无参构造:"<<endl;}~Sta(){delete data;cout<<"stack::析构函数:"<<this<…
阅读更多...
信息安全技术概论-李剑-持续更新

信息安全技术概论-李剑-持续更新

图片和细节来源于 用户 xiejava1018 一.概述 随着计算机网络技术的发展&#xff0c;与时代的变化&#xff0c;计算机病毒也经历了从早期的破坏为主到勒索钱财敲诈经济为主&#xff0c;破坏方式也多种多样&#xff0c;由早期的破坏网络到破坏硬件设备等等 &#xff0c;这也…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023