多线程之volatile方法(1)

关键字volatile的主要作用是使变量在多个线程间可见。
1.关键字volatile与死循环
如果不是在多继承的情况下，使用集成Thread类和实现Runnable接口在取得程序运行的结果上并没有什么太大的区别。如果一旦出现“多继承”的情况，则用实现Runnable接口的方式来处理多线程的问题就是很有必要的。
我这边将用实现Runnable接口的方式来继续理解多线程技术的使用，并且使用关键字volatile来实验在并发情况下的一些特性。同理也是适用于集成Thread类。

package volatileTest;

/**
 * @Author LiBinquan
 */
public class PrintString {
    private boolean isContinuePrint = true;
    public boolean isContinuePrint(){
        return isContinuePrint;
    }

    public void setContinuePrint(boolean continuePrint) {
        isContinuePrint = continuePrint;
    }
    
    public void printStringMethod(){
        try{
            while(isContinuePrint == true){
                System.out.println("run printStringMethod threadName ="+Thread.currentThread().getName());
                Thread.sleep(1000);
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

运行类：

package volatileTest;

/**
 * @Author LiBinquan
 */
public class Run {
    public static void main(String[] args) {
        PrintString printString = new PrintString();
        printString.printStringMethod();
        System.out.println("使线程停止");
        printString.setContinuePrint(false);
    }
}

输出：

线程开始运行后，线程根本停不下来。
停不下来的原因主要就是main线程一直在处理while()循环，导致程序不能继续执行后面的代码。解决的办法当然是用多线程技术。

2.解决同步死循环

这边修改一下PrintString类，代码如下：

package volatileTest;

/**
 * @Author LiBinquan
 */
public class PrintString implements Runnable{
    private boolean isContinuePrint = true;
    public boolean isContinuePrint(){
        return isContinuePrint;
    }

    public void setContinuePrint(boolean continuePrint) {
        isContinuePrint = continuePrint;
    }

    public void printStringMethod(){
        try{
            while(isContinuePrint == true){
                System.out.println("run printStringMethod threadName ="+Thread.currentThread().getName());
                Thread.sleep(1000);
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        printStringMethod();
    }
}

运行类：

package volatileTest;

/**
 * @Author LiBinquan
 */
public class Run {
    public static void main(String[] args) {
        PrintString printString = new PrintString();
        Thread thread = new Thread(printString);
        thread.start();
        System.out.println("使线程停止");
        printString.setContinuePrint(false);
    }
}

输出：

上面的示例代码的格式运行在-server服务器模式中64bit的JVM上时，会出现死循环。解决的办法是使用volatile关键字。
关键字volatile的作用是强制从公共堆栈中取得变量的值，而不是从线程私有数据栈中取得变量的值。

3.解决异步死循环

在说volatile关键字之前，来做一个死循环实验，代码如下：

package volatileTest;

/**
 * @Author LiBinquan
 */
public class RunThread extends Thread{
    private boolean isRunning = true;

    public boolean isRunning() {
        return isRunning;
    }

    public void setRunning(boolean running) {
        isRunning = running;
    }

    @Override
    public void run() {
        System.out.println("进入run");
        while(isRunning){
            
        }
        System.out.println("线程停止了");
    }
}

运行类：

package volatileTest;

/**
 * @Author LiBinquan
 */
public class Run {
    public static void main(String[] args) {
        try{
            RunThread thread = new RunThread();
            thread.start();
            Thread.sleep(1000);
            thread.setRunning(false);
            System.out.println("已经赋值false");
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

输出：

这边可以看到代码“ System.out.println(“线程停止了”); ”从未被执行。这就出现了死循环。
这是为什么呢，在启动RunThread线程时，变量private boolean isRunning = true；存在于公共堆栈及线程的私有堆栈中。线程一直在私有堆栈中取得isRunning的值是true。而代码thread.setRunning(false)虽然被执行了 ，更新的确实公共堆栈中的isRunning变量值false，所以一直就是死循环的状态。简单的内存模型如下：

这个问题其实就是私有堆栈中的值和公共堆栈中的值不同步造成的。解决这样的问题就要使用volatile关键字了，它主要的作用就是当线程访问isRunning这个变量时，强制性从公共堆栈中进行取值。
修改代码如下：

package volatileTest;

/**
 * @Author LiBinquan
 */
public class RunThread extends Thread{
    volatile private boolean isRunning = true;

    public boolean isRunning() {
        return isRunning;
    }

    public void setRunning(boolean running) {
        isRunning = running;
    }

    @Override
    public void run() {
        System.out.println("进入run");
        while(isRunning){

        }
        System.out.println("线程停止了");
    }
}

输出：

通过使用volatile关键字，强制的从公共内存中读取变量的值，内存结构如图：

使用volatile关键字增加了实例变量在多个线程之间的可见性。但volatile关键字最致命的确定是不支持原子性。
下面将关键字synchronized和volatile进行比较：
1.关键字volatile是线程同步的轻量级实现，所以volatile性能肯定比synchronized要好，并且volatile只能修饰变量，而synchronized可以修饰方法，以及代码块。随着JDK新版本的发布，synchronized关键字在执行效率上得到很大提升，在开发中使用synchronized关键字的比率还是比较大的。
2.多线程访问volatile不会发生阻塞，而synchronized会出现阻塞。
3.volatile能保证数据的可见性，但不能保证原子性；而synchronized可以保证原子性，也可以间接保证可见性，因为它会将私有内存和公共内存中的数据做同步。此知识点在后面有实验做论证。
4.再次重申一下，关键字volatile解决是变量在多个线程之间的可见性；而synchronized关键字解决的是多个线程之间访问资源的同步性。

线程安全包含原子性和可加性两个方面，Java的同步机制都是围绕这两个方面来确保线程安全的。