23、并发队列与 ABA 问题

并发队列与 ABA 问题

在并发系统中,队列是一种非常重要的数据结构,它可以用于实现生产者 - 消费者模型,保证数据的有序处理。本文将详细介绍并发队列的相关知识,包括不同类型的队列及其实现原理。

1. 池的概念

在并发系统中,池(Pool)是一种常见的数据结构。它与集合(Set)类似,但有两个主要区别:一是池不一定提供 contains() 方法来检查元素是否存在;二是池允许同一个元素多次出现。池通常有 get() 和 set() 方法。

池在并发系统中有广泛的应用,例如在生产者 - 消费者模型中,生产者线程产生的元素可以先放入池中,消费者线程再从池中取出元素进行处理。当生产者产生元素的速度突然超过消费者处理的速度时,池可以作为缓冲区,暂时存储这些元素。

池有多种类型:
- 有界池和无界池 :有界池只能容纳有限数量的元素,这个数量限制称为容量;无界池则可以容纳任意数量的元素。有界池适用于需要对生产者和消费者线程进行松散同步的场景,确保生产者不会领先消费者太多;无界池适用于不需要对生产者和消费者的差距设置固定限制的场景。
- 方法类型 :
- 总方法(Total) :调用时不需要等待特定条件为真。例如,从空池中移除元素的 get() 调用会立即返回失败代码或抛出异常;向已满的有界池添加元素的 set() 调用也会立即返回失败代码或异常。当生产者或消费者线程有其他更重要的事情要做,而不想等待方法调用生效时,总接口是合适的选择。
- 部分方法(Partial) :调用可能需要等待条件满足。例如,从空池中移除元素的部分 get() 调用会阻塞,直到有元素可用;向已满的有界池添加元素的部分 set() 调用会阻塞,直到有空槽可用。当生产者或消费者线程除了等待池变为非满或非空之外没有其他更好的事情可做时,部分接口是合适的选择。
- 同步方法(Synchronous) :需要等待另一个方法的调用区间重叠。例如,在同步池中,向池添加元素的方法调用会阻塞,直到该元素被另一个方法调用移除;从池中移除元素的方法调用会阻塞,直到另一个方法调用使元素可用。同步池常用于 CSP 和 Ada 等编程语言中,用于线程之间的信息交换。
- 公平性保证 :池可以提供不同的公平性保证,如先进先出(FIFO,队列)、后进先出(LIFO,栈)或其他较弱的属性。在使用池进行缓冲时,公平性非常重要,就像打电话等待客服时,我们希望电话能按照来电顺序被接听。

2. 队列的基本概念

队列是一种提供先进先出(FIFO)公平性的池。顺序队列(Sequential Queue)是一个有序的元素序列,它提供 enq(x) 方法将元素 x 放入队列的一端(称为尾部),以及 deq() 方法从队列的另一端(称为头部)移除并返回元素。并发队列可以线性化为顺序队列,其中 enq() 实现 set() 方法, deq() 实现 get() 方法。

3. 有界部分队列

为了简化,我们假设向队列中添加空值是非法的。对于一个有多个并发入队者和出队者的有界队列实现,我们期望它能提供多少并发度呢?从直观上看, enq() 和 deq() 方法分别操作队列的两端,因此只要队列既不满也不空, enq() 调用和 deq() 调用原则上应该可以互不干扰地进行。但实际上,实现这种并发度并不容易。

我们将有界队列实现为一个链表(也可以使用数组)。以下是有界队列的代码实现:

public class BoundedQueue<T> {
    ReentrantLock enqLock, deqLock;
    Condition notEmptyCondition, notFullCondition;
    AtomicInteger size;
    volatile Node head, tail;
    int capacity;

    public BoundedQueue(int _capacity) {
        capacity = _capacity;
        head = new Node(null);
        tail = head;
        size = new AtomicInteger(0);
        enqLock = new ReentrantLock();
        notFullCondition = enqLock.newCondition();
        deqLock = new ReentrantLock();
        notEmptyCondition = deqLock.newCondition();
    }

    public void enq(T x) {
        boolean mustWakeDequeuers = false;
        enqLock.lock();
        try {
            while (size.get() == capacity)
                notFullCondition.await();
            Node e = new Node(x);
            tail.next = e;
            tail = e;
            if (size.getAndIncrement() == 0)
                mustWakeDequeuers = true;
        } finally {
            enqLock.unlock();
        }
        if (mustWakeDequeuers) {
            deqLock.lock();
            try {
                notEmptyCondition.signalAll();
            } finally {
                deqLock.unlock();
            }
        }
    }

    public T deq() {
        T result;
        boolean mustWakeEnqueuers = false;
        deqLock.lock();
        try {
            while (size.get() == 0)
                notEmptyCondition.await();
            result = head.next.value;
            head = head.next;
            if (size.getAndDecrement() == capacity) {
                mustWakeEnqueuers = true;
            }
        } finally {
            deqLock.unlock();
        }
        if (mustWakeEnqueuers) {
            enqLock.lock();
            try {
                notFullCondition.signalAll();
            } finally {
                enqLock.unlock();
            }
        }
        return result;
    }

    protected class Node {
        public T value;
        public volatile Node next;

        public Node(T x) {
            value = x;
            next = null;
        }
    }
}

该队列使用两个不同的锁 enqLock 和 deqLock 来确保同一时间最多只有一个入队者和一个出队者可以操作队列对象的字段。每个锁都有一个关联的条件字段: enqLock 关联 notFullCondition ,用于在队列不再满时通知等待的出队者; deqLock 关联 notEmptyCondition ,用于在队列不再空时通知等待的入队者。

size 字段是一个 AtomicInteger ,用于跟踪队列中当前的元素数量。 enq() 方法的工作流程如下:
1. 线程获取 enqLock 。
2. 读取 size 字段,如果队列已满( size 等于容量),则入队者需要等待,直到出队者腾出空间。入队者在 notFullCondition 上等待,暂时释放入队锁,并阻塞直到该条件被信号唤醒。
3. 当有空槽时,入队者创建一个新节点,并将其添加到队列尾部。
4. 如果入队前队列是空的,可能需要唤醒等待的出队者。

deq() 方法的工作流程如下:
1. 线程获取 deqLock 。
2. 读取 size 字段,如果队列为空,则出队者需要等待,直到有元素入队。出队者在 notEmptyCondition 上等待,暂时释放出队锁,并阻塞直到该条件被信号唤醒。
3. 当队列非空时,出队者从队列头部移除一个元素。
4. 如果出队前队列是满的,可能需要唤醒等待的入队者。

这个实现的一个缺点是,并发的 enq() 和 deq() 调用会相互干扰,因为所有方法调用都会对 size 字段进行 getAndIncrement() 或 getAndDecrement() 操作,这些操作比普通的读写操作更昂贵,可能会导致顺序瓶颈。为了减少这种干扰,可以将 size 字段拆分为两个计数器: enqSideSize 和 deqSideSize 。

4. 无界总队列

无界总队列可以容纳任意数量的元素。 enq() 方法总是能成功入队元素, deq() 方法在队列为空时会抛出 EmptyException 。其实现与有界队列类似,但不需要跟踪元素数量,也不需要提供等待条件。

public class UnboundedQueue<T> {
    ReentrantLock enqLock, deqLock;
    volatile Node head, tail;

    public UnboundedQueue() {
        head = new Node(null);
        tail = head;
        enqLock = new ReentrantLock();
        deqLock = new ReentrantLock();
    }

    public void enq(T x) {
        enqLock.lock();
        try {
            Node e = new Node(x);
            tail.next = e;
            tail = e;
        } finally {
            enqLock.unlock();
        }
    }

    public T deq() throws EmptyException {
        T result;
        deqLock.lock();
        try {
            if (head.next == null) {
                throw new EmptyException();
            }
            result = head.next.value;
            head = head.next;
        } finally {
            deqLock.unlock();
        }
        return result;
    }

    protected class Node {
        public T value;
        public volatile Node next;

        public Node(T x) {
            value = x;
            next = null;
        }
    }
}

class EmptyException extends Exception {
    public EmptyException() {
        super("Queue is empty");
    }
}

这个队列不会发生死锁,因为每个方法只获取一个锁( enqLock 或 deqLock )。队列中的哨兵节点不会被删除,因此每个 enq() 调用只要获取到锁就能成功。当然,如果队列为空, deq() 方法会失败。与前面的队列实现一样,元素实际上在 enq() 调用将最后一个节点的 next 字段设置为新节点时就已经入队,即使 enq() 还没有将 tail 重置为指向新节点。

5. 无界无锁队列

无界无锁队列 LockFreeQueue<T> 是无界总队列的自然扩展,它通过让较快的线程帮助较慢的线程来防止方法调用饥饿。

import java.util.concurrent.atomic.AtomicReference;

public class LockFreeQueue<T> {
    private AtomicReference<Node> head;
    private AtomicReference<Node> tail;

    public LockFreeQueue() {
        Node sentinel = new Node(null);
        head = new AtomicReference<>(sentinel);
        tail = new AtomicReference<>(sentinel);
    }

    public void enq(T value) {
        Node node = new Node(value);
        while (true) {
            Node last = tail.get();
            Node next = last.next.get();
            if (last == tail.get()) {
                if (next == null) {
                    if (last.next.compareAndSet(next, node)) {
                        tail.compareAndSet(last, node);
                        return;
                    }
                } else {
                    tail.compareAndSet(last, next);
                }
            }
        }
    }

    public T deq() throws EmptyException {
        while (true) {
            Node first = head.get();
            Node last = tail.get();
            Node next = first.next.get();
            if (first == head.get()) {
                if (first == last) {
                    if (next == null) {
                        throw new EmptyException();
                    }
                    tail.compareAndSet(last, next);
                } else {
                    T value = next.value;
                    if (head.compareAndSet(first, next))
                        return value;
                }
            }
        }
    }

    private class Node {
        public T value;
        public AtomicReference<Node> next;

        public Node(T value) {
            this.value = value;
            next = new AtomicReference<>(null);
        }
    }
}

class EmptyException extends Exception {
    public EmptyException() {
        super("Queue is empty");
    }
}

队列中的每个节点的 next 字段是一个 AtomicReference<Node> ,队列本身由两个 AtomicReference<Node> 字段 head 和 tail 组成,分别指向队列的第一个和最后一个节点。队列的构造函数将 head 和 tail 都初始化为指向哨兵节点。

enq() 方法是懒惰的,它分两个不同的步骤进行:
1. 调用 compareAndSet() 将新节点追加到队列尾部。
2. 调用 compareAndSet() 将队列的 tail 字段从先前的最后一个节点更新为当前的最后一个节点。

由于这两个步骤不是原子执行的,其他方法调用可能会遇到未完成的 enq() 调用,并帮助完成该工作。 deq() 方法与无界总队列的 deq() 方法类似,但在无锁情况下有一个微妙的问题:在移动 head 之前,必须确保 tail 不会指向即将从队列中移除的哨兵节点。为了避免这个问题,添加了一个测试:如果 head 等于 tail 且它们指向的节点有非空的 next 字段,则更新 tail 。

综上所述,不同类型的队列在并发系统中都有各自的应用场景。有界队列适用于需要控制生产者和消费者速度的场景;无界队列适用于不需要限制元素数量的场景;无锁队列则在高并发环境中提供更好的性能。在实际应用中,需要根据具体需求选择合适的队列类型。

下面是一个简单的 mermaid 流程图,展示无界无锁队列 enq() 方法的工作流程:

graph TD;
    A[开始] --> B[创建新节点];
    B --> C[获取尾节点 last];
    C --> D[获取 last 的下一个节点 next];
    D --> E{last 是否等于当前尾节点};
    E -- 是 --> F{next 是否为空};
    F -- 是 --> G[尝试将新节点追加到 last 后面];
    G -- 成功 --> H[尝试更新尾节点为新节点];
    H -- 成功 --> I[返回];
    F -- 否 --> J[尝试更新尾节点为 next];
    J --> C;
    G -- 失败 --> C;
    H -- 失败 --> I;
    E -- 否 --> C;

这个流程图清晰地展示了 enq() 方法的循环过程,包括节点的创建、尾节点的获取、节点的追加和尾节点的更新等步骤。通过这个流程图,可以更好地理解无界无锁队列的入队操作。

在实际应用中,我们可以根据不同的场景选择合适的队列类型。例如,在生产者 - 消费者模型中,如果生产者和消费者的速度差异不大,可以使用有界队列来控制缓冲区的大小;如果生产者产生元素的速度非常快,且不需要限制缓冲区大小,可以使用无界队列;如果对并发性能有较高要求,可以考虑使用无锁队列。

同时,我们也可以根据队列的实现原理,对其进行优化。例如,在有界队列中,可以通过拆分 size 字段来减少并发操作的干扰;在无锁队列中,可以进一步优化 compareAndSet() 操作的使用,提高性能。

总之,并发队列是并发编程中非常重要的一部分,深入理解不同类型队列的特点和实现原理,有助于我们在实际开发中更好地应用它们,提高系统的并发性能和稳定性。

并发队列与 ABA 问题

6. 队列操作的线性化与公平性分析

在并发编程中,线性化是一个重要的概念,它确保并发操作的结果与这些操作按某种顺序依次执行的结果相同。对于队列来说, enq() 和 deq() 操作都需要满足线性化的要求。

  • 线性化点 :

    • 有界部分队列 : enq() 操作的线性化点是在入队者观察到有空槽并开始入队操作的瞬间; deq() 操作的线性化点是在出队者观察到队列非空并开始出队操作的瞬间。
    • 无界总队列 : enq() 操作的线性化点是在 tail.next 被设置为新节点的瞬间; deq() 操作的线性化点是在 head 被更新为其下一个节点的瞬间。
    • 无界无锁队列 : enq() 操作的线性化点是在执行线程(或并发帮助线程)调用 compareAndSet() 重定向 tail 字段到新节点的瞬间; deq() 操作的线性化点是在 head 被成功更新为其下一个节点的瞬间。
  • 公平性 :队列提供的先进先出(FIFO)公平性保证了元素按照入队的顺序出队。在并发环境中,这种公平性对于许多应用场景非常重要,例如任务调度、消息传递等。不同类型的队列在实现公平性时采用了不同的方法:

    • 有界部分队列 :通过使用锁和条件变量来确保入队和出队操作的顺序,从而保证 FIFO 公平性。
    • 无界总队列 :同样使用锁来控制并发访问,保证元素按照入队顺序出队。
    • 无界无锁队列 :通过原子操作和帮助机制来实现公平性,确保每个元素都能按照入队顺序被处理。
7. 不同队列类型的性能比较

不同类型的队列在并发性能上有不同的表现,下面从几个方面进行比较:

队列类型 并发度 锁的使用 同步开销 适用场景
有界部分队列 有限, enq() 和 deq() 操作在队列非空非满时可并发,但 size 操作可能成为瓶颈 使用两个锁 enqLock 和 deqLock 较高,频繁的锁获取和释放以及条件变量的等待和唤醒 生产者和消费者速度差异不大,需要控制缓冲区大小的场景
无界总队列 有限,每个方法只获取一个锁,避免了死锁,但并发度仍受锁的限制 使用两个锁 enqLock 和 deqLock 适中,锁的获取和释放开销 不需要限制元素数量,对并发度要求不高的场景
无界无锁队列 较高,通过原子操作和帮助机制实现无锁并发 无锁 较低,避免了锁的开销,但原子操作有一定成本 高并发环境,对性能要求较高的场景
8. 队列实现中的常见问题及解决方案

在队列的实现过程中,可能会遇到一些常见的问题,下面介绍这些问题及相应的解决方案:

  • 丢失唤醒问题 :在有界部分队列中,入队者在发现队列已满时会等待 notFullCondition ,而出队者在使队列不再满时会信号该条件。如果处理不当,可能会出现入队者丢失唤醒的情况。解决方案是在信号条件之前获取相应的锁,确保入队者在等待和被唤醒的过程中不会错过信号。

  • ABA 问题 :虽然本文未详细提及 ABA 问题,但在无锁队列的实现中,ABA 问题是一个潜在的风险。ABA 问题指的是一个值从 A 变为 B,再变回 A,而其他线程可能无法察觉这个变化。在无锁队列中,如果使用 compareAndSet() 操作,可能会因为 ABA 问题导致操作错误。解决方案可以是使用带有版本号的原子引用,每次值发生变化时版本号也随之改变,这样在比较时不仅比较值,还比较版本号。

  • 性能瓶颈问题 :有界部分队列中 size 字段的操作可能成为性能瓶颈。解决方案是将 size 字段拆分为两个计数器 enqSideSize 和 deqSideSize ,减少并发操作的干扰。

9. 队列在实际应用中的案例

队列在实际应用中有广泛的用途,下面介绍几个常见的案例:

  • 生产者 - 消费者模型 :这是队列最常见的应用场景之一。生产者线程将任务或数据放入队列,消费者线程从队列中取出任务或数据进行处理。不同类型的队列可以根据生产者和消费者的速度差异以及系统的并发需求进行选择。例如,在一个电商系统中,订单处理可以采用生产者 - 消费者模型,生产者线程负责接收用户的订单,将其放入队列,消费者线程负责处理订单。

  • 任务调度 :在操作系统或分布式系统中,任务调度通常使用队列来管理任务的执行顺序。例如,操作系统的任务队列可以确保任务按照提交的顺序依次执行,保证公平性。

  • 消息传递 :在分布式系统中,消息队列用于不同节点之间的消息传递。生产者节点将消息发送到队列,消费者节点从队列中接收消息。无锁队列在高并发的消息传递场景中可以提供更好的性能。

10. 总结与展望

本文详细介绍了并发队列的相关知识,包括池的概念、不同类型的队列(有界部分队列、无界总队列、无界无锁队列)及其实现原理、线性化与公平性分析、性能比较、常见问题及解决方案以及实际应用案例。不同类型的队列在并发系统中都有各自的优势和适用场景,在实际应用中需要根据具体需求进行选择。

未来,随着计算机硬件的发展和并发编程需求的增加,队列的实现可能会进一步优化。例如,在多核处理器和分布式系统中,如何设计更高效的无锁队列将是一个研究热点。同时,如何更好地解决队列实现中的复杂问题,如 ABA 问题和性能瓶颈问题,也需要进一步的研究和探索。

下面是一个 mermaid 流程图,展示生产者 - 消费者模型中使用队列的工作流程:

graph LR;
    A[生产者] --> B[入队操作 enq()];
    B --> C[队列];
    C --> D[出队操作 deq()];
    D --> E[消费者];

这个流程图清晰地展示了生产者 - 消费者模型中队列的作用,生产者将数据入队,消费者从队列中出队数据进行处理。通过这个流程图,可以更好地理解队列在实际应用中的工作原理。

总之,并发队列是并发编程中不可或缺的一部分,深入研究和掌握并发队列的知识对于提高系统的并发性能和稳定性具有重要意义。

C++面试八股文常见错误勘误:从constexpr到ABA问题 C++作为高性能系统级编程语言,其语法细节与并发模型始终是开发者关注的焦点。在面试准备中,常因资料错误导致对constexpr引入版本、CAS操作与ABA问题等核心概念产生误解。理解这些底层原理不仅有助于写出更健壮的代码,也能在工程实践中正确运用内存模型、原子操作与智能指针。从基础语法到多线程编程,再到算法复杂度与设计模式,系统梳理这些高频考点的本质,能帮助开发者避开常见误区,真正提升技术判断力与工程实践能力。本文基于实际面试经验,对多个常见错误进行逐一勘误,并给出更符合现代C++标准的理解方式,助你构建更 阅读详情

相关推荐

原子操作 vs 互斥锁:5个并发场景下的性能基准测试与选择指南

本文通过5个典型并发场景的基准测试,对比原子操作与互斥锁的性能差异。结果显示,原子操作在简单指令(如计数器累加)中吞吐量可达互斥锁的23倍,而互斥锁更适合保护复杂操作(如链表更新)。文章提供了基于硬件特性和业务场景的选型决策框架,帮助开发者在并发编程中做出最优选择。

weixin_42528191的博客 268

CAS中的ABA问题——无锁编程的隐形陷阱与破解之道

摘要:CAS(Compare-And-Swap)作为无锁并发编程的核心技术,存在ABA问题这一致命缺陷。当共享变量经历A→B→A的数值轮回时,CAS会因仅比较数值而忽略修改历史导致误判。本文系统分析了银行转账、无锁队列等场景中的ABA问题,并提出版本号机制、标记位机制、高级数据结构和硬件辅助方案四类解决方案。通过对比不同方案的存储开销和适用场景,为开发者提供选型指南,并给出版本号初始化、溢出处理等最佳实践。文章指出,解决ABA问题需要在确定性和性能间寻找平衡,为CAS操作赋予"时间感知"

5站站长 416

C++高阶并发编程实战:从数据竞争到线程安全队列设计

并发编程是现代软件开发的核心技术,它允许多个任务同时执行以提升系统性能。其基本原理是通过多线程共享CPU时间片,但这也引入了数据竞争和竞态条件等挑战。在C++中,标准库提供了std::thread、std::mutex等基础工具,而高阶并发则关注如何系统性地管理线程间的协作与竞争。从技术价值看,良好的并发设计能显著提升程序吞吐量和响应性,尤其在服务器、游戏引擎、高性能计算等场景中至关重要。本文聚焦于C++并发编程中的核心痛点,深入探讨如何通过RAII锁管理、条件变量、内存序等机制构建健壮的并发系统,并以实现

412

无锁并发编程:从CAS到高性能并发

无锁并发编程是一种通过避免使用锁来实现线程安全的编程方式。它依赖于硬件支持的原子操作(如CAS)来确保数据的一致性,从而避免了锁带来的性能开销和死锁问题。无锁并发的核心特点🧩无阻塞:线程不会因为竞争锁而被挂起🛠️高性能:避免了锁的开销,适合高并发场景🔒线程安全:通过原子操作保证数据一致性无锁并发的应用高性能计数器无锁队列(如Disruptor并发数据结构(如。

KBkongbaiKB的博客 1292

【信息科学与工程学】计算机科学与自动化——第一百三十四篇 编程语言篇 系列一 C/C++01

5. 适用于信号处理。

weixin_49199313的博客 21

【Latex】【附安装文件】Miktex和TexStudio的安装与配置

这代表“构建并运行”,一般来说,我们只需要点这个按钮来运行Latex代码。保存一下代码文件,再运行一次,PDF文件会出现在与代码文件相同的文件夹下。安装完成后,你可能会跳转到一个页面中,你看到这个页面就意味着安装成功了。其实不需要你敲,你只要将下面的代码复制粘贴到你刚刚的文件中即可。成功安装MikTex后,我们需要进行更新,减少后续使用的麻烦。如果懂得将安装路径设置在你想要的盘中,你可以自己设置。双击上文的.exe文件后,你会看到如下画面。如果不懂,为避免不必要的麻烦,请直接点击“

未来就在脚下。 1万+

Juc_并发编程目录

只有登上山顶,才能看到那边的风光 时刻磨刀,学习提升,才能不被淘汰 更新中 感谢周阳老师的付出,将大厂学院JUC全部公开,第一次接触周阳老师的课程那个时候在学校,记得那个时候接近毕业了,看的JVM,出去准备面试。接着陆陆续续看了老师的cloud、面试第一季、第二季等,收获很大,也让自己在这个知识点上有了更多的理解。谈谈看完老师JUC后需要注意的几个小问题: (1). 不需要预习,直接看视频劲量在课上就进行消化,建议自己也总结,加上自己的认知 (2). 从CompletableFeture到JVM、到后面的

所得皆惊喜 8万+

应急响应靶场练习Linux-web-2

本次应急响应靶机采用的是知攻善防实验室的Linux-2应急响应靶机靶机下载地址为:相关账户密码: root/Inch@957821.(第一个为大写的i,记住要带最后的点.)1.该攻击者的IP为192.168.20.12.攻击方式应该是通过/index.php?user-app-register上传了一个webshell,然后使用蚁剑管理webshell之后再次上传version2.php进行提权.3.攻击者修改了phpmyadmin数据库的管理员密码。

tddkett的博客 2806

《Java多线程编程深度实践解锁高性能并发系统的底层逻辑与优化之道》

基于Dijkstra银行家算法的死锁预防策略存在过度保守的缺陷,本文提出结合动态拓扑的DFS检测机制:通过监控等待图中强连通分量的形成轨迹,并结合Safety Margin的余量计算,在生产环境中成功定位多例隐藏的资源循环依赖死锁案例。设计基于Quarantine机制的异常处理框架,当线程捕获不可恢复异常时,立即触发线程置灰操作(设置Terminator状态),并利用 latch实现的隔离期,防止该线程残留的监控线程继续占用操作系统线程表项。这种映射关系使得并发场景中的饥饿现象具备理论解释。

fLSjoIUM的博客 835

ADC噪声参数博弈论:为何24位ADC的有效分辨率可能不如16位?

本文深入探讨了ADC噪声参数的核心矛盾,揭示了24位ADC有效分辨率可能不如16位ADC的根本原因。关键在于跳出单纯比较位数的误区,转而关注输入参考噪声这一绝对指标。文章通过分析参考电压对满量程范围和噪声模型的影响,阐述了动态范围与最小可测信号之间的取舍逻辑,为工程师提供了基于系统实际需求的ADC选型与噪声评估框架。

snow3的博客 710

PyTorch深度学习实战(24)——使用U-Net架构进行图像分割

图像分割 (Image segmentation) 是计算机视觉领域中的一个重要任务,旨在将图像划分为具有语义信息的不同区域或对象。与目标检测任务不同,图像分割要求像素级别的精确定位和分类,将每个像素标记为属于哪个类别或属于哪个区域。在本节中,我们将介绍图像分割的基本概念,并训练一个基于 U-Net 架构的图像分割模型。

盼小辉丶的博客 1万+

实现无锁的栈与队列

怎样实现一个无锁队列,网络上有很多的介绍,其中流传最广,影响最大的恐怕就属于以下两篇论文:  a) "Implementing lock free queue" by  John.D.Valois  b) "Simple, Fast, and Practical Non-Blocking and Blocking Concurrent Queue Algorithms" by M.

woshiyuanlei的专栏 579

相机标定(六)—— 张正友标定法

相机标定一、相机标定的目的1. 相机的成像过程2. 相机标定的目的3. 畸变与畸变矫正二、张正友标定法简介三、标定相机内外参1. 求解内参和外参的积2. 求解内参矩阵3. 求解外参矩阵四、标定相机的畸变参数五、L-M算法参数优化六、相机标定的步骤七、源代码 一、相机标定的目的 1. 相机的成像过程 2. 相机标定的目的 3. 畸变与畸变矫正 二、张正友标定法简介 三、标定相机内外参 1. 求解内参和外参的积 2. 求解内参矩阵 3. 求解外参矩阵 四、标定相机的畸变参数 五、L-M算法参数优化 六、相机

weixin_41480034的博客 1万+

Java后端专题-并发与多线程(约1w字,最全!)

本文汇总了Java并发与多线程专题的核心知识点,包含线程状态与生命周期、锁机制、线程池等关键内容。主要内容包括: 线程6种状态(NEW/RUNNABLE/BLOCKED/WAITING/TIMED_WAITING/TERMINATED)及其转换条件 synchronized原理与锁升级过程(偏向锁→轻量级锁→重量级锁) ReentrantLock与synchronized的核心区别(可中断、超时、多条件等特性) volatile解决可见性与有序性问题但不保证原子性 线程池参数配置原则与拒绝策略选择 并发容器

2401_83440791的博客 737

openlayers:实现在连续更改时间维度时如何平滑地重新加载层 (附完整源码)

openlayers:实现在连续更改时间维度时如何平滑地重新加载层 (附完整源码)

希望我的博客,能帮上你解决学习中工作中所遇到的问题 350

基于Cesium实现,动态水面+大坝排水动画

一、绘制面状水域,使用水波纹理,进行渲染,水体透明,可以看到底色。三、使用粒子系统,将喷泉改变方向,加上重力设置,实现排水动画。二、绘制线状三维体,用作模拟大坝拦截效果。四、最后,模拟水位上升,进行淹没分析,

一醉千秋的专栏 1421

C++多线程流水线设计陷阱与规避策略(2025大会官方案例精讲)

掌握C++多线程流水线设计核心技巧,规避常见性能陷阱。结合2025全球C++及系统软件技术大会:并行数据处理的C++流水线官方案例,解析高并发场景下的数据同步、任务调度与资源竞争解决方案,提升系统吞吐与稳定性,值得收藏。

FuncTide的博客 788

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

Java并发编程:AQS与CAS机制深度解析

CAS(Compare-And-Swap)是并发编程中的核心原子操作,通过CPU指令级支持实现无锁线程安全。其原理是比较内存值与预期值,若匹配则更新,整个过程具备原子性。在Java中,AQS(AbstractQueuedSynchronizer)作为并发包基础框架,采用CAS机制管理同步状态和线程队列,解决了传统锁机制的性能瓶颈问题。通过对比实验可见,CAS方案在吞吐量、延迟和线程切换次数上显著优于synchronized和ReentrantLock。典型应用场景包括高并发库存扣减、计数器等需要高性能原子操

weixin_42535461的博客 37

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

实现无锁的栈与队列(3)

怎样实现一个无锁队列,网络上有很多的介绍,其中流传最广,影响最大的恐怕就属于以下两篇论文: a) "Implementing lock free queue" by John.D.Valois b)"Simple, Fast, and Practical Non-Blocking and BlockingConcurrent Queue Algorithms"byM.M. Mic...

weixin_33950035的博客 193

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

Java 并发锁机制:从底层原理到锁升级,这一篇就够了

无论是面试还是日常高并发开发,锁都是绕不开的核心话题。 本文从 synchronized 到 Lock、AQS,再到死锁/活锁/饥饿,系统梳理 Java 锁的全貌。本文涵盖 JDK 15+ 废弃偏向锁、JIT 运行时优化、虚拟线程 pinning 修复(JDK 24+)、紧凑对象头(JDK 24/25)等最新知识点。全文超 8000 字,建议收藏后慢慢啃。

一线 Java 开发,专注 Java 核心原理、生产踩坑与架构面试实战。 632

0、Java开发常见(并发,JVM)

并发 问题 详解 请谈谈你对volatile的理解 link CAS你知道吗? link 原子类Atomiclnteger的ABA问题谈谈?原子更新引用知道吗? link 我们知道ArrayList是线程不安全,请编码写一个不安全的案例并给出解决方案 link 公平锁/非公平锁/可重入锁/递归锁/自旋锁谈谈你的理解?请手写一个自旋锁 link CountDownLatch/CyclicBarrier/Semaphore使用过吗? link

爱欧米 1057

Java并发面试题100道(含答案解析)

本文整理了一份Java并发编程面试题库,涵盖100道高频面试题及答案解析。内容包含线程基础、synchronized锁机制、volatile与内存模型、CAS原子类、线程池及并发工具等核心知识点。适合Java后端开发者系统复习并发编程知识,帮助准备跳槽面试或提升技术深度。题库附带AI模拟面试和答案解析功能,同时提供JVM、MySQL、Redis等完整面试资源。

huazaijake的博客 354

《Java并发编程精要解锁多线程性能与高可用性实战》

一个电商库存系统案例中,使用`AtomicLong`替代传统`synchronized`锁,将100万并发请求下的操作延迟从23ms降至1.5ms。书中特别强调,CAS并非绝对安全——例如在`AtomicInteger`的`compareAndSet()`操作中,若连续多次失败则会触发线程的自旋消耗。书中给出的“线程阻塞形态分析法”极具借鉴意义:通过组合`jstack`+`perf record`+`VisualVM`,可定位锁竞争热点。书中给出的压测数据显示,此模型可使线程切换开销减少20%。

NIfOzrXk的博客 738
上一篇: 8、双枢轴快速排序与子集和问题的时空优化研究
下一篇: 34、云计算硬件与软件深度解析
php55
博客等级 码龄15年 51粉丝 1553原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值