原子性

并发程序正确地执行,必须要保证原子性可见性以及有序性。只要有一个没有被保证,就有可能会导致程序运行不正确。

原子性:一个操作或多个操作要么全部执行完成且执行过程不被中断,要么就不执行。

可见性:当多个线程同时访问同一个变量时,一个线程修改了这个变量的值,其他线程能够立即看得到修改的值。

有序性:程序执行的顺序按照代码的先后顺序执行。

对于单线程,在执行代码时jvm会进行指令重排序,处理器为了提高效率,可以对输入代码进行优化,它不保证程序中各个语句的执行先后顺序同代码中的顺序一致,但是它会保证保存最终执行结果和代码顺序执行的结果是一致的。

看下边的一个例子:

package com.dx.juc.test;

public class MyThread implements Runnable {
private int serialNumber = 0; public void run() {
System.out.println(Thread.currentThread().getName() + ":" + getSerialNumber());
} public int getSerialNumber() {
return serialNumber++;
}
}

调用:

package com.dx.juc.test;

public class Main {
public static void main(String[] args) {
MyThread thread=new MyThread();
for(int i=0;i<10;i++){
new Thread(thread).start();
}
}
}

输出结果(有时会抛出下边异常结果,但不是每次都出现异常结果):

Thread-1:0
Thread-3:2
Thread-2:1
Thread-0:0
Thread-4:3
Thread-5:4
Thread-7:5
Thread-6:6
Thread-9:7
Thread-8:8

上边这个操作错误的原因:

1)初始值serialNumer=0,thread-0把该值复制到自己的工作空间(线程私有的,该工作空间也可以叫做缓存),之后进行了三个操作:

操作一:int temp=serialNumber;// 从主存中将serialNumber复制到自己的工作空间

操作二:serialNumber=serialNumber+1;// 在自己的工作空间内进行运算

操作三:将serialNumber刷新到主存中

2)假设thread-0在操作三还未处理之前,thread-1从主存中复制serialNumber=0到自己的工作空间,然后thread-0触发操作三,而此时thread-1并不知道主存中的serialNumber已经被修改,它依然使用工作空间中的serialNum=0,也进行与thread-0一样的散步操作。

当thread-1触发操作三时(此时thread-0已经把主存中的serialNubmer修改为1)并不知道serialNumber是否被其他线程操作过,它就把在自己工作区修改的结果刷新到主存中,此时thread-1中的serialNum=1,之后的操作就是thread-1的值覆盖了thread-0的值,实际上他们值是一样的。

3)即时把int serialNumber添加上volatile修饰也不能避免该问题,从这里可以看出volatile是不具有原子性的。

在java中,对基本数据类型的变量的读取和赋值操作是原子性操作,即这些操作是不可被中断,要么执行,要么不执行。

X=10;   // 原子性(简单的读取、将数字赋值给变量)
Y = x; // 变量之间的相互赋值,不是原子操作
X++; // 对变量进行计算操作,此时讲过三次操作int temp=X;X=X+1;X=temp,经过获取、修改、赋值三个操作。
X = x+1;

语句2实际包括两个操作,它先要去读取x的值,再将y值写入,两个操作分开是原子性的,合在一起就不是原子性的。

语句3、4:x++  x=x+1包括3个操作:读取x的值,x+1,将x写入,所以他们也不是原子性的。

只有语句1具有原子性。

注:可以通过 synchronized和Lock实现原子性。因为synchronized和Lock能够保证任一时刻只有一个线程访问该代码块。

使用Atomic解决原子性问题

在jdk1.5以后java.util.concurrent.atomic包下,提供了

大量的原子变量,它们内部使用CAS算法。

针对上边的代码修改为如下:

package com.dx.juc.test;

import java.util.concurrent.atomic.AtomicInteger;

public class MyThread implements Runnable {
private AtomicInteger serialNumber = new AtomicInteger(); public void run() {
System.out.println(Thread.currentThread().getName() + ":" + getSerialNumber());
} public int getSerialNumber() {
return serialNumber.getAndIncrement();
}
}

将int serialNumber修改AtomicInteger serialNumber就具有原子性,也不在出现异常结果。

CAS算法

CAS(Compare-And-Swap)是一种硬件对并发的支持,针对多处理器操作而设计的,处理器中的一种特殊指令,用于管理对共享数据的并发访问。

CAS是一种无锁的非阻塞算法实现,是硬件对于并发操作的支持,保证了数据变量的原子性。

Cas包含了3个操作数:

  1. 内存值 V
  2. 预估值 A
  3. 更新值 B

当且仅当 V == A 时, V = B; 否则,不会执行任何操作。

简单的来说,CAS有3个操作数,要读写的内存值V,旧的预期值A,要修改的新值B。当且仅当预期值A和内存值V相同时,将内存值V修改为B,否则返回V(不做任何操作,然后重新获取主存V值,重新操作。)。这是一种乐观锁的思路,它相信在它修改之前,没有其它线程去修改它。

CAS算法模拟:

模拟代码:

package com.dx.juc.test;

public class TestCompareAndSwap {
public static void main(String[] args) {
final CompareAndSwap cas = new CompareAndSwap(); for (int i = 0; i < 10; i++) {
new Thread(new Runnable() {
public void run() {
int expectedValue = cas.getValue();
boolean b = cas.compareAndSet(expectedValue, (int) new java.util.Random.nextInt(1000));
System.err.println(b);
}
}).start();
} }
} /**
* 默认CAS
**/
class CompareAndSwap {
// 内存值
private volatile int value = 0; // 返回内存值
public synchronized int getValue() {
return value;
} /**
* 如果预估值与原来的值一直,则修改内存为新的值,否则,不做处理。 无论是否修改,都返回原来的内存值。
**/
public synchronized int compareAndSwap(int expectedValue, int newValue) {
int oldValue = value;
System.out.println("old:" + oldValue + ",expectedValue:" + expectedValue + ",newValue:" + newValue);
if (expectedValue == oldValue) {
value = newValue;
} return oldValue;
} // 如果更新成功,舊的內內存值和預估值相等。
public synchronized boolean compareAndSet(int expectedValue, int newValue) {
return expectedValue == compareAndSwap(expectedValue, newValue);
} }

输出结果:

old:0,expectedValue:0,newValue:224
trueold:224,expectedValue:224,newValue:303
old:303,expectedValue:0,newValue:690
old:303,expectedValue:0,newValue:500 true
false
false
old:303,expectedValue:303,newValue:639
true
old:639,expectedValue:0,newValue:525
false
old:639,expectedValue:303,newValue:978
false
old:639,expectedValue:639,newValue:734
trueold:734,expectedValue:734,newValue:803 old:803,expectedValue:734,newValue:455
true
false

Java-JUC(三):原子性变量与CAS算法的更多相关文章

  1. (一)juc线程高级特性——volatile / CAS算法 / ConcurrentHashMap

    1. volatile 关键字与内存可见性 原文地址: https://www.cnblogs.com/zjfjava/category/979088.html 内存可见性(Memory Visibi ...

  2. 三、原子变量与CAS算法

    原子变量:jdk1.5 后 java.util.concurrent.atomic 包下提供了常用的原子变量: - AtomicBoolean - AtomicInteger - AtomicLong ...

  3. Java多线程-----原子变量和CAS算法

       原子变量      原子变量保证了该变量的所有操作都是原子的,不会因为多线程的同时访问而导致脏数据的读取问题      Java给我们提供了以下几种原子类型: AtomicInteger和Ato ...

  4. 原子变量与CAS算法

    原子变量 为了引出原子变量这个概念,我们先看一个例子. package com.ccfdod.juc; public class TestAtomicDemo { public static void ...

  5. juc-2-原子变量与CAS算法

      i++的原子性问题 例子   int i=10;           i++; 结果   i=10   分析过程                    在计算机 底层 会有生成一个临时变量 tem ...

  6. volatile关键字与内存可见性&原子变量与CAS算法

    1 .volatile 关键字:当多个线程进行操作共享数据时, 可以保证内存中的数据可见 2 .原子变量:jdk1.5后java.util.concurrent.atomic 包下提供常用的原子变量 ...

  7. 原子变量与CAS算法小结

    CAS算法 CAS(compare-and-swap)是一种硬件对并发的支持,针对多处理器操作而设计的处理器中的一种特殊指令,用于管理对共享数据的并发访问. CAS是一种无锁非阻塞算法的实现. CAS ...

  8. 原子变量与CAS算法(二)

    一.锁机制存在的问题 (1)在多线程竞争下,加锁.释放锁会导致比较多的上下文切换和调度延时,引起性能问题. (2)一个线程持有锁会导致其它所有需要此锁的线程挂起. (3)如果一个优先级高的线程等待一个 ...

  9. Java多线程系列——原子类的实现(CAS算法)

    1.什么是CAS? CAS:Compare and Swap,即比较再交换. jdk5增加了并发包java.util.concurrent.*,其下面的类使用CAS算法实现了区别于synchronou ...

随机推荐

  1. HDU 4731 Minimum palindrome (2013成都网络赛,找规律构造)

    Minimum palindrome Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Other ...

  2. AVR Programming Methods

    AVR Programming Methods  There are many ways to program AVR microcontrollers. Since many people ask ...

  3. Timer triggered DMA transfer - Delay between requesting the DMA transfer

    Hello, I'm working with a STM32F407 controller board.   Right now, I want to trigger a DMA transfer ...

  4. 数据库数据格式化之Kettle Spoon

    前言 现在的数据库种类越来越多,数据库备份的格式也越来越复杂,所以数据格式化一直是一个老生常谈的问题.据库备份文件格式那么多,既有SQL的,也有BAK的,还有TXT的等.数据库种类也有很多,MySQL ...

  5. IEnumerable和IQueryable的区别以及背后的ExpressionTree表达式树

    关于IEnumerable和IQueryable的区别,这事还要从泛型委托Func<T>说起.来看一个简单的泛型委托例子: class Program { static void Main ...

  6. C#编程(三十八)----------运算符

    原文链接: http://blog.csdn.net/shanyongxu/article/details/46877353 运算符 类别 运算符 算术运算符 + - * / 逻辑运算符 &  ...

  7. 【JVM】linux上tomcat中部署的web服务,时好时坏,莫名其妙宕机,报错:There is insufficient memory for the Java Runtime Environment to continue.

    =========================================================================================== 环境: linu ...

  8. 【java】java下载文件中换行符 在windows和linux下通用的

    请使用: public static final String FILE_CONTENT_SPLIT_MARK = "\r\n"; 注意 不是"\n\r",顺序 ...

  9. Hybrid App 开发初探:使用 WebView 装载页面

    Hybrid App 是混合模式应用的简称,兼具 Native App 和 Web App 两种模式应用的优势,开发成本低,拥有 Web 技术跨平台特性.目前大家所知道的基于中间件的移动开发框架都是采 ...

  10. 用PopupWindow实现弹出菜单(弹出的菜单采用自定义布局)

         用PopupWindow实现弹出菜单是一个比较好的方式.当然我们还有一个类PopupMenu也能实现弹出菜单,但那个太过于局限了,所以不是很推荐. 这个实例的效果是这样的:点击按钮后,一个菜 ...