无锁编程（Lock Free）框架 系列文章

最新推荐文章于 2024-07-09 18:36:03 发布
最新推荐文章于 2024-07-09 18:36:03 发布
阅读量1k 收藏 2
点赞数 2
分类专栏： # 并发编程 Java 文章标签： java 多线程
原文链接：https://www.cnblogs.com/crazymakercircle/p/13909235.html
版权

无锁编程（Lock Free）框架 系列文章：

1 disruptor 是什么？

Disruptor 是英国外汇交易公司 LMAX 开发的一个高性能队列，研发的初衷是解决内存队列的延迟问题（在性能测试中发现竟然与 I/O 操作处于同样的数量级）。

基于 Disruptor 开发的系统单线程能支撑每秒 600 万订单，2010 年在 QCon 演讲后，获得了业界关注。2011 年，企业应用软件专家 Martin Fowler 专门撰写长文介绍。同年它还获得了 Oracle 官方的 Duke 大奖。

目前，包括 Apache Storm、Camel、Log4j 2 在内的很多知名项目都应用了 Disruptor 以获取高性能。

需要特别指出的是，这里所说的队列是系统内部的内存队列，而不是 Kafka 这样的分布式队列。另外，本文所描述的 Disruptor 特性限于 3.3.4。

2 Java 内置队列的问题

介绍 Disruptor 之前，我们先来看一看常用的线程安全的内置队列有什么问题。Java 的内置队列如下表所示。

队列有界性锁数据结构
ArrayBlockingQueuebounded加锁arraylist
LinkedBlockingQueueoptionally-bounded加锁linkedlist
ConcurrentLinkedQueueunbounded无锁linkedlist
LinkedTransferQueueunbounded无锁linkedlist
PriorityBlockingQueueunbounded加锁heap
DelayQueueunbounded加锁heap

队列的底层一般分成三种：数组、链表和堆。其中，堆一般情况下是为了实现带有优先级特性的队列，暂且不考虑。

从数组和链表两种数据结构来看，基于数组线程安全的队列，比较典型的是 ArrayBlockingQueue，它主要通过加锁的方式来保证线程安全；基于链表的线程安全队列分成 LinkedBlockingQueue 和 ConcurrentLinkedQueue 两大类，前者也通过锁的方式来实现线程安全，而后者以及上面表格中的 LinkedTransferQueue 都是通过原子变量 compare and swap（以下简称 “CAS”）这种不加锁的方式来实现的。

但是对 volatile 类型的变量进行 CAS 操作，存在伪共享问题，具体请参考专门的文章：

伪共享 （图解）

Disruptor 使用了类似上面的方案，解决了伪共享问题。

3 Disruptor 框架是如何解决伪共享问题的？

在 Disruptor 中有一个重要的类 Sequence，该类包装了一个 volatile 修饰的 long 类型数据 value，无论是 Disruptor 中的基于数组实现的缓冲区 RingBuffer，还是生产者，消费者，都有各自独立的 Sequence，RingBuffer 缓冲区中，Sequence 标示着写入进度，例如每次生产者要写入数据进缓冲区时，都要调用 RingBuffer.next（）来获得下一个可使用的相对位置。对于生产者和消费者来说，Sequence 标示着它们的事件序号，来看看 Sequence 类的源码：

  class LhsPadding {
	protected long p1, p2, p3, p4, p5, p6, p7;
}

class Value extends LhsPadding {
	protected volatile long value;
}

class RhsPadding extends Value {
	protected long p9, p10, p11, p12, p13, p14, p15;
}

public class Sequence extends RhsPadding {
	static final long INITIAL_VALUE = -1L;
	private static final Unsafe UNSAFE;
	private static final long VALUE_OFFSET;
	static {
		UNSAFE = Util.getUnsafe();
		try {
			VALUE_OFFSET = UNSAFE.objectFieldOffset(Value.class.getDeclaredField("value"));
		} catch(final Exception e) {
			 throw new RuntimeException(e);
		}
	}
	

```
public Sequence() {
	this(INITIAL_VALUE);
}

public Sequence(final long initialValue) {
	UNSAFE.putOrderedLong(this, VALUE_OFFSET, initialValue);
}
```

}

从第 1 到 11 行可以看到，真正使用到的变量 value，它的前后空间都由 8 个 long 型的变量填补了，对于一个大小为 64 字节的缓存行，它刚好被填补满（一个 long 型变量 value，8 个字节加上前 / 后个 7long 型变量填补，7*8=56，56+8=64 字节）。这样做每次把变量 value 读进高速缓存中时，都能把缓存行填充满（对于大小为 64 个字节的缓存行来说，如果缓存行大小大于 64 个字节，那么还是会出现伪共享问题），保证每次处理数据时都不会与其他变量发生冲突。

Disruptor 的使用场景

Disruptor 的最常用的场景就是 “生产者 - 消费者” 场景，对场景的就是 “一个生产者、多个消费者” 的场景，并且要求顺序处理。

当前业界开源组件使用 Disruptor 的包括 Log4j2、Apache Storm 等，它可以用来作为高性能的有界内存队列，基于生产者消费者模式，实现一个 / 多个生产者对应多个消费者。它也可以认为是观察者模式的一种实现，或者发布订阅模式。

举个例子，我们从 MySQL 的 BigLog 文件中顺序读取数据，然后写入到 ElasticSearch（搜索引擎）中。在这种场景下，BigLog 要求一个文件一个生产者，那个是一个生产者。而写入到 ElasticSearch，则严格要求顺序，否则会出现问题，所以通常意义上的多消费者线程无法解决该问题，如果通过加锁，则性能大打折扣。

实战：Disruptor 的 使用实例

我们从一个简单的例子开始学习 Disruptor：生产者传递一个 long 类型的值给消费者，而消费者消费这个数据的方式仅仅是把它打印出来。

定义一个 Event

首先定义一个 Event 来包含需要传递的数据：

public class LongEvent { 
    private long value;
    public long getValue() { 
        return value; 
    } 
 
    public void setValue(long value) { 
        this.value = value; 
    } 
}

由于需要让 Disruptor 为我们创建事件，我们同时还声明了一个 EventFactory 来实例化 Event 对象。

public class LongEventFactory implements EventFactory { 
    @Override 
    public Object newInstance() { 
        return new LongEvent(); 
    } 
}

定义事件处理器（disruptor 会回调此处理器的方法）

我们还需要一个事件消费者，也就是一个事件处理器。这个事件处理器简单地把事件中存储的数据打印到终端：

/** 
 */public class LongEventHandler implements EventHandler<LongEvent> { 
    @Override 
    public void onEvent(LongEvent longEvent, long l, boolean b) throws Exception { 
        System.out.println(longEvent.getValue()); 
    } 
}

定义事件源：事件发布器 发布事件

事件都会有一个生成事件的源，这个例子中假设事件是由于磁盘 IO 或者 network 读取数据的时候触发的，事件源使用一个 ByteBuffer 来模拟它接受到的数据，也就是说，事件源会在 IO 读取到一部分数据的时候触发事件（触发事件不是自动的，程序员需要在读取到数据的时候自己触发事件并发布）：

public class LongEventProducer { 
    private final RingBuffer<LongEvent> ringBuffer;
    public LongEventProducer(RingBuffer<LongEvent> ringBuffer) { 
        this.ringBuffer = ringBuffer; 
    } 
 
    /** 
     * onData用来发布事件，每调用一次就发布一次事件事件 
     * 它的参数会通过事件传递给消费者 
     * 
     * @param bb 
     */public void onData(ByteBuffer bb) { 
            //可以把ringBuffer看做一个事件队列，那么next就是得到下面一个事件槽
            long sequence = ringBuffer.next();
            
        try { 
            //用上面的索引取出一个空的事件用于填充 
            LongEvent event = ringBuffer.get(sequence);// for the sequence 
            event.setValue(bb.getLong(0)); 
        } finally { 
            //发布事件 
            ringBuffer.publish(sequence); 
        } 
    } 
}

很明显的是：当用一个简单队列来发布事件的时候会牵涉更多的细节，这是因为事件对象还需要预先创建。

发布事件最少需要两步：

获取下一个事件槽，发布事件（发布事件的时候要使用 try/finnally 保证事件一定会被发布）。

如果我们使用 RingBuffer.next () 获取一个事件槽，那么一定要发布对应的事件。如果不能发布事件，那么就会引起 Disruptor 状态的混乱。尤其是在多个事件生产者的情况下会导致事件消费者失速，从而不得不重启应用才能会恢复。

Disruptor 3.0 提供了 lambda 式的 API。这样可以把一些复杂的操作放在 Ring Buffer，所以在 Disruptor3.0 以后的版本最好使用 Event Publisher 或者 Event Translator (事件转换器) 来发布事件。

Disruptor3.0 以后的事件转换器（填充事件的业务数据）

public class LongEventProducerWithTranslator { 
    //一个translator可以看做一个事件初始化器，publicEvent方法会调用它
    //填充Event
    private static final EventTranslatorOneArg<LongEvent, ByteBuffer> TRANSLATOR = 
            new EventTranslatorOneArg<LongEvent, ByteBuffer>() { 
                public void translateTo(LongEvent event, long sequence, ByteBuffer bb) { 
                    event.setValue(bb.getLong(0)); 
                } 
            };
            
    private final RingBuffer<LongEvent> ringBuffer;
    public LongEventProducerWithTranslator(RingBuffer<LongEvent> ringBuffer) { 
        this.ringBuffer = ringBuffer; 
    } 
 
    public void onData(ByteBuffer bb) { 
        ringBuffer.publishEvent(TRANSLATOR, bb); 
    } 
}

上面写法的另一个好处是，Translator 可以分离出来并且更加容易单元测试。Disruptor 提供了不同的接口 (EventTranslator, EventTranslatorOneArg, EventTranslatorTwoArg, 等等) 去产生一个 Translator 对象。很明显，Translator 中方法的参数是通过 RingBuffer 来传递的。

组装起来

最后一步就是把所有的代码组合起来完成一个完整的事件处理系统。Disruptor 在这方面做了简化，使用了 DSL 风格的代码（其实就是按照直观的写法，不太能算得上真正的 DSL）。虽然 DSL 的写法比较简单，但是并没有提供所有的选项。如果依靠 DSL 已经可以处理大部分情况了。

注意：这里没有使用时间转换器，而是使用简单的 事件发布器。

public class LongEventMain { 
    public static void main(String[] args) throws InterruptedException { 
        // Executor that will be used to construct new threads for consumers 
        Executor executor = Executors.newCachedThreadPool();
        // The factory for the event 
        LongEventFactory factory = new LongEventFactory();
        // Specify the size of the ring buffer, must be power of 2.
        int bufferSize = 1024;
        // Construct the Disruptor 
        Disruptor<LongEvent> disruptor = new Disruptor<LongEvent>(factory, bufferSize, executor);
        
        // Connect the handler 
        disruptor.handleEventsWith(new LongEventHandler());
        // Start the Disruptor, starts all threads running 
        disruptor.start();
        // Get the ring buffer from the Disruptor to be used for publishing. 
        RingBuffer<LongEvent> ringBuffer = disruptor.getRingBuffer(); 
 
        LongEventProducer producer = new LongEventProducer(ringBuffer); 
 
        ByteBuffer bb = ByteBuffer.allocate(8);
        for (long l = 0; true; l++) { 
            bb.putLong(0, l); 
            
            //发布事件 
            producer.onData(bb); 
            Thread.sleep(1000); 
        } 
    } 
}

在 Java 8 使用 Disruptor

Disruptor 在自己的接口里面添加了对于 Java 8 Lambda 的支持。大部分 Disruptor 中的接口都符合 Functional Interface 的要求（也就是在接口中仅仅有一个方法）。所以在 Disruptor 中，可以广泛使用 Lambda 来代替自定义类。

public class LongEventMainJava8 { 
    /** 
     * 用lambda表达式来注册EventHandler和EventProductor 
     * @param args 
     * @throws InterruptedException 
     */public static void main(String[] args) throws InterruptedException { 
        // Executor that will be used to construct new threads for consumers 
        Executor executor = Executors.newCachedThreadPool();
        // Specify the size of the ring buffer, must be power of 2.
        int bufferSize = 1024;// Construct the Disruptor 
        Disruptor<LongEvent> disruptor = new Disruptor<>(LongEvent::new, bufferSize, executor);
        // 可以使用lambda来注册一个EventHandler 
        disruptor.handleEventsWith((event, sequence, endOfBatch) -> System.out.println("Event: " + event.getValue()));
        // Start the Disruptor, starts all threads running 
        disruptor.start();
        // Get the ring buffer from the Disruptor to be used for publishing. 
        RingBuffer<LongEvent> ringBuffer = disruptor.getRingBuffer(); 
 
        LongEventProducer producer = new LongEventProducer(ringBuffer); 
 
        ByteBuffer bb = ByteBuffer.allocate(8);for (long l = 0; true; l++) { 
            bb.putLong(0, l); 
            ringBuffer.publishEvent((event, sequence, buffer) -> event.setValue(buffer.getLong(0)), bb); 
            Thread.sleep(1000); 
        } 
    } 
}

由于在 Java 8 中方法引用也是一个 lambda，因此还可以把上面的代码改成下面的代码：

public class LongEventWithMethodRef { 
    public static void handleEvent(LongEvent event, long sequence, boolean endOfBatch) 
    { 
        System.out.println(event.getValue()); 
    } 
 
    public static void translate(LongEvent event, long sequence, ByteBuffer buffer) 
    { 
        event.setValue(buffer.getLong(0)); 
    } 
 
    public static void main(String[] args) throws Exception 
    { 
        // Executor that will be used to construct new threads for consumers 
        Executor executor = Executors.newCachedThreadPool();
        // Specify the size of the ring buffer, must be power of 2.
        int bufferSize = 1024;
        // Construct the Disruptor 
        Disruptor<LongEvent> disruptor = new Disruptor<>(LongEvent::new, bufferSize, executor);
        // Connect the handler 
        disruptor.handleEventsWith(LongEventWithMethodRef::handleEvent);
        // Start the Disruptor, starts all threads running 
        disruptor.start();
        // Get the ring buffer from the Disruptor to be used for publishing. 
        RingBuffer<LongEvent> ringBuffer = disruptor.getRingBuffer(); 
 
        LongEventProducer producer = new LongEventProducer(ringBuffer); 
 
        ByteBuffer bb = ByteBuffer.allocate(8);
        for (long l = 0; true; l++) 
        { 
            bb.putLong(0, l); 
            ringBuffer.publishEvent(LongEventWithMethodRef::translate, bb); 
            Thread.sleep(1000); 
        } 
    } 
}

Disruptor 如何实现高性能？

Disruptor 实现高性能主要体现了去掉了锁，采用 CAS 算法，同时内部通过环形队列实现有界队列。

  • 环形数据结构
    为了避免垃圾回收，采用数组而非链表。同时，数组对处理器的缓存机制更加友好。
  • 元素位置定位
    数组长度 2^n，通过位运算，加快定位的速度。下标采取递增的形式。不用担心 index 溢出的问题。index 是 long 类型，即使 100 万 QPS 的处理速度，也需要 30 万年才能用完。
  • 无锁设计
    每个生产者或者消费者线程，会先申请可以操作的元素在数组中的位置，申请到之后，直接在该位置写入或者读取数据。整个过程通过原子变量 CAS，保证操作的线程安全。

使用 Disruptor，主要用于对性能要求高、延迟低的场景，它通过 “榨干” 机器的性能来换取处理的高性能。如果你的项目有对性能要求高，对延迟要求低的需求，并且需要一个无锁的有界队列，来实现生产者 / 消费者模式，那么 Disruptor 是你的不二选择。

原理：Disruptor 的内部 Ring Buffer 环形队列

RingBuffer 是什么

RingBuffer 是一个环 (首尾相连的环)，用做在不同上下文 (线程) 间传递数据的 buffer。
RingBuffer 拥有一个序号，这个序号指向数组中下一个可用元素。

img

Disruptor 使用环形队列的优势：

Disruptor 框架就是一个使用 CAS 操作的内存队列，与普通的队列不同，Disruptor 框架使用的是一个基于数组实现的环形队列，无论是生产者向缓冲区里提交任务，还是消费者从缓冲区里获取任务执行，都使用 CAS 操作。

使用环形队列的优势：

第一，简化了多线程同步的复杂度。学数据结构的时候，实现队列都要两个指针 head 和 tail 来分别指向队列的头和尾，对于一般的队列是这样，想象下，如果有多个生产者同时往缓冲区队列中提交任务，某一生产者提交新任务后，tail 指针都要做修改的，那么多个生产者提交任务，头指针不会做修改，但会对 tail 指针产生冲突，例如某一生产者 P1 要做写入操作，在获得 tail 指针指向的对象值 V 后，执行 compareAndSet（）方法前，tail 指针被另一生产者 P2 修改了，这时生产者 P1 执行 compareAndSet（）方法，发现 tail 指针指向的值 V 和期望值 E 不同，导致冲突。同样，如果多个消费者不断从缓冲区中获取任务，不会修改尾指针，但会造成队列头指针 head 的冲突问题（因为队列的 FIFO 特点，出列会从头指针出开始）。

环形队列的一个特点就是只有一个指针，只通过一个指针来实现出列和入列操作。如果使用两个指针 head 和 tail 来管理这个队列，有可能会出现 “伪共享” 问题（伪共享问题在下面我会详细说），因为创建队列时，head 和 tail 指针变量常常在同一个缓存行中，多线程修改同一缓存行中的变量就容易出现伪共享问题。

第二，由于使用的是环形队列，那么队列创建时大小就被固定了，Disruptor 框架中的环形队列本来也就是基于数组实现的，使用数组的话，减少了系统对内存空间管理的压力，因为它不像链表，Java 会定期回收链表中一些不再引用的对象，而数组不会出现空间的新分配和回收问题。

原理：Disruptor 的等待策略

Disruptor 默认的等待策略是 BlockingWaitStrategy。这个策略的内部适用一个锁和条件变量来控制线程的执行和等待（Java 基本的同步方法）。BlockingWaitStrategy 是最慢的等待策略，但也是 CPU 使用率最低和最稳定的选项。然而，可以根据不同的部署环境调整选项以提高性能。

SleepingWaitStrategy

和 BlockingWaitStrategy 一样，SpleepingWaitStrategy 的 CPU 使用率也比较低。它的方式是循环等待并且在循环中间调用 LockSupport.parkNanos (1) 来睡眠，（在 Linux 系统上面睡眠时间 60µs）. 然而，它的优点在于生产线程只需要计数，而不执行任何指令。并且没有条件变量的消耗。但是，事件对象从生产者到消费者传递的延迟变大了。SleepingWaitStrategy 最好用在不需要低延迟，而且事件发布对于生产者的影响比较小的情况下。比如异步日志功能。

YieldingWaitStrategy

YieldingWaitStrategy 是可以被用在低延迟系统中的两个策略之一，这种策略在减低系统延迟的同时也会增加 CPU 运算量。YieldingWaitStrategy 策略会循环等待 sequence 增加到合适的值。循环中调用 Thread.yield () 允许其他准备好的线程执行。如果需要高性能而且事件消费者线程比逻辑内核少的时候，推荐使用 YieldingWaitStrategy 策略。例如：在开启超线程的时候。

BusySpinW4aitStrategy

BusySpinWaitStrategy 是性能最高的等待策略，同时也是对部署环境要求最高的策略。这个性能最好用在事件处理线程比物理内核数目还要小的时候。例如：在禁用超线程技术的时候。

原理：并行模式

单一写者模式

在并发系统中提高性能最好的方式之一就是单一写者原则，对 Disruptor 也是适用的。如果在你的代码中仅仅有一个事件生产者，那么可以设置为单一生产者模式来提高系统的性能。

这里写图片描述

public class singleProductorLongEventMain { 
    public static void main(String[] args) throws Exception { 
        //.....// Construct the Disruptor with a SingleProducerSequencer 
 
        Disruptor<LongEvent> disruptor = new Disruptor(factory, 
                bufferSize, 
                ProducerType.SINGLE, // 单一写者模式, 
                executor);//..... 
    } 
}
一次生产，串行消费

比如：现在触发一个注册 Event，需要有一个 Handler 来存储信息，一个 Hanlder 来发邮件等等。

img

/**
  * 串行依次执行
  * <br/>
  * p --> c11 --> c21
  * @param disruptor
  */
 public static void serial(Disruptor<LongEvent> disruptor){
     disruptor.handleEventsWith(new C11EventHandler()).then(new C21EventHandler());
     disruptor.start();
 }
菱形方式执行

img

 public static void diamond(Disruptor<LongEvent> disruptor){
     disruptor.handleEventsWith(new C11EventHandler(),new C12EventHandler()).then(new C21EventHandler());
     disruptor.start();
 }
链式并行计算

img

 public static void chain(Disruptor<LongEvent> disruptor){
     disruptor.handleEventsWith(new C11EventHandler()).then(new C12EventHandler());
     disruptor.handleEventsWith(new C21EventHandler()).then(new C22EventHandler());
     disruptor.start();
 }
相互隔离模式

这里写图片描述

 public static void parallelWithPool(Disruptor<LongEvent> disruptor){
     disruptor.handleEventsWithWorkerPool(new C11EventHandler(),new C11EventHandler());
     disruptor.handleEventsWithWorkerPool(new C21EventHandler(),new C21EventHandler());
     disruptor.start();
 }
航道模式

这里写图片描述串行依次执行，同时 C11，C21 分别有 2 个实例

/**
  * 串行依次执行,同时C11，C21分别有2个实例
   * <br/>
   * p --> c11 --> c21
   * @param disruptor
   */
  public static void serialWithPool(Disruptor<LongEvent> disruptor){
      disruptor.handleEventsWithWorkerPool(new C11EventHandler(),new C11EventHandler()).then(new C21EventHandler(),new C21EventHandler());
      disruptor.start();
  }
王坦.
关注
专栏目录
TSX之有限事务内存，TSX之锁消除技术 和 lock free 编程之比较(有效总结)
dellme99的专栏
02-05 4150
在多核年代提倡并行编程，然而锁技术大大削弱了系统的并行性。cpu的使用率并不高。 而且一些开源的框架由于锁问题导致了并行性能不好。 但是目前流行的无锁编程、事务同步扩展技术(包括有限事务内存和硬件锁消除）等技术大大提高了系统的并行性。这里介绍了这三者。并且深刻提取了这三者的技术特点和相互之间的区别。
汪文君高并发编程实战视频资源下载.txt
08-08
│ 高并发编程第一阶段30讲、如何实现一个自己的显式锁Lock精讲下（让锁具备超时功能）.mp4 │ 高并发编程第一阶段31讲、如何给你的应用程序注入钩子程序，Linux下演示.mp4 │ 高并发编程第一阶段32讲、如何捕获...
awesome-lockfree：关于免等待和无锁编程的资源集合
01-30
awesome-lockfree：关于免等待和无锁编程的资源集合
无锁化编程
07-11
无锁化编程无锁化编程无锁化编程无锁化编程无锁化编程无锁化编程无锁化编程无锁化编程无锁化编程无锁化编程无锁化编程无锁化编程无锁化编程无锁化编程无锁化编程无锁化编程无锁化编程无锁化编程无锁化编程无锁化编程无锁化编程无锁化编程无锁化编程无锁化编程无锁化编程无锁化编程无锁化编程无锁化编程无锁化编程无锁化编程无锁化编程无锁化编程无锁化编程
Disruptor-无锁并发框架
最新发布
core815的专栏
07-09 676
Disruptor-无锁并发框架
无锁编程入门
flyingleo1981的专栏
11-11 1870
无锁编程入门 本文档的最后也说了，确实是简单介绍，本身需要参考很多其他链接的东西。有翻译不对的地方请帮忙指出来。谢谢。文章中红色字体是我自己加的。 原文地址：http://preshing.com/20120612/an-introduction-to-lock-free-programming 无锁编程是一个挑战，不只是因为任务本身的复杂度，还由于《 but because o
Disruptor-无锁编程－核心原理剖析－ Volatile的普遍误解
软件开发与架构领域 -体系化知识分享
11-23 4920
提到Disruptor，首先映入大家脑海的词就是“无锁“，“快“，本文将试图从底层核心原理上来剖析Disruptor为什么可以“完全无锁“，为什么可以如此快？ 关于Disruptor的背景介绍，本文就不多费口舌了。直接引用网上一段常见的描述： Martin Fowler在自己网站上写了一篇LMAX架构的文章，在文章中他介绍了LMAX是一种新型零售金融交易平台，它能够以很低的延迟产生大量交易...
无锁编程
~~ LINUX ~~
11-16 772
锁的缺点 锁定被迫交出时间片。 锁定意味着阻塞，多个线程（进程）排队获取资源，无法充分发挥系统性能。 锁定的阻塞无法通过fd进行通知，对性能有进一步的影响（理想的服务器模型是全局一处阻塞统一等待消息）。 一些锁限制了必须使用线程的方式进行开发，而线程无法充分利用系统的内存。 pthread库在特殊情况下可能产生饥饿的情况。 无锁编程的思路 加锁的根本起因是什么？ 资源竞争。 解决...
lockfree c#.net
12-11
在IT行业中，"LockFree"是一种并发编程技术，它的核心思想是避免在多线程环境下使用锁来同步对共享资源的访问。LockFree技术在C# .NET框架中也有广泛的应用，可以显著提高多线程环境下的程序性能，降低死锁和竞态...
汪文君高并发编程实战视频资源全集
08-08
│ 高并发编程第一阶段30讲、如何实现一个自己的显式锁Lock精讲下（让锁具备超时功能）.mp4 │ 高并发编程第一阶段31讲、如何给你的应用程序注入钩子程序，Linux下演示.mp4 │ 高并发编程第一阶段32讲、如何捕获...
无锁并发框架Disruptor
架构设计
02-21 189
概述 在逛并发编程网的时候，看到了并发框架Disruptor译文这个系列文章。 Martin Fowler在自己网站上写了一篇LMAX架构(译文)的文章，在文章中他介绍了LMAX是一种新型零售金融交易平台，它能够以很低的延迟产生大量交易。这个系统是建立在JVM平台上，其核心是一个业务逻辑处理器，它能够在一个线程里每秒处理6百万订单。业务逻辑处理器完全是运行在内存中，使用事件源驱动方式。业务...
无锁编程（CAS）
zhongzhh8的博客
12-30 2442
参考高并发之无锁编程 多线程并发 在高并发场景下往往需要用到多线程编程，又由于多个线程共享同一个进程中的地址空间，所以又可能会出现同时访问/修改同一个共享变量的情况，这就涉及到线程安全的问题，比如 两个线程同时修改同一个数据，可能造成某线程的修改丢失； 一个线程写的同时，另一个线程去读该数据时可能会读到写了一半的数据。 对此，我们可以用锁来解决线程安全的问题，在访问共享变量的代码的前后加上加锁和解锁的操作，从而保证同一时刻只有一个线程处于临界区中访问资源。但是除此之外，还有一种无锁编程的方式也可以解.
深入理解无锁编程
极客重生
07-26 1757
hi，大伙好，今天介绍一下无锁编程基础知识，希望大家可以了解无锁编程基本原理。无锁编程是一个挑战，不仅因为任务本身的复杂性，还因为从一开始就很难深入了解这个主题，因为该主题和底层技术（编译...
C++无锁编程——无锁栈(lock-free stack)
davidhopper的博客
06-28 1596
无锁数据结构意味着线程可以并发地访问数据结构而不出错。例如，一个无锁堆栈能同时允许一个线程压入数据，另一个线程弹出数据。不仅如此，当调度器中途挂起其中一个访问线程时，其他线程必须能够继续完成自己的工作，而无需等待挂起线程。
无锁编程介绍
王以山的专栏
06-30 6159
H2 { margin-bottom: 0.21cm; }H2.western { font-family: "DejaVu Sans",sans-serif; font-size: 12pt; font-style: normal; }H2.cjk { font-family: "DejaVu Sans"; font-size: 12pt; }H2.ctl { font-family: "Loh
无锁编程基础
usstmiracle的博客
07-07 524
背景 我们处在技术快速发展的时代，竞争变得前所未有的激烈，不仅要十八般武艺俱全，还得选对正确的技术，跟上发展的脚步，并贴上精研某个专业方向的标签。我们不仅要面对多线程和并发，还要考虑多核时代的并行计算，无锁编程或许是一种选择，可能会提升性能，也可能避免锁的使用引起的错误，同时会带来编程习惯的变革。 不可否认，无锁技术是目前各种并发解决方案中比较受争议的一种，尽管它基于最基本的编程技术，不依赖于任何语言和平台，但是这项技术有些诡异，掌握起来颇有难度，有点曲高和寡，所以没有大面积应用在编程中。 技术本身
无锁编程——从CPU缓存一致性讲到内存模型（1）
lmy347771232的博客
07-01 881
1.什么是有锁编程，什么是无锁编程？在编程中，特别是在并发编程的上下文中，“无锁”和“有锁”是描述线程同步和资源访问控制的两种不同策略。有锁编程是指使用锁（例如互斥锁、信号量等）来控制对共享资源的访问。在有锁策略中，线程必须在执行关键部分的代码前获得锁，以确保同一时间只有一个线程可以访问和修改共享资源。当线程完成对共享资源的操作后，它释放锁，使得其他线程可以接着访问资源。特点包括：线程安全：通过锁可以防止多个线程同时访问共享资源，避免竞争条件。
C语言并发编程指南：从线程管理到锁与无锁数据结构
6. **无锁并发数据结构**：无锁编程（lock-free）使用原子操作来实现并发数据结构，它减少了锁带来的开销和潜在的性能瓶颈，但实现起来更复杂，需要对硬件和编译器优化有深入了解。 7. **设计并发代码**：编写并发...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值