Concurrent初探 --- Atomic 无锁

一.CAS算法

  Compare And Swap,CAS算法的过程是这样:它包含3个参数CAS(V,E,N)。V表示要更新的变量,E表示预期值,N表示新值。仅当V值等于E值时,才会将V的值设为N,如果V值和E值不同,则说明已经有其他线程做了更新,则当前线程什么都不做。最后,CAS返回当前V的真实值。CAS操作是抱着乐观的态度进行的,它总是认为自己可以成功完成操作。当多个线程同时使用CAS操作一个变量时,只有一个会胜出,并成功更新,其余均会失败。失败的线程不会被挂起,仅是被告知失败,并且允许再次尝试,当然也允许失败的线程放弃操作。基于这样的原理,CAS操作即时没有锁,也可以发现其他线程对当前线程的干扰,并进行恰当的处理。

二.Unsafe类(实现无锁的关键类):

  unsafe提供一些类似于C++的指针操作.非安全的操作,比如:根据偏移量设置值park()     底层的CAS操作非公开API,在不同版本的JDK中, 可能有较大差异

  主要接口:    

  //获得给定对象偏移量上的int值
  public native int getInt(Object o, long offset);
  //设置给定对象偏移量上的int值
  public native void putInt(Object o, long offset, int x);
  //获得字段在对象中的偏移量
  public native long objectFieldOffset(Field f);
  //设置给定对象的int值,使用volatile语义
  public native void putIntVolatile(Object o, long offset, int x);
  //获得给定对象对象的int值,使用volatile语义
  public native int getIntVolatile(Object o, long offset);
  //和putIntVolatile()一样,但是它要求被操作字段就是volatile类型的
  public native void putOrderedInt(Object o, long offset, int x);

  

三.无锁类:

  1.AtomicInteger:

    API:

      public final int get() //取得当前值

      public final void set(int newValue) //设置当前值

      public final int getAndSet(int newValue) //设置新值,并返回旧值

      public final boolean compareAndSet(int expect, int u)//如果当前值为expect,则设置为u

      public final int getAndIncrement() //当前值加1,返回旧值
      public final int getAndDecrement() //当前值减1,返回旧值
      public final int getAndAdd(int delta) //当前值增加delta,返回旧值
      public final int incrementAndGet() //当前值加1,返回新值
      public final int decrementAndGet() //当前值减1,返回新值
      public final int addAndGet(int delta) //当前值增加delta,返回新值

时间: 2024-10-03 17:24:45

Concurrent初探 --- Atomic 无锁的相关文章

Java高并发之无锁与Atomic源码分析

目录 CAS原理 AtomicInteger Unsafe AtomicReference AtomicStampedReference AtomicIntegerArray AtomicIntegerFieldUpdater 无锁的Vector 无锁即无障碍的运行, 所有线程都可以到达临界区, 接近于无等待. 无锁采用CAS(compare and swap)算法来处理线程冲突, 其原理如下 CAS原理 CAS包含3个参数CAS(V,E,N).V表示要更新的变量, E表示预期值, N表示新值.

无锁同步-C++11之Atomic和CAS

1.概要 本文是无锁同步系列文章的第一篇,主要探讨C++11中的Atomic. 我们知道在C++11中引入了mutex和方便优雅的lock_guard.但是有时候我们想要的是性能更高的无锁实现,下面我们来讨论C++11中新增的原子操作类Atomic,我们可以利用它巧妙地实现无锁同步. 2.传统的线程同步 1 #include <thread> 2 #include <mutex> 3 4 #include <iostream> 5 6 using namespace s

使用无锁的方式和有锁的方式的程序性能对比

这里分别使用有锁和无锁两种方式,对一个数值进行增加,一直增加到100000,然后输出使用时间的长短. 1 import java.util.concurrent.ExecutorService; 2 import java.util.concurrent.Executors; 3 import java.util.concurrent.TimeUnit; 4 import java.util.concurrent.atomic.AtomicInteger; 5 6 public class Te

无锁模式的Vector

这两天学习无锁的并发模式,发现相比于传统的 同步加锁相比,有两点好处1.无锁 模式 相比于 传统的 同步加锁  提高了性能 2.无锁模式 是天然的死锁免疫 下来介绍无锁的Vector--- LockFreeVector 它的结构是: private final AtomicReferenceArray<AtomicReferenceArray<E>> buckets; 从这里我们可以看到,它的内部是采用的是 无锁的引用数组, 数组嵌套数组 相当于一个二维数组,它的大小可以动态的进行

boost 无锁队列

一哥们翻译的boost的无锁队列的官方文档 原文地址:http://blog.csdn.net/great3779/article/details/8765103 Boost_1_53_0终于迎来了久违的Boost.Lockfree模块,本着学习的心态,将其翻译如下.(原文地址:http://www.boost.org/doc/libs/1_53_0/doc/html/lockfree.html) Chapter 17. Boost.Lockfree 第17章.Boost.Lockfree Ta

无锁编程与有锁编程的性能对比与分析

最近维护的一个网络服务器遇到性能问题,于是就对原有的程序进行了较大的框架改动.改动最多的是线程工作模式与数据传递方式,最终的结果是改变锁的使用模式.经过一番改进,基本上可以做到 GMb 网卡全速工作处理.在 性能达标之后,一度在想有没有什么办法使用更加轻量级锁,或者去掉锁的使用,为此搜索一些相关的研究成果,并做了一些实验来验证这些成果,因而就有这篇文章.希望有做类似工作的同行可以有所借鉴.如果有人也有相关的经验,欢迎和我交流. 1 无锁编程概述 本节主要对文献 [1] 进行概括,做一些基础知识的

Java高并发-无锁

一.无锁类的原理 1.1 CAS CAS算法的过程是这样:它包含3个参数CAS(V,E,N).V表示要更新的变量,E表示预期值,N表示新值.仅当V值等于E值时,才会将V的值设为N,如果V值和E值不同,则说明已经有其他线程做了更新,则当前线程什么都不做.最后,CAS返回当前V的真实值 .CAS操作是抱着乐观的态度进行的,它总是认为自己可以成功完成操作.当多个线程同时使用CAS操作一个变量时,只有一个会胜出,并成功更新,其余均会失败.失败的线程不会被挂起,仅是被告知失败,并且允许再次尝试,当然也允许

并发之无锁技术归纳

并发之AtomicBoolean/AtomicBooleanArray/AtomicBooleanUpdateFeild 1 和前面的AtomicInteger很相似或者原理基本一致的:原理就是使用了CAS算法实行循环重试的方式来保证一组操作是原子性的操作: 2 同样的也是一个无锁技术的应用: 3 在源码内部,使用1表示true,使用0表示false; 同样的boolean类型的变量在并发情况下也是不安全的,因此使用了AtomicBoolean来保障原子性的操作: AtomicReference

Java高并发程序设计(十)--无锁

锁是一种悲观策略,总是觉得会出问题,所以小心翼翼地操作. 无锁是一种乐观策略,总是假设不会出现问题,如果出现问题,那就重新操作.无锁一般使用CAS作为策略. 比较交换CAS: CAS算法包括三个参数:需要更新的变量,预期值,更新值.只有当需要更新的值等于预期值时,说明其他线程没有对它进行操作,使需要更新值等于更新值. 在java.util.concurrent.atomic中,实现了很多无锁的类型: 用AtomicInteger写个小例子: public class demo implement