1. volatile 关键字与内存可见性

原文地址: https://www.cnblogs.com/zjfjava/category/979088.html

  内存可见性(Memory Visibility)是指当某个线程正在使用对象状态而另一个线程在同时修改该状态,需要确保当一个线程修改了对象状态后,其他线程能够看到发生的状态变化。

  可见性错误是指当读操作与写操作在不同的线程中执行时,我们无法确保执行读操作的线程能适时地看到其他线程写入的值,有时甚至是根本不可能的事情。

定义线程类ThreadDemo,功能是将boolean型变量flag的值修改

class ThreadDemo implements Runnable {

    private volatile boolean flag = false;

    @Override
public void run() { try {
Thread.sleep(200);
} catch (InterruptedException e) {
} flag = true; System.out.println("flag=" + isFlag()); } public boolean isFlag() {
return flag;
} public void setFlag(boolean flag) {
this.flag = flag;
} }

测试:线程1修改ThreadDemo类中 flag的值(由false修改为true),线程main方法判断 flag的值,当为true时输出信息,并停止

public class TestVolatile {
//线程main方法判断boolean值,当为true时输出“------------” 并停止线程
public static void main(String[] args) {
ThreadDemo td = new ThreadDemo();
//线程1为ThreadDemo的run方法,将boolean值由false改为true
new Thread(td).start(); while(true){
if(td.isFlag()){
System.out.println("------------------");
break;
}
}
}
}

运行如下:

即由于可见性错误导致线程main方法读取到主存中的flag值并不是线程1修改后的值(读取操作发生在线程1将flag值写入主存之前)。

解决方法:

(1)使用同步锁synchronized,让线程main重复的到主存中读取数据,但是当多线程操作时,效率很低

synchronized (td) {
if(td.isFlag()){
System.out.println("------------------");
break;
} }

(2)使用volatile 变量,用来确保将变量的更新操作通知到其他线程

private volatile boolean flag = false;

可以将 volatile 看做一个轻量级的锁,但是又与锁有些不同:

  • 对于多线程,不是一种互斥关系
  • 不能保证变量状态的“原子性操作”

2. 原子变量与 CAS 算法

以 i++为例,i++操作实际上分为三个步骤

//i++ 的原子性问题:
int i = 10;
i = i++; //10
//i++ 的操作实际上分为三个步骤“读-改-写”
int temp = i;
i = i + 1;
i = temp;

测试如下:

public class TestAtomicDemo {
public static void main(String[] args) {
AtomicDemo ad = new AtomicDemo();
//创建10个线程对serialNumber值进行增加操作
for (int i = 0; i < 10; i++) {
new Thread(ad).start();
}
}
} class AtomicDemo implements Runnable{
//声明volatile变量
private volatile int serialNumber = 0; @Override
public void run() {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
}
System.out.println(getSerialNumber());
}
//对变量进行i++操作
public int getSerialNumber(){
return serialNumber++;
}
}

可能会出现如下结果:

原因为 volatile只能保证内存可见性,但是线程1和线程2中进行的 i++操作却分好几个步骤,即不能保证变量状态的“原子性操作”。

  

解决方法:

使用原子变量(在 java.util.concurrent.atomic 包下)

//    private volatile int serialNumber = 0;
private AtomicInteger serialNumber = new AtomicInteger(0); public int getSerialNumber(){
// return serialNumber++;
return serialNumber.getAndIncrement();
}

以 AtomicInteger分析原子变量的实现

(1)volatile 保证内存可见性

  

(2)CAS(Compare-And-Swap) 算法保证数据变量的原子性

  

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

CAS 是一种无锁的非阻塞算法的实现。

CAS 包含了 3 个操作值:

  • 需要读写的内存值 V
  • 进行比较的值 A
  • 拟写入的新值 B

当且仅当 V 的值等于 A 时,CAS 通过原子方式用新值 B 来更新 V 的值,否则不会执行任何操作。

可通过源码查看sun.misc.Unsafe.class中的getAndAddInt方法实现来理解CAS算法

public final int getAndAddInt(Object paramObject, long paramLong, int paramInt)
{
int i;
do
{
i = getIntVolatile(paramObject, paramLong);
} while (!compareAndSwapInt(paramObject, paramLong, i, i + paramInt));
return i;
}

3. 模拟CAS算法

/*
* 模拟 CAS 算法
*/
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() {
@Override
public void run() {
int expectedValue = cas.get();
boolean b = cas.compareAndSet(expectedValue, (int)(Math.random() * 101));
System.out.println(b);
}
}).start();
}
}
} class CompareAndSwap{
private int value;
//获取内存值
public synchronized int get(){
return value;
}
//比较
public synchronized int compareAndSwap(int expectedValue, int newValue){
int oldValue = value;
if(oldValue == expectedValue){
this.value = newValue;
}
return oldValue;
}
//设置
public synchronized boolean compareAndSet(int expectedValue, int newValue){
return expectedValue == compareAndSwap(expectedValue, newValue);
}
}

4. 同步容器类 ConcurrentHashMap

Java 5.0 在 java.util.concurrent 包中提供了多种并发容器类来改进同步容器的性能。

ConcurrentHashMap 同步容器类是Java 5 增加的一个线程安全的哈希表。对与多线程的操作,介于 HashMap 与 Hashtable 之间。内部采用“锁分段”机制(可理解为“并行”)替代 Hashtable 的独占锁(相当于“串行”),进而提高性能。

注意:jdk1.8之后ConcurrentHashMap底层采用的 CAS算法 取代“锁分段”机制。

此包还提供了设计用于多线程上下文中的 Collection 实现:

ConcurrentHashMap、ConcurrentSkipListMap、ConcurrentSkipListSet、CopyOnWriteArrayList 和 CopyOnWriteArraySet。

  • 当期望许多线程访问一个给定 collection 时,ConcurrentHashMap 通常优于同步的 HashMap,ConcurrentSkipListMap 通常优于同步的 TreeMap。
  • 当期望的读数和遍历远远大于列表的更新数时,CopyOnWriteArrayList 优于同步的 ArrayList。
/*
* CopyOnWriteArrayList/CopyOnWriteArraySet : “写入并复制”
* 注意:添加操作多时,效率低,因为每次添加时都会进行复制,开销非常的大。并发迭代操作多时可以选择。
*/
public class TestCopyOnWriteArrayList {
public static void main(String[] args) {
HelloThread ht = new HelloThread();
for (int i = 0; i < 10; i++) {
new Thread(ht).start();
}
}
} class HelloThread implements Runnable{ // 使用ArrayList,报错java.util.ConcurrentModificationException
// private static List<String> list = Collections.synchronizedList(new ArrayList<String>()); private static CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
static{
list.add("AA");
list.add("BB");
list.add("CC");
} @Override
public void run() {
Iterator<String> it = list.iterator();
while(it.hasNext()){
//迭代和add方法操作同一个数据源
System.out.println(it.next());
list.add("AA");
}
}
}

(一)juc线程高级特性——volatile / CAS算法 / ConcurrentHashMap的更多相关文章

  1. (二)juc线程高级特性——CountDownLatch / Callable / Lock

    5. CountDownLatch 闭锁 Java 5.0 在 java.util.concurrent 包中提供了多种并发容器类来改进同步容器的性能. CountDownLatch 一个同步辅助类, ...

  2. (四)juc线程高级特性——线程池 / 线程调度 / ForkJoinPool

    13. 线程池 第四种获取线程的方法:线程池,一个 ExecutorService,它使用可能的几个池线程之一执行每个提交的任务,通常使用 Executors 工厂方法配置. 线程池可以解决两个不同问 ...

  3. 7.JUC线程高级-生产消费问题&虚假唤醒

    描述 生产消费问题在java多线程的学习中是经常遇到的问题 ,多个线程共享通一个资源的时候会出现各种多线程中经常出现的各种问题. 实例说明 三个类:售货员Clerk,工厂Factory,消费者Cons ...

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

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

  5. jvm高级特性(6)(线程的种类,调度,状态,安全程度,实现安全的方法,同步种类,锁优化,锁种类)

    JVM高级特性与实践(十三):线程实现 与 Java线程调度 JVM高级特性与实践(十四):线程安全 与 锁优化 一. 线程的实现 线程其实是比进程更轻量级的调度执行单位. 线程的引入,可以把一个检查 ...

  6. jvm高级特性(5)(1)(原子性,可见性,有序性,volatile,概述)

    JVM高级特性与实践(十二):高效并发时的内外存交互.三大特征(原子.可见.有序性) 与 volatile型变量特殊规则 简介: 阿姆达尔定律(Amdahl):该定律通过系统中并行化与串行化的比重来描 ...

  7. jvm高级特性(2)(判断存活对象算法,finaliza(),方法区回收)

    JVM高级特性与实践(二):对象存活判定算法(引用) 与 回收 垃圾回收器GC(Garbage Collection) 于1960年诞生在MIT的Lisp是第一门真正使用内存动态分配和垃圾收集技术的语 ...

  8. 详解 volatile关键字 与 CAS算法

    (请观看本人博文 -- <详解 多线程>) 目录 内存可见性问题 volatile关键字 CAS算法: 扩展 -- 乐观锁 与 悲观锁: 悲观锁: 乐观锁: 在讲解本篇博文的知识点之前,本 ...

  9. (转)利用CAS算法实现通用线程安全状态机

    在多线程环境下,如果某个类是有状态的,那我们在使用前,需要保证所有该类的实例对象状态一致,否则会出现意向不到的bug.下面是通用线程安全状态机的实现方法. public class ThreadSav ...

随机推荐

  1. MySQL读取配置文件的顺序、启动方式、启动原理

    一.MySQL读取配置文件的顺序 读取顺序:/etc/my.cnf > /etc/mysql/my.cnf > /usr/etc/my.cnf > ~/.my.cnf 命令验证:[r ...

  2. ASP.NET -- WebForm -- Cookie的使用 应用程序权限设计 权限设计文章汇总 asp.net后台管理系统-登陆模块-是否自动登陆 C# 读写文件摘要

    ASP.NET -- WebForm -- Cookie的使用 ASP.NET -- WebForm --  Cookie的使用 Cookie是存在浏览器内存或磁盘上. 1. Test3.aspx文件 ...

  3. Linux内核剖析(五)Linux内核的构建过程

    参考 一次实验引发的故事 – kernel build system探索—vmlinux是如何炼成的– kernel makefile 深度探索Linux操作系统:系统构建和原理解析.pdf 问题 在 ...

  4. PHP会员找回密码功能实现实例介绍

    设置思路 1.用户注册时需要提供一个E-MAIL邮箱,目的就是用该邮箱找回密码. 2.当用户忘记密码或用户名时,点击登录页面的“找回密码”超链接,打开表单,并输入注册用的E-MAIL邮箱,提交. 3. ...

  5. ip代理优化

    如何保证可用ip不低于2000个,代理ip池优化策略 第一:获得大量ip: 第二:验证可用ip: 第三:监控可用ip: 第三:保证可用ip不低于3000或者5000: 截图是实时可用ip数量 心得:不 ...

  6. python的类和对象(类的静态字段)

    转自:http://www.cnblogs.com/Eva-J/p/5044411.html 什么是静态字段 在开始之前,先上图,解释一下什么是类的静态字段(我有的时候会叫它类的静态变量,总之说的都是 ...

  7. Java中的不可变类理解

    一.Java中的不可变类 不可变类(Immutable Objects):当类的实例一经创建,其内容便不可改变,即无法修改其成员变量. 可变类(Mutable Objects):类的实例创建后,可以修 ...

  8. SQL Server In-Memory OLTP Internals for SQL Server 2016

    SQL Server In-Memory OLTP Internals for SQL Server 2016 这份白皮书是在上一份<SQL Server In-Memory OLTP Inte ...

  9. 双网卡双线路DNS解析分析

    在企业网络维护过程中我们经常会遇到这样或那样的奇怪问题,而很多问题需要有深厚的理论知识才能解决.而随着网络的飞速发展越来越多的中小企业开始尝试通过多条线路来保证网络的畅通,一方面双网卡下的双线接入可以 ...

  10. 【iCore4 双核心板_uC/OS-II】例程一:认识 uC/OS-II

    一.实验说明: 本例程移值入uC/OS-II,建立三个任务,红色和绿色LED分别以固定频率闪烁,并且打开串口工具, 输出浮点数据. 二.源代码下载链接: 链接:https://pan.baidu.co ...