轻量级同步机制：volatile关键字
volatile的作用
关键作用是使变量在多个线程之间可见
public class VolatileText { public static void main(String[] args) throws InterruptedException { Student student=new Student(); new Thread(new Runnable() { @Override public void run() { student.GetMethon(); } }).start(); Thread.sleep(1000);//睡眠之后修改布尔值 student.GetName(false);//改变布尔值以结束程序运行 } static class Student { public boolean flag=true; public Student GetName(boolean flag) { this.flag=flag; return this; } public void GetMethon() { System.out.println("开始"); while (flag){//死循环 } System.out.println("结束"); } } }
程序并没有因为我修改之后结束运行，因为线程对共享变量具有不可见性，main线程修改布尔值之后，子线程看不到值的修改。因此要想实现线程的可见性这里可以加上volatile关键字修饰公共变量
volatile关键字的作用：使线程在强制公共内存中读取变量值，保证可见性
volatile非原子特性
public class Text10 extends Thread { private volatile static int count; @Override public void run() { Addcount(); } public static void Addcount() { for (int i = 0; i < 1000; i++) { count++; } System.out.println(Thread.currentThread().getName()+"-->"+count); } public static void main(String[] args) { for (int i = 0; i < 10; i++) { Text10 text10=new Text10(); text10.start(); } } }
按道理输出1000的整数倍数才对，但是变量在自增的过程中没有更新到又被读取再修改，因此volatile不具备原子性，正确办法将方法加上synchronized关键字
volatile与synchronized比较
- volatile关键字是线程同步的轻量级实现，所以volatile性能肯定比synchronized要好，volatile只能修饰变量，而synchronized可以修饰方法代码块，在开发中使用synchronized比例还是挺大的。
- 多线程访问volatile变量不会发生阻塞，而synchronized可能会阻塞。
- volatile能保证数据的可见性，但是不能保证原子性，而synchronized可以保证原子性，也可以保证可见性，因为
- synchronized会将线程的工作内存和主内存进行同步
- volatile关键字保证多个线程之间的可见性，synchronized关键字解决线程访问公共资源的同步性。
| 区别 | synchronized | volatile |
| 使用上 | 只能用于修饰方法、代码块 | 只能修饰实例变量或者类关键字 |
| 原子性保证 | 能保证，锁可以保护数据不被打断 | 无法保证 |
| 可见性保证 | 能保证，排它方式使同步代码串行 | 能保证，可以读取公共变量 |
| 有序性保证 | 能保证，在同步串行的时候 | 能保证，禁止JVM以及处理器进行排序 |
| 阻塞情况 | 会发生阻塞 | 不会发生阻塞 |
常用原子类进行自增自减操作
i++不是原子操作，除了使用synchronized进行同步，也可以使用AtomicInteger/AtomicLong进行实现
import java.util.concurrent.atomic.AtomicInteger; public class Text10 extends Thread { private static AtomicInteger count=new AtomicInteger(); @Override public void run() { AddCount(); } public static void AddCount() { for (int i = 0; i < 1000; i++) { count.getAndIncrement();//相当于i++ //count.incrementAndGet();//相当于++i } System.out.println(Thread.currentThread().getName()+"-->"+count.get()); } public static void main(String[] args) { for (int i = 0; i < 10; i++) { Text10 text10=new Text10(); text10.start(); } } }
CAS
CAS（Compare And Swap）是由硬件实现的，
CAS可以将read（读）-modify（修改）-write（写）转化为原子操作
i++自增过程：
从主内存调取i变量值
对i值加1
再把加1过后的值保存到主内存
CAS原理：在把数据更新到主内存时，再次读取主内存变量的值，如果现在变量的值与期望的值一样就更新。
使用CAS原理实现线程安全计数器
public class CASText { public static void main(String[] args) { CASControl casControl=new CASControl(); for (int i = 0; i <10000 ; i++) { new Thread(new Runnable() { @Override public void run() { System.out.println(Thread.currentThread().getName()+"==>"+casControl.incrementAndGet()); } }).start(); } } } class CASControl { volatile static long value;//使用volatile修饰线程可见性 public long getValue() { return value; } private boolean Expect(long oldValue,long newValue) { synchronized (this) { if(value==oldValue) { value=newValue; return true; } else return false; } } public long incrementAndGet() { long oldvalue; long newValue; do { oldvalue=value; newValue=oldvalue+1; }while (!Expect(oldvalue, newValue)); return newValue; } }
CAS中的ABA问题
CAS实现原子操作背后有一个假设：共享变量当前值与当前线程提供的期望值相同，就认为变量没有被其他线程过。
实际上这种假设不一定成立，假如count=0
A线程对count值修改为10
B线程对count值修改为30
C线程对count值修改为0
当前线程看到count=0，不能认为count没有被其他线程更新，这种结果是否能被接受？
这就是CAS中的ABS问题即共享变量经过了A=》B=》A的更改
是否能够接受ABA问题跟算法实现有关
如果想要规避ABA问题，可以为共享变量引入一个修订号，或者时间戳，每次修改共享变量值，相应的修订号加1.，就会变更为[A,0]=>[B,1]=>[A,2]，每次对共享变量的修改都会导致共享变量的增加，通过这个标识就可以判断。AtomicStampedReference类就是基于这个思想产生的。
原子变量类
原子类变量是基于CAS实现的，当对共享变量进行read（读）-modify（修改）-write（写）操作时，通过原子类变量可以保障原子性与可见性，对变量的read（读）-modify（修改）-write（写）操作不是指一个简单的赋值，而是变量的新值，依赖变量的旧值，如自增操作i++，由于volatile只能保证原子的可见性，而不能保证原子性，原变量类内部就是一个借助volatile变量，并且保障了该变量的read-modify-wirte操作的原子性，有时把原子变量看作一个增强的volatile变量，原子变量类有12个
| 分组 | 原子变量类 |
| 基础数据型 | AtomicInteger、AtomicLong、AtomicBoolean |
| 数组型 | AtomicIntegerArry、AtomicLongArry、AtomicReferenceArry |
| 字段更新器 | AtomocIntegerFiledUpdater、AtomicLongFieldUpdate、AtomicReferenceFiledUpdater |
| 引用型 | AtomicReference、AtomicStampedReference、AtomicMarkableReference |
使用AtomicLong定义计数器
import java.util.Random; import java.util.concurrent.atomic.AtomicLong; public class Text15 { //构造方法私有化 private Text15(){} //私有静态对象 private static final Text15 text=new Text15(); //公共静态方法返回该类的实例 public static Text15 getInstance() { return text; } //使用原子类记录保存请求总数 成功数 失败数 private final AtomicLong RequestCount=new AtomicLong(0); private final AtomicLong SuccessCount=new AtomicLong(0); private final AtomicLong FailCount=new AtomicLong(0); //进行自增 public void RequestCount() { RequestCount.incrementAndGet(); } public void SuccessCount() { SuccessCount.incrementAndGet(); } public void FailCount() { FailCount.incrementAndGet(); } //查看总数 public long GetRequestCount() { return RequestCount.get(); } public long GetSuccessCount() { return SuccessCount.get(); } public long GetFailCount() { return FailCount.get(); } } class Text16 { public static void main(String[] args) throws InterruptedException { new Thread(new Runnable() { @Override public void run() { for (int i = 0; i <1000 ; i++) { Text15.getInstance().RequestCount();//请求数量 int num=new Random().nextInt(); if(num%2==0)//如果是偶数就成功 { Text15.getInstance().SuccessCount(); } else Text15.getInstance().FailCount(); } } }).start(); Thread.sleep(1000); System.out.println("请求总数："+Text15.getInstance().GetRequestCount()); System.out.println("请求成功"+Text15.getInstance().GetSuccessCount()); System.out.println("请求失败"+Text15.getInstance().GetFailCount()); } }
