volatile相关问题（volatile特点，happens-before，8种方式实现单例，volatile使用场景，volatile和synchronized的区别）

最新推荐文章于 2025-02-28 08:48:11 发布
最新推荐文章于 2025-02-28 08:48:11 发布
阅读量133 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wozhendeb/article/details/112641691
版权

volatile的特点

  1. 保证可见性
package com.JUC编程.volatile0;
import java.util.concurrent.TimeUnit;
public class demo1 {
    private static  volatile Boolean flag=true;
    public static void main(String[] args)  {
        new Thread(()->{
            while(flag){

            }
        }).start();

        new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            flag=false;
            System.out.println("修改了flag的值");
        }).start();
    }
}
  1. 不保证原子性
package com.JUC编程.volatile0;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
public class demo2 {
    public static void main(String[] args) throws InterruptedException {
        //原子性的验证
        //使用栅栏保证所有的线程有执行完
        CountDownLatch countDownLatch = new CountDownLatch(100);
        Resource resource = new Resource();
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                try {
                    resource.add();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                countDownLatch.countDown();
            }).start();
        }
        countDownLatch.await();
        System.out.println(resource.num);
    }
}
class Resource{
    volatile int num=0;
    // AtomicInteger atomicInteger=new AtomicInteger();使用原子类可以解决
    public void add() throws InterruptedException {
        for (int i = 0; i < 20; i++) {
            TimeUnit.MICROSECONDS.sleep(20);
            num++;
        }
    }
}
  1. 禁止指令重排
  • 重排序：为了提高性能，编译器和处理器会对既定的代码执行顺序进行指令重排序。再不改变程序执行结果的前提下，尽可能提高执行效率，JVM对底层尽量减少约束，使其能够发挥自身优势

happens-before

  1. 什么是happens-before？

上面的内容我们知道，为了提高处理速度，JVM会对代码进行优化，也就是指令重排序优化，并发编程下指令重排序会带来一些安全隐患：如指令重排序会导致的多个线程操作之间的不可见性。从JDK1.5开始，提出了happens-before的概念通过这个概念来阐述操作之间的内存可见性，**如果一个操作执行的结果需要对另一个操作可见，那么这两个操作之间必须存在happens-before关系。**这里提到的两个操作既可以是在一个线程内，也可以是在两个线程之间。

所以为了解决多线程的可见性问题，就高出了happens-before原则，让线程之间遵循这些原则，编译器还会优化我们的语句，所以等于是给了编译器优化的约束，不能让其优化的不知道东南西北了！

简单来说happens-before：前一个操作的结果可以被后续的操作会获取。前面一个操作将a赋值，那后一个操作肯定能知道a已经变成1了。

  1. happens-before规则
  • 程序顺序规则（单线程规则）
    解释：同一个线程中前面的操作对后面的操作可见
  • 锁规则（synchronized， lock）
    解释：对一个线程的解锁，可见于随后的这个锁的加锁
    简单来说：就是想如果线程1解锁了monitor a，接着线程2锁定了a，那么线程1解锁a之前的操作都对线程2可见（线程1和线程2是同一个线程）
  • volatile变量规则
    解释：对一个volatile域的写，可见于的后续对这个域的读
  • 传递性
    解释：如果A可见于B，B可见于C，那么A可见于C
  • start（）规则
    解释：假定线程A在执行过程中，通过执行ThreadB.start（）来启动线程B，那么线程A对共享变量的修改在接下来的线程B开始执行前对线程B可见。注意：线程B启动后，线程A对变量修改线程B未必可见
  • join（）规则
    解释：如果线程A执行才啊哦做ThreadB.join（）并成功返回，那么线程B中的任意操作happens-before于线程A从ThreadB.join（）操作成功返回
  1. volatile写读建立的happens-before原则
package com.JUC编程.volatile0;
public class HappBefore {
    private int a = 1;
    private volatile int b = 3;
    public void write() {
        a = 3;
        b = a;
    }
    /*
     * 我们发现会出现a=1 b=3 这就是由于前一个线程的写操作对于后一个线程的读操作不可见造成的。
     * 所以我们可以利用volatile写读建立的happens-before关系来实现。
     *我们可以给b加volatile，前一个线程下对b写入后，后一个线程在读取b时，那么b之前那所有的操作都对后一个线程可见，
     * 就不会出现a=1的情况了。
     * */
    public void read() {
        System.out.println("a=" + a + ",b=" + b);
    }
    public static void main(String[] args) {
        HappBefore before = new HappBefore();
        new Thread(() -> {
            before.write();
        }).start();
        new Thread(() -> {
            before.read();
        }).start();
    }
}

单例模式

  1. 饿汉式的两种写法
    饿汉式的特点：在获取单例对象之前对象就已经创建完成了
package com.JUC编程.volatile0;
public class SingleEh {
    //饿汉式单例模式
    //1.静态常量
   /* private static final SingleEh singleEh=new SingleEh();
    private SingleEh(){
    }
    public static SingleEh getSingleEh(){
        return singleEh;
    }*/
    //2.静态代码块
    private static final SingleEh singleEh;
    private SingleEh(){
    }
    static {
        singleEh=new SingleEh();
    }
    public static SingleEh getSingleEh(){
        return singleEh;
    }
}
class test{
    public static void main(String[] args) {
        SingleEh singleEh = SingleEh.getSingleEh();
        SingleEh singleEh1 = SingleEh.getSingleEh();
        System.out.println(singleEh1 == singleEh);//true
    }
}
  1. 懒汉单例的四种写法
    懒汉单例的特点：在真正需要单例的时候才撞见出该对象。
package com.JUC编程.volatile0;
public class SingleLh {
    //懒汉式单例模式
    //1.线程不安全
    private SingleLh(){
    }
    private static SingleLh singleLh;//定义的时候不初始化
    public static SingleLh getSingleLh(){
        //当有两个线程同时进入到这个方法中时，就会发生线程安全问题
        if (singleLh==null) {
            return new SingleLh();
        }
        return singleLh;
    }
}


package com.JUC编程.volatile0;
public class SingleLh {
    //2.使用synchronized修饰方法，但是性能太低
    private SingleLh(){
    }
    private static SingleLh singleLh;
    public synchronized static SingleLh getSingleLh(){
        if (singleLh==null) {
            return new SingleLh();
        }
        return singleLh;
    }
}


package com.JUC编程.volatile0;
public class SingleLh {
    //3.可以缩小synchronized的使用范围，但是我们发现却保证不了线程安全
    private SingleLh(){
    }
    private static SingleLh singleLh;
    public synchronized static SingleLh getSingleLh(){
        if (singleLh==null) {
            synchronized (SingleLh.class) {
                return new SingleLh();
            }
        }
        return singleLh;
    }
}

volatile双重检查机制（推荐方式）

package com.JUC编程.volatile0;
public class SingleLh {
    //4.volatile双重检查模式(推荐)
    private SingleLh(){
    }
    //volatile在此处主要的作用是保证可见性和禁止指令重排序
    private volatile static SingleLh singleLh;
    public  static SingleLh getSingleLh(){
        /*双重检查既保证了效率又保证了线程安全*/
        if (singleLh==null) {
            synchronized (SingleLh.class) {
                if(singleLh==null) {
                //因为new SingleLh()并不是一个原子操作,可能会发生指令重排。
                    return new SingleLh();
                }
            }
        }
        return singleLh;
    }
}
  1. 静态内部类单例方式
    静态内部类是在被调用时才会被加载，这种方案实现懒汉单例的一种思想，需要用到的时候才回去创建单例，加上JVM的特性，这种方式又实现了线程安全的创建单例对象
package com.JUC编程.volatile0;
public class SingleStatic {
    /*步骤：
    * 1.提供一个静态内部类来，里面提供一个常量用来存储单例对象
    * 2.提供一个静态方法返回静态内部类中的单例对象
    * */
    private SingleStatic(){
    }
    private static class InnerClass{
        private static final SingleStatic single=new SingleStatic();
    }
    public static SingleStatic getSingleStatic(){
        return InnerClass.single;
    }
}
  1. 枚举实现单例
package com.JUC编程.volatile0;
/*
* 枚举实际上是一种多例的模式，如果我们直接定义了一个实例就相当于是单例了
* */
public enum  SingleEnum {
    //但是枚举的主要作用是用于信息的标志和分类,不足以应付特殊的应用场景，单例中用的较少
    SINGLE_ENUM;
}

单例模式的使用场景

  1. 纯赋值操作
package com.JUC编程.volatile0;
import java.util.concurrent.atomic.AtomicInteger;
public class SingleUse1 {
    public static void main(String[] args) throws InterruptedException {
        Resources resources = new Resources();
        Thread thread = new Thread(() -> {
            resources.add();
        });
        Thread thread1 = new Thread(() -> {
            resources.add();
        });
        thread.start();
        thread1.start();
        thread.join();
        thread1.join();
        System.out.println(resources.flag);
        System.out.println(resources.atomicInteger.get());
    }
}
class Resources{
    public volatile Boolean flag=false;
    public AtomicInteger atomicInteger= new AtomicInteger();
    public  void add(){
        for (int i = 0; i < 10000; i++) {
            flag=true;
            //flag=!flag;
            atomicInteger.incrementAndGet();
        }
    }
}

小结：

volatile可以适合做多线程中的纯赋值操作，如果一个共享变量自始至终只被各个线程赋值，而没有其他的操作，那么就可以用volatile来代替synchronized或者代替原子变量，因为赋值自身是有原子性的，而volatile又保证了可见性，所以就足以保证线程安全

  1. 触发器（happens-before）
package com.JUC编程.volatile0;
public class SingleUse2 {
    public static void main(String[] args) {
        //可以作为刷新之前操作的触发器
        resource re = new resource();
        new Thread(()->{
            re.write();
        }).start();
        new Thread(()->{
            re.read();
        }).start();
    }
}
class resource {
    private int a = 1;
    private int b = 2;
    private int c = 3;
    private volatile boolean flag = true;
    public void write() {
        a = 10;
        b = 20;
        c = 30;
        flag = true;
    }
    public void read() {
        //flag被volatile修饰，充当了触发器,一旦值为被修改为true,那么此处对变量之前的操作对于后面的线程都是可见的。
        while (flag) {
            System.out.println("a=" + a + ",b=" + b + ",c=" + c);
        }
    }
}

小结：
volatile可以作为刷新之前变量的触发器，我们可以将某个变量设置为volatile修饰，其他线程一旦发现该变量修改的值后，触发获取到的该变量之前的最新且可见的。

volatile和synchronized的区别

  • volatile只能修饰实例变量和类变量；而synchronized可以修饰方法，以及代码块
  • volatile保证数据可见性，但是不保证原子性，不保证线程安全；而synchronized是一种互斥锁（排他）机制，可以保证线程安全
  • volatile用于禁止指令重排序，可以解决单例双重检查对象初始化代码执行乱序问题
  • volatile可以看做是轻量版的synchronized，volatile不保证原子性，但是如果对一个共享变量进行多个线程的赋值，而没有其他操作，那么就可以用volatile来代替synchronized，因为赋值本身是有原子性的，而volatile又保证了可见性，所以就可以保证线程安全了
yangningke
关注
多线程 - volatile、happens-before原则
学无止境
03-29 217
volatile 关键字可以确保多个线程之间对变量的可见性（visibility），即一个线程修改了一个被 volatile 修饰的变量的值，其他线程可以立即看到这个变量的新值。具体来说，使用 volatile 关键字修饰的变量在进行读写操作时，会直接从内存中读取或写入，而不会从线程的缓存中读取或写入。这就保证了不同线程之间对该变量的访问是同步的，避免了可能的数据竞争问题。需要注意的是，volatile 关键字只能保证对单个变量的原子性操作，不能保证对多个变量的复合操作的原子性。
【进阶之路】深入了解volatile、内存屏障与happens-before规则
南橘Home
10-26 583
大家好，我是练习java两年半时间的南橘，从一名连java有几种数据结构都不懂超级小白，到现在懂了一点点的进阶小白，学到了不少的东西。知识越分享越值钱，我这段时间总结（包括从别的大佬那边学习，引用）了一些平常学习和工作中的重点（自我认为），希望给大家带来一些帮助 这是之前的三篇关于JVM的文章，没看过的同学可以一起看一下 攻克JVM——JVM对象及对象的访问定位（一） 攻克JVM——JVM的垃圾回收机制（二） 攻克JVM——JVM的垃圾收集器（三） 大家都知道，在阿里巴巴泰山版开发手册中有这一段，.
java获取线程信息
02-07
获取并显示线程信息 运行tasklist并获取流，再输出
PC寄存器
weixin_45650737的博客
10-13 533
连接：https://docs.oracle.com/javase/specs/jvms/se8/html/ 寄存器存储指令相关的线程信息，CPU只有把数据装载到寄存器才能运行。 JVM中的PC寄存器是对物理PC寄存器的一种抽象模拟。 作用：线程独有，用来存储指向下一条指令的地址，也即将要执行的指令代码，由执行引擎读取下一条指令！ 介绍： 他是一块很小的内存空间，几乎可以忽略不计，也是运行速度最快的存储区域。 在JVM规范中，每个线程都有它自己的程序计数器，是线程私有的，生命周期与线程的生命周期保持一致。
java如果拿到当前线程id
weixin_40322141的博客
07-03 275
如何在Java中获取当前线程ID 作为一名经验丰富的开发者，我将教你如何在Java中获取当前线程ID。首先，让我们看一下整个流程： 步骤 步骤 描述 1 获取当前线程对象 2 从当前线程对象中获取线程ID 代码实现 步骤1：获取当前线程对象 登录后复制 Thread currentThread =...
java如何获取线程id呢？
qq_25073223的博客
07-12 4180
获取线程id的方法分享
Java学习，获取线程id
最新发布
五味香的专栏
02-28 681
System.out.println("新线程的ID: " + threadId);System.out.println("新线程的ID: " + newThreadId);System.out.println("主线程的ID: " + mainThreadId);System.out.println("当前线程的ID: " + threadId);Java每个线程都有一个唯一的标识符，称为线程ID。方法来获取当前线程的线程ID。
volatile与happens-before的关系与内存一致性错误
08-26
在Java并发编程中，理解和掌握volatile关键字以及happens-before原则对于解决内存一致性错误至关重要。内存一致性错误通常出现在多线程环境下，当不同线程访问共享变量时，由于缓存和处理器优化，可能导致数据不一致...
java volatile关键字作用及使用场景详解
08-25
下面将详细解释`volatile`的关键特性、它如何解决并发问题以及相关的`happens-before`原则。 1. **可见性**： `volatile`关键字确保了被其修饰的变量在所有线程之间具有可见性。这意味着当一个线程修改了`volatile...
Java并发编程：volatile、happens-before与内存一致性
"Java并发编程中的volatile变量与happens-before原则关系，以及如何解决内存一致性错误" 在Java并发编程中，volatile关键字扮演着至关重要的角色，它保证了多线程环境下的可见性和有序性，从而帮助防止内存一致性...
java 获取指定的进程id
06-17
java 获取指定java 获取指定的进程id的进程id
java：获取线程的Id
听海边涛声
12-21 1488
java：获取线程的Id
java当前线程id_获取Linux中Java线程的线程ID
weixin_31955599的博客
02-12 869
最后,我发现JNI是解决我问题的最佳方法.作为参考,我发布代码并为其构建说明(基于维基百科的example)：负责与C代码(GetThreadID.java)接口的Java类：public class GetThreadID {public static native int get_tid();static {System.loadLibrary("GetThreadID");}}C文件负责获取...
java 线程的id_Java 实例 – 获取线程id
weixin_35831315的博客
03-05 430
Java 实例 - 获取线程id以下实例演示了如何使用 getThreadId() 方法获取线程id：/*author by w3cschool.cnMain.java*/public class Main extends Object implements Runnable {private ThreadID var;public Main(ThreadID v) {this.var = v;}...
java怎么查看线程id,Java 获取线程id
weixin_34024811的博客
03-22 1961
package com.company;/**/public class GetThreadTest extends Object implements Runnable {private ThreadID var;public GetThreadTest(ThreadID v) {this.var = v;}public static void main(String[] args) {Thre...
java通过线程id,Java获取线程ID的实例
weixin_30719609的博客
03-12 1011
以下实例演示了如何使用 getThreadId() 方法获取线程id：public class Main extends Object implements Runnable {private ThreadID var;public Main(ThreadID v) {this.var = v;}public void run() {try {print("var getThreadID =" +...
java当前线程id,在Linux中获取Java线程的线程ID
weixin_30820933的博客
02-12 148
I have a Java application where some threads are created (via new Thread()). Using ps I can see they have different thread IDs (LWP column) and I would like to obtain those IDs from within the Java ap...
synchronized的偏向锁、轻量级锁、重量级锁、自旋锁、锁消除、锁粗化简介
d303577562的博客
10-23 622
在多线程并发编程中synchronized一直是元老级角色，很多人都会称呼它为重量级锁。但是，随着Java SE1.6对synchronized进行了各种优化之后，有些情况下它就并不是那么重了。JavaSE1.6为了减少获得锁和锁释放带来的性能消耗而引入了偏向锁和轻量级锁。 首先我们来看下利用synchronized实现同步的基础。Java中的每个队形都可以作为锁。具体表现为以下三种形式： 对于普通方法，锁时当前实例对象 对于静态同步方法，锁是当前类的Class对象 对于同步方法块，锁是Synchroni
java 线程的id_java获取真实线程id
weixin_34212182的博客
02-28 8283
以下代码获取的threadId其实是jvm里的线程id，和我们常说的linux系统线程id不一样public static void main(String[] a) {long tid = Thread.currentThread().getId();System.out.println("tid:"+ tid);}打印结果tid:1从结果看明显id不是我们想要的系统线程id。系统线程id可以借...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值