volatile关键字

最新推荐文章于 2022-06-25 10:30:13 发布
最新推荐文章于 2022-06-25 10:30:13 发布
阅读量795 收藏 1
点赞数 1
分类专栏： 多线程 文章标签： 多线程 volatile
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/facekbook/article/details/52206640
版权

　　关键字volatile的主要作用是使变量在多个线程间可见。

关键字volatile与死循环：

　　如果不是在多继承的情况下，使用继承Thread类和实现Runnable接口在取得成效运行结果上并没有什么太大的区别。如果一旦出现“多继承”的情况，则用实现Runnable接口的方式来处理多线程的问题是很有必须要的。创建如下代码：

public class PrintString {
    private boolean isContinuePrint = true;

    public boolean isContinuePrint(){
        return true;
    }

    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(Exception e){
            e.printStackTrace();
        }
    }

}

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

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

解决同步死循环：

创建如下代码：

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(){
        while(isContinuePrint){
            System.out.println("run printStringMethod threadName="+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

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

}

public class Run {
    public static void main(String[] args) {
        PrintString printString = new PrintString();
        new Thread(printString).start();
        System.out.println("我要停止它! stopThreadName="+Thread.currentThread().getName());
        printString.setContinuePrint(false);
    }
}

执行结果如下：
这里写图片描述

解决异步死循环：

在使用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){

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

public class Run {
    public static void main(String[] args) throws InterruptedException {
        RunThread runThread = new RunThread();
        runThread.start();
        Thread.sleep(1000);
        runThread.setRunning(false);
        System.out.println("已经赋值为false");
    }
}

执行结果如下：
这里写图片描述
出现死循环了。造成的原因是启动RunThread线程时，变量private boolean isRunning = true;存在于公共堆栈及线程的私有堆栈中，线程一直在私有堆栈中获取isRunning的值是true。而代码runThread.setRunning(false);虽然执行了，更新的却是公共堆栈中的isRunning变量的值为false，所以一直就是死循环的状态。
　　通过使用volatile关键字，强制的从公共内存中读取变量的值。使用volatile关键字增加了实例变量在多个线程之间的可见性。但volatile关键字最致命的缺点是不支持原子性。
　　下面将关键字volatile和synchronized进行一些比较：
　　

  1. 关键字volatile是线程同步的轻量级实现，所有volatile性能肯定比synchronized要好，并且volatile只能修饰于变量，而synchronized可以修改方法及代码块。随着JDK新版本的发布，synchronized关键字在执行效率上得到很大提升，在开发中使用synchronized关键字的比率还是比较大的。
  2. 多线程访问volatile不会发生阻塞，而synchronized会出现阻塞。
  3. volatile能保证数据的可见性，但不能保证原子性；而synchronized可以保证原子性，也可以间接保证可见性，因为它会将私有内存和公共内存中的数据做同步。
    线程安全包含原子性和可见性两个方面，Java的同步机制都是围绕这两个方面来确保线程安全的。
volatile非原子的特性：

　　关键字volatile虽然增加了实例变量在多个线程之间的可见性，但它却不具备同步性，也就是不具备原子性。创建如下代码进行验证：

public class MyThread extends Thread{
    volatile private static int count = 0;
    private static void addCount(){
        for(int i=0;i<100;i++){
            count++;
        }
        System.out.println("count="+count);
    }

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

public class Run {
    public static void main(String[] args) {
        MyThread[] myThreads = new MyThread[100];

        for(int i=0;i<100;i++){
            myThreads[i] = new MyThread();
        }

        for(int i=0;i<100;i++){
            myThreads[i].start();
        }
    }
}

执行结果如下：
这里写图片描述
出现两个相同的值，修改MyThread的代码如下：

public class MyThread extends Thread{
    volatile private static int count = 0;
    synchronized private static void addCount(){
        for(int i=0;i<100;i++){
            count++;
        }
        System.out.println("count="+count);
    }

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

执行结果如下：
这里写图片描述
在addCount方法前面添加了synchronized关键字，这样的话也就没有必要在变量前加volatile关键字。
　　关键字volatile提示线程每次从共享内存中读取变量，而不是从私有内存中读取，这样就保证了同步数据的可见性。但是这里需要注意的是：如果修改实例变量中的数据，如i++，也就是i=i+1，则这样的操作其实并不是一个原子操作，也就是非线程安全的。表达式i++的操作步骤分解如下：

  1. 从共享内存中取出i的值。
  2. 计算i的值。
  3. 将i的值写到内存中。
    加入在第2步的时候，另外一个线程也修改了i的值，那么这个时候就会线程脏数据。解决的办法就是使用synchronized关键字。
    下面用图来演示一下使用volatile关键字出现非线程安全的原因。变量在内存中工作的过程如下图所示：
    这里写图片描述
    　　在多线程的环境中，use和asign是多次出现的的，但这一操作并不是原子性，也就是在read和load之后，如果主内存count变量方式修改之后，线程工作内存中的值由于已经加载，不会产生对应的变化，也就是私有内存和公共内存中的变量不同步，所以计算出来的结果会和预期不一样，也就出现了非线程安全的问题。
    　　对于用volatile修饰的变量，JVM虚拟机只是保证从主内存加载到线程工作内存的值是最新的。例如线程1和线程2在进行read和load的操作中，发现主内存中count的值都是5，那么都会加载这个最新的值。也就是说，volatile关键字解决的是变量读取时的可见性问题，但无法保证原子性，对于多个线程访问同一个实例变量还是需要锁同步。
使用原子类进行i++操作：

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

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

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

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

执行结果如下：
这里写图片描述
程序成功累加到50000。

原子类也并不安全：

原子类在具有逻辑性的情况下输出结果也具有随机性。创建如下代码进行验证：

public class MyService {
    public static AtomicLong atomicLong = new AtomicLong();

     public void addNum(){
        System.out.println(Thread.currentThread().getName()+"加了100之后的值是："+atomicLong.addAndGet(100));
        //再加1
        atomicLong.addAndGet(1);
    }
}

public class MyThread extends Thread{
    private MyService myService;

    public MyThread(MyService myService) {
        this.myService = myService;
    }
    @Override
    public void run() {
        myService.addNum();
    }
}

public class Run {
    public static void main(String[] args) throws InterruptedException {
        MyService myService = new MyService();
        MyThread[] myThreads = new MyThread[5];
        for(int i=0;i<myThreads.length;i++){
            myThreads[i] = new MyThread(myService);
        }
        for(int i=0;i<myThreads.length;i++){
            myThreads[i].start();
        }
        Thread.sleep(1000);
        System.out.println(myService.atomicLong.get());
    }
}

执行结果如下：
这里写图片描述
打印顺序出错了，应该是每加1次100再加1次1。出现这样的情况是因为addAndGet()方法是原子的，但是方法与方法之间却不是原子的。解决这样的问题必须要用同步。修改MyService代码如下：

public class MyService {
    public static AtomicLong atomicLong = new AtomicLong();

     synchronized public void addNum(){
        System.out.println(Thread.currentThread().getName()+"加了100之后的值是："+atomicLong.addAndGet(100));
        //再加1
        atomicLong.addAndGet(1);
    }
}

这里写图片描述
从运行结果可以看到，是每次加100后再加一，这就是我们想要的过程，结果是505的同时还保证过程中累加的顺序也是正确的。

synchronized代码块有volatile同步的功能：

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

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

        }
        System.out.println("停下来了");
    }

    public void stopMethod(){
        isContinueRun = false;
    }
}

public class ThreadA extends Thread{
    private Service service;
    public ThreadA(Service service) {
        this.service = service;
    }

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

public class ThreadB extends Thread{
    private Service service;

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

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

public class Run {
    public static void main(String[] args) throws InterruptedException {
        Service service = new Service();
        ThreadA threadA = new ThreadA(service);
        threadA.start();

        Thread.sleep(1000);
        ThreadB threadB = new ThreadB(service);
        threadB.start();
        System.out.println("已经发起停止的命令");
    }
}

执行结果如下：
这里写图片描述
得到这个结果是各线程间的数据没有可视性造成的，而关键字synchronized可以具有可视性。修改Service类的代码如下：

public class Service {
    private boolean isContinueRun = true;
    public void runMethod(){
        String anyString = new String();
        while(isContinueRun){
            synchronized (anyString) {

            }
        }
        System.out.println("停下来了");
    }

    public void stopMethod(){
        isContinueRun = false;
    }
}

执行结果如下：
这里写图片描述
关键字synchronized可以保证在同一时刻，只有一个线程可以执行某一个方法或某一个代码块。它包含两个特性：互斥和可见性。同步synchronized不仅可以解决一个线程看到对象处于不一致的状态，还可以保障进入同步方法或同步代码块的每个线程，都看到由同一个锁保护之前所有的修改效果。
学习多线并发，要着重“外练互斥，内修可见“。

本文总结:

　　对synchronized有了一定认识，知道什么时候需要使用synchronized关键字。通过学习多线程同步可以控制线程处理数据的顺序，及对处理后的数据进行有效值的保证，更好的对线程执行结果有正确的预期。

在路上的JavaCoder-尹骑
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中volatile关键字实现原理
08-30
本文详细解读一下volatile关键字如何保证变量在多线程之间的可见性,对Java中volatile关键字实现原理感兴趣的朋友一起通过本文学习吧
IBM原厂资深专家：DB2优化器和成本模型分析
最新发布
明明
03-26 452
11月17日，IBM资深软件工程师刘俊老师在DB2用户群进行了一次“浅析DB2优化器和成本模型”的线上主题分享。小编特别整理出其中精华内容，供大家学习交流。 嘉宾简介 IBM资深软件工程师自2005年以来一直从事DB2性能优化的产品研发，包括Visual Explain、Optimization Service Center、Optimization Expert等，在DB2查询优化和性能调优技术上具有多年实践经验帮助IBM技术支持团队处理客户提交的DB2性能问题，利用产品功能帮助客户快速解决性能故障目前致
DB2 RUNSTATS on VOLATILE Tables
weixin_30539835的博客
05-29 146
http://www-01.ibm.com/support/docview.wss?uid=swg21516461 The short answer is yes, runstats is needed even for VOLATILE tables. However, this is something that is often misunderstood because many...
DB2基础知识二
yjdpkto的专栏
10-07 546
 数据库表的建立、修改、删除CREATE TABLE LYLF615."ot_test"(    "id"   INTEGER     NOT NULL GENERATED ALWAYS AS IDENTITY ( START WITH 1, INCREMENT BY 1, NO CYCLE, CACHE 20 ),    "name" VARCHAR(10)PRIMARY KEY (
Java 解决多线程死循环问题
抛弃幻想，准备斗争
03-21 5099
内置类与静态内置类： 在内置类中有两个同步方法，但使用的却是不同的锁，打印的结果也是异步的。 同步代码块synchronized(class)对class上锁后，其他线程只能以同步的方法调用class中的静态同步方法。 锁对象的改变： 在任何数据类型作为同步锁时，需要注意的是，是否有多个线程同时持有锁对象， 如果同时持有相同的锁对象，则这些线程之间就是同步的； 如果分别获取锁对象，这些线程之间就是...
C语言中的volatile关键字
01-19
volatile关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素更改。 　用volatile关键字声明的变量i每被访问时，执行部件都会从i相应的内存单元中取出i的值。 　没有用volatile关键字声明...
解析java中volatile关键字
09-02
主要为大家解析了java中volatile关键字，经常有人把volatile关键字和synchronized或者lock混淆，本文就为大家好好区分，感兴趣的小伙伴们可以参考一下
Java——volatile关键字详解
12-21
volatile是比synchronized关键字更轻量级的同步机制，访问volatile变量时不会执行加锁操作，因此不会使执行线程阻塞。 volatile保证可见性和禁止指令重排序，底层是通过“内存屏障”来实现，但不保证原子性。 写入...
volatile关键字解析
07-09
volatile关键字解析
对象及变量的并发访问（三）——volatial关键字
qq_44307209的博客
06-25 225
   如果不是在多继承的情况下，使用集成Thread类和实现Runnable接口在取得程序运行的结果上并没有什么太大的区别。如果一旦出现“多继承”的情况，则用实现Runnable接口的方式来处理多线程的问题就是很有必要的。    接下来将用实现Runnable接口的方式来继续理解多线程技术的使用，并且使用关键字volatile来实验在并发情况下的一些特性。下面的示例也是适用于集成Thread类。 创建PrintString.java类，代码如下： 运行类Run.java的代码如下: 运行结果如下所示： 程
db2 常用命令
似水流年 -- 韩欣的博客
09-17 1134
1.数据库的启动、停止   db2start --启动   db2stop [force] --停止2.与数据库的连接、断开    db2 CONNECT TO DBName [user UserID using PWD] --建立连接    db2 CONNECT reset /db2 disconnect CURRENT  --断开连接3.实
可见性问题解决 加锁和Volatile关键字
qq_40600507的博客
05-28 797
可见性问题解决方案 加锁 为啥加锁可以解决可见性问题呢？ 因为某一个线程进入synchronized代码块前后，线程会获得锁，清空工作内存，从主内存拷贝共享变量最新的值到工作内存成为副本，执行代码，将修改后的副本的值刷新回主内存中，线程释放锁。 而获取不到锁的线程会阻塞等待，所以变量的值肯定一直都是最新的。 Volatile修饰共享变量 每个线程操作数据的时候会把数据从主内存读取到自己的工作内存...
使用关键字volatile时出现非线程安全的原因。
孤芳不自赏
05-16 683
变量在内存中工作的过程如下图所示。由上，我们可以得出以下结论。read和load阶段：从主存复制变量到当前线程工作内存；use和assign阶段：执行代码，改变共享变量值；store和write阶段：用工作内存数据刷新主存对应变量的值。       在多线程环境中，use和assign是多次出现的，但这一操作并不是原子性，也就是在read和load之后，如果主内存count变量发生修改之后，线程工...
java多线程之-----volatile关键字
简国堂的博客
10-29 310
1关键字与死循环创建测试项目，创建PrintString.java类 public class PrintString { private boolean isContinuePrint=true; public boolean isContinuePrint(){ return isContinuePrint; } public void setCont
Java多线程-volatile关键字
LifeBackwards的专栏
04-10 285
volatile关键字 目录 一 简介 二 volatile关键字的可见性 三 volatile关键字能保证原子性吗？ 四 synchronized关键字和volatile关键字比较 一 简介 Java中的“volatile关键字”： 在 JDK1.2 之前，Java的内存模型实现总是从主存（即共享内存）读取变量，是不需要进行特别的注意的。而在当前的 Java 内存模型下，线程可以...
深入理解Volatile关键字及其实现原理
热门推荐
泽宇的博客
08-06 3万+
volatile的用法 volatile通常被比喻成"轻量级的synchronized"，也是Java并发编程中比较重要的一个关键字。和synchronized不同，volatile是一个变量修饰符，只能用来修饰变量。无法修饰方法及代码块等。 volatile的用法比较简单，只需要在声明一个可能被多线程同时访问的变量时，使用volatile修饰就可以了。 如以下代码，是一个比较典型的使用双...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值