轻量级同步机制：volative关键字

volative的作用

关键作用是使变量在多个线程之间可见

public class VolativeText {
    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线程修改布尔值之后，子线程看不到值的修改。因此要想实现线程的可见性这里可以加上volative关键字修饰公共变量

volative关键字的作用：使线程在强制公共内存中读取变量值，保证可见性

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个

使用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());
    }
}