java并发编程的艺术（2）浅谈volatile和synchronized

再多线程编程里面，难免避免不了volatile和synchronized这两个关键字。关于volatile这个关键字，最著名的就是“可见性”问题了，所谓的可见性问题是指：当有多个线程访问同一个共享变量，并且对这个变量进行修改之后，另外的一个线程里面可以读取到这个最新修改的值。

关于volatile的定义和原理

Java语言规范第3版中对volatile的定义如下：Java编程语言允许线程访问共享变量，为了确保共享变量能被准确和一致地更新，线程应该确保通过排他锁单独获得这个变量。Java语言提供了volatile，在某些情况下比锁要更加方便。如果一个字段被声明成volatile，Java线程内存模型确保所有线程看到这个变量的值是一致的。

那么，在使用了volatile关键字定义之后，到底代码的底层发生了什么变化呢？ 按照《java并发编程的艺术》这本书里面的内容介绍是说，相应的汇编代码被添加了一个叫做lock的前缀指令，但是光是书本这么说还是太浅显了。lz在网上找了各种文章，最后找到了一篇介绍如何通过class文件转译成为汇编代码的内容。
以下附上相应链接：
https://www.cnblogs.com/xrq730/p/7048693.html

通过自己对于代码的汇编转码之后，可以看到命令窗口里面出现以下相应的关键字内容：

LZ发现，在使用了volatile关键字进行修饰的变量在转换成汇编代码的时候会多出来一个lock的指令内容。

说了这么多，还是用一个案例来讲解volatile关键字的用处吧
关于volatile的代码案例如下所示：

package 并发编程02.volatile关键字案例;

//变量的可见性
public class VolatileVisible {
    boolean ready=true;
    private final static int SIZE=100;

    public static void main(String[] args) throws InterruptedException {
        VolatileVisible[] vv=new VolatileVisible[SIZE];
        for (int i=0;i<SIZE;i++) {
            (vv[i]=new VolatileVisible()).test();
        }
        System.out.println("---------");
    }

    public void test() throws InterruptedException {
        Thread t2=new Thread(){
            public void run(){
                System.out.println("t2:"+ready);
                while (ready){};
                System.out.println("this is end!");
            }
        };
        Thread t1=new Thread(){
            public void run(){
                ready=false;
            }
        };
        t2.start();
        Thread.yield();
        t1.start();
        t1.join();
        t2.join();
    }
}

这个案例中，可能会出现死循环的情况，这是因为不同线程他们本地缓存里面的ready并没有被设置为false，所以会一直进入循环状态。那么又该如何调整呢？加入一个volatile关键字即可改变。
在ready变量前边加入一个volatile关键字即可。使用了volatile关键字修饰的变量，会对引用到相应变量的线程里面的该变量信息进行及时同步。编译器在运行时会注意到该变量是一个共享变量，因此会及时将其同步到各个线程的本地缓存当中。
在访问volatile变量时不会执行加锁操作，因此也就不会使执行线程阻塞，因此volatile变量是一种比sychronized关键字更轻量级的同步机制。

一旦某一个变量A被申明了volatile关键字之后，就会具有以下两种特性：
1.保证改变量的可见性：当某个线程对A进行了相应的修改之后，其他线程里面的A也会及时更新，每次使用该变量之前都会在从主内存中提取到自己的cpu缓存中。

2.禁止指令重排序优化。有volatile修饰的变量，赋值后多执行了一个“load addl $0x0, (%esp)”操作，这个操作相当于一个内存屏障（指令重排序时不能把后面的指令重排序到内存屏障之前的位置），只有一个CPU访问内存时，并不需要内存屏障；（什么是指令重排序：是指CPU采用了允许将多条指令不按程序规定的顺序分开发送给各相应电路单元处理）。

关于synchronized

在多线程并发编程中synchronized一直是元老级角色，很多人都会称呼它为重量级锁。但是，随着Java SE 1.6对synchronized进行了各种优化之后，有些情况下它就并不那么重了。本文详细介绍Java SE 1.6中为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁，以及锁的存储结构和升级过程。

在synchronized里面，包含有三种常见的锁状态：

对于普通的同步方法：
锁是当前的对象
对于静态函数的同步方法：
锁是指引用当前类的class对象
对于同步方法块的内容：
锁是指Synchonized括号里配置的对象

那么接下来还是用一个案例来进行讲解吧：

在多线程里面总会提及到一个线程安全的问题，那么让我们来理解一下什么是线程安全问题吧！首先，让我们来了解一下什么是线程安全吧：
所谓的线程安全就是指：多个线程同时对于一个全局变量进行写的操作！！！
那么如何防止这类危害发生呢？我们需要加一个叫做线程锁的东西：
具体让我们来看下代码案例：（模拟抢火车票的场景）

package com.sise.lab02;

class ThreadTrainl implements Runnable{
    private int trainCount=100;
    public Object obj=new Object();

    //局部变量不会受到线程安全问题的影响
    @Override
    public void run() {
        while (trainCount>0){
            try{
                Thread.sleep(50);
            }catch (Exception e){
            }
            sale();
        }
    }


    private  void sale() {
        //同步代码块 ---走到这个位置的时候，可能会有多个线程进行访问，谁先拿到锁谁就先进行购票
            synchronized (obj) {
                if (trainCount > 0) {
                    System.out.println(Thread.currentThread().getName() + ":开始售出第" + (100 - trainCount + 1) + "" + "张票");
                }
                trainCount--;
            }
        }
    }

//模拟火车站抢票
public class ThreadMain {
    public static void main(String[] args) {
        //为了模拟有两个窗口在抢票
        ThreadTrainl threadTrainl=new ThreadTrainl();
        Thread t1= new Thread(threadTrainl,"窗口1");
        Thread t2= new Thread(threadTrainl,"窗口2");
        t1.start();
        t2.start();
    }
}

原本如果不加锁的话，容易出现的问题就是，两个线程同时访问到sale方法，对票数造成
数据的影响，导致线程的不安全问题

同步的前提是：
1.必须要有两个或者以上的线程才可以：
2.必须是多个线程使用同一个锁
3.必须要争同步中只能由一个线程在运行

线程锁synchronized的原理就是：
第一个访问到这把锁的线程先使用，然后其他线程处于等待状态，当锁释放了以后，其他线程就可以上前去访问了，这个时候，就会出现了相应的资源抢占情况毕竟抢锁，是一件相当消耗资源的事情
优点：
可以防止线程安全问题
缺点：
占用资源

说到了锁，顺便可以提一下，还有一种锁 Reetrantlock是jdk5里面自带的，需要手动释放锁才可以。

上边那我们提到的是同步锁，另外一种方式是同步函数在方法前边加一个synchronized即可：
private synchronized void sale()
那么这个时候我们需要来进行深入研究了，同步函数究竟是用的什么锁呢？
答案是 this锁。
那么该如何进行证明呢？请看下边这个案例：

package com.sise.lab02;

class ThreadTrain2 implements Runnable{
    private int trainCount=100;
    public Object obj=new Object();

    public boolean flag=true;
    //局部变量不会受到线程安全问题的影响
    @Override
    public void run() {
        if(flag){
            while (trainCount>0) {
                try {
                    Thread.sleep(50);
                } catch (Exception e) {
                }
                //使用了同步代码块，里面用的是this锁
                synchronized (obj) {
                    if (trainCount > 0) {
                        System.out.println(Thread.currentThread().getName() + ":开始售出第" + (100 - trainCount + 1) + "" + "张票");
                    }
                    trainCount--;
                }
            }
        }else{
            while (trainCount>0) {
                try {
                    sale();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }


    private synchronized void sale() throws InterruptedException {
        //同步代码块 ---走到这个位置的时候，可能会有多个线程进行访问，谁先拿到锁谁就先进行购票
            if (trainCount > 0) {
                Thread.sleep(40);
                System.out.println(Thread.currentThread().getName() + ":开始售出第" + (100 - trainCount + 1) + "" + "张票");
            }
            trainCount--;
        }
    }


//模拟火车站抢票
public class ThreadMain02 {
    public static void main(String[] args) throws InterruptedException {
        //为了模拟有两个窗口在抢票
        ThreadTrain2 threadTrain2=new ThreadTrain2();
        Thread t1= new Thread(threadTrain2,"窗口1");
        Thread t2= new Thread(threadTrain2,"窗口2");
        t1.start();
        Thread.sleep(40);
        threadTrain2.flag=false;
        t2.start();
    }
}

因为两个函数里面使用的锁一个是this，一个是obj，所以访问的时候不能避免线程安全问题，因此会出现冲突的结果：售出第101张票。