对象及变量的并发访问（三）——volatial关键字

Yarrow-Y

于 2022-06-25 10:30:13 发布

阅读量241

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_44307209/article/details/125429343

版权

1.关键字volatile与死循环

如果不是在多继承的情况下，使用集成Thread类和实现Runnable接口在取得程序运行的结果上并没有什么太大的区别。如果一旦出现“多继承”的情况，则用实现Runnable接口的方式来处理多线程的问题就是很有必要的。
接下来将用实现Runnable接口的方式来继续理解多线程技术的使用，并且使用关键字volatile来实验在并发情况下的一些特性。下面的示例也是适用于集成Thread类。
创建PrintString.java类，代码如下：

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

运行类Run.java的代码如下:

public class Run {
    public static void main(String[] args) {
        PrintString printString = new PrintString();
        printString.printStringMethod();
        System.out.println("停止线程！ stopThread=" + Thread.currentThread().getName());
        printString.setContinuePrint(false);
    }
}

运行结果如下所示：

run printStringMethod threadName =main
run printStringMethod threadName =main
run printStringMethod threadName =main
run printStringMethod threadName =main
run printStringMethod threadName =main

程序开始运行后，线程根本停不下来。

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

2.解决同步死循环

更改一下PrintString类，代码如下：

public class PrintString implements Runnable{
    private boolean isContinuePrint = true;
    public boolean isContinuePrint(){
        return isContinuePrint;
    }

    public void setContinuePrint(boolean isContinuePrint) {
        this.isContinuePrint = isContinuePrint;
    }

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

运行类Run.java代码如下：

public class Run {
    public static void main(String[] args) {
        PrintString printStringService = new PrintString();
        new Thread(printStringService).start();
        System.out.println("停止线程！ stopThread=" + Thread.currentThread().getName());
        printStringService.setContinuePrint(false);
    }
}

运行结果如下所示：

停止线程！ stopThread=main
run printStringMethod threadName =Thread-0

上面的示例代码的格式运行在-server服务器模式中64bit的JVM上时，会出现死循环。解决的办法是使用volatile关键字。

关键字volatile的作用是强制从公共堆栈中取得变量的值，而不是从线程私有数据栈中取得变量的值。

3.解决异步死循环

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

public class RunThread extends Thread{
    private boolean isRunning = true;

    public boolean isRunning() {
        return isRunning;
    }

    public void setRunning(boolean isRunning) {
        this.isRunning = isRunning;
    }

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

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

运行类Run.java代码如下：

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

运行结果为：

进入run
已经赋值false

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

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

修改RunThread代码如下：

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("线程被停止了");
    }
}

运行结果如下：

进入run
已经赋值false
线程被停止了

通过使用volatile关键字，强制的从公共内存中读取变量的值。

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

4.volatile非原子的特性

关键字volatile虽然增加了实例变量在多个线程之间的可见性，但它却不具备同步性，那么也就不具备原子性。
关键字volatile主要使用的场合是在多个线程中可以感知实例变量被更改了，并且可以获得最新的值使用，也就是用多线程读取共享变量时可以获得最新值使用。

关键字volatile提示线程每次从共享内存中读取变量，而不是从私有内存中读取，这样就保证了同步数据的可见性。但在这里需要注意的是：如果修改实例变量中的数据，比如 i++ ，也就是 i=i+1，则这样的操作其实并不是一个原子操作，也就是非线程安全的。表达式i++的操作步骤分解如下：
1、从内存中取出i的值；
2、计算i的值；
3、将i的值写到内存中。
假如在第2步计算值得时候，另外一个线程也修改i的值，那么这个时候就会出现脏数据。解决的办法其实就是使用synchronized关键字，这个知识点在前面的案例中已经介绍过了。所以volatile本身并不处理数据的原子性，而是强制对数据的读写及时影响到主内存的。

在多线程环境中，use和assign是多次出现的。但这一操作并不是原子性，也就是在read和load之后，如果主内存count变量发生修改之后，线程工作内存中的值由于已经加载，不会产生对应变化，也就是私有内存和公共内存中的变量不同步，所以计算出来的结果会和预期不一样，也就出现了非线程安全问题。
对于用volatile修饰的变量，JVM虚拟机只是保证从主内存加载到线程工作内存的值是最新的，例如线程1和线程2在进行read和load的操作中，发现主内存中count的值都是5，那么都会加载这个最新的值。也就是说，volatile关键字解决的是变量读时的可见性问题，但无法保证原子性，对于多个线程访问同一个实例变量还是需要加锁同步。

5.使用原子类进行i++操作

除了在i++操作时使用synchronized关键字实现同步外，还可以使用AtomicInteger原子类。
原子操作时不能分割的整体，没有其他线程能够中断或检查正在原子操作中的变量。一个原子(atomic)类型就是一个原子操作可用的类型，它可以在没有锁的情况下做到线程安全。
创建项目AtomicIntegerTest，，文件AddCountThread.java代码如下：

import java.util.concurrent.atomic.AtomicInteger;

public class AddCountThread extends Thread{
    private AtomicInteger count = new AtomicInteger(0);

    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            System.out.println(count.incrementAndGet());
        }
    }
}

运行类Run.java代码如下：

public class Run {
    public static void main(String[] args) {
        AddCountThread countThread = new AddCountThread();
        Thread t1 = new Thread(countThread);
        t1.start();
        Thread t2 = new Thread(countThread);
        t2.start();
        Thread t3 = new Thread(countThread);
        t3.start();
        Thread t4 = new Thread(countThread);
        t4.start();
        Thread t5 = new Thread(countThread);
        t5.start();

    }
}

运行结果为：

成功累计到50000

6.原子类也并不完全安全

原子类在具有有逻辑性的情况下输出结果也具有随机性。

7.synchronized代码块有volatile同步的功能

关键字synchronized可以使多个线程访问同一个资源具有同步性，而且它还具有将线程工作内存中的私有变量与公共内存中的变量同步的功能。
创建项目synchronizedUpdateNewValue，类Service.java代码如下：

public class Service {
    private boolean isContinueRun = true;
    public void runMethod() {
        while (isContinueRun == true){

        }
        System.out.println("停下来！");
    }
    public void stopMethod() {
            isContinueRun = false;
    }
}

创建线程类，ThreadA.java

public class ThreadA extends Thread{
    private  Service service;

    public ThreadA(Service service){
        this.service = service;
    }
    @Override
    public void run() {
        service.runMethod();
    }
}

创建线程类，ThreadB.java

public class ThreadB extends Thread {
    private Service service;

    public ThreadB(Service service) {
        this.service = service;
    }

    @Override
    public void run() {
        service.stopMethod();
    }
}

创建运行类，Run.java

public class Run {
    public static void main(String[] args) {
        try {
            Service service = new Service();
            ThreadA a = new ThreadA(service);
            a.start();
            Thread.sleep(1000);
            ThreadB b = new ThreadB(service);
            b.start();
            System.out.println("已经发起停止的命令了！");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果如下：

已经发起停止的命令了！

出现死循环

得到这个结果是各线程间的数据值没有可视性造成的，而关键字synchronized可以具有可视性。

修改Service类代码：

public class Service {
    private boolean isContinueRun = true;
    public void runMethod() {
        String string = new String();
        while (isContinueRun == true){
            synchronized (string){}
        }
        System.out.println("停下来！");
    }
    public void stopMethod() {
            isContinueRun = false;
    }
}

运行结果如下：

已经发起停止的命令了！
停下来！

正常运行

关键字synchronized可以保证在同一时刻，只有一个线程可以执行某一个方法或某一个代码块。它包含两个特征：互斥性和可见性。同步synchronized不仅可以解决一个线程看到对象处于不一致的状态，还可以保证进入同步方法或者同步代码块的每个线程，都看到由同一个锁保护之前所有的修改效果。

Yarrow-Y

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
对象及变量的并发访问（三）——volatial关键字

如果不是在多继承的情况下，使用集成Thread类和实现Runnable接口在取得程序运行的结果上并没有什么太大的区别。如果一旦出现“多继承”的情况，则用实现Runnable接口的方式来处理多线程的问题就是很有必要的。接下来将用实现Runnable接口的方式来继续理解多线程技术的使用，并且使用关键字volatile来实验在并发情况下的一些特性。下面的示例也是适用于集成Thread类。创建PrintString.java类，代码如下：运行类Run.java的代码如下:运行结果如下所示：程
复制链接

扫一扫