JAVA中final、static、volatile在字节码文件中的表现

最新推荐文章于 2023-05-27 14:55:11 发布
最新推荐文章于 2023-05-27 14:55:11 发布
阅读量71 收藏
点赞数
文章标签： java
原文链接：https://yq.aliyun.com/articles/616308
版权

本文已收录在本人整编的JAVA技术资源目录中，微信用户请点击头像查看《JAVA通关秘籍》

说到这几个关键字，大部分猿都能娓娓道来，说出很多它们的用法和定义

  1. final修饰的字段不可修改、方法不可重写、类不可继承，JVM对final有优化
  2. static修饰的字段所有对象共用、static{}内的代码在类加载时执行、JVM对static有优化
  3. volatile修饰的字段所有线程看到的值一致

问：JVM对final和static有什么优化？
我：？？？
问：为什么volatile各线程看到的值是一致的？
我：嘿！这个我知道，因为对volatile的写操作会直接更新到主内存（这里指堆或元空间等线程共享内存）中，不会使用TLAB（这个在字节码上看不出来，也不在本文的讨论范围中。TLAB：Thread Local Allocation Buffer，本地线程分配缓冲）

带着这些疑问，我们一起看一下Java的字节码文件，从字节码文件中，就能印证和解决上述的部分说法和问题

static关键字

准备一个测试类

public class TestStatic {
    static double pi = 3.14;
    static Double piO = 3.14;
    static Object o1 = new Object();   
    Object o2 = new Object();
}

测试类很简单，四个字段都比较典型，在看字节码之前，先思考两个问题

  1. pi和piO在编译后有区别吗？
    答：JAVA有自动拆装箱，编译后可能没有区别...吧？
  2. o1和o2在编译后有区别吗？
    答：o1是静态的，o2不是静态的（这不是废话么？）

可能大家都没有认真思考过这个问题，那么现在我们看一下TestStatic编译后的字节码文件，能否在其中找到答案

JDK提供了javap工具可以反编译字节码，使用如下命令可以方便的查看

javap -verbose F:\workspace\TestProject\out\production\TestProject\TestStatic.class

输出如下

Classfile /F:/workspace/TestProject/out/production/TestProject/TestStatic.class
  Last modified 2018-4-28; size 567 bytes
  MD5 checksum 73675b19fe69643d4cb69073bcbad34f
  Compiled from "TestStatic.java"
public class TestStatic
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #2.#28         // java/lang/Object."<init>":()V
   #2 = Class              #29            // java/lang/Object
   #3 = Fieldref           #10.#30        // TestStatic.o2:Ljava/lang/Object;
   #4 = Double             3.14d
   #6 = Fieldref           #10.#31        // TestStatic.pi:D
   #7 = Methodref          #32.#33        // java/lang/Double.valueOf:(D)Ljava/lang/Double;
   #8 = Fieldref           #10.#34        // TestStatic.piO:Ljava/lang/Double;
   #9 = Fieldref           #10.#35        // TestStatic.o1:Ljava/lang/Object;
  #10 = Class              #36            // TestStatic
  #11 = Utf8               pi
  #12 = Utf8               D
  #13 = Utf8               piO
  #14 = Utf8               Ljava/lang/Double;
  #15 = Utf8               o1
  #16 = Utf8               Ljava/lang/Object;
  #17 = Utf8               o2
  #18 = Utf8               <init>
  #19 = Utf8               ()V
  #20 = Utf8               Code
  #21 = Utf8               LineNumberTable
  #22 = Utf8               LocalVariableTable
  #23 = Utf8               this
  #24 = Utf8               LTestStatic;
  #25 = Utf8               <clinit>
  #26 = Utf8               SourceFile
  #27 = Utf8               TestStatic.java
  #28 = NameAndType        #18:#19        // "<init>":()V
  #29 = Utf8               java/lang/Object
  #30 = NameAndType        #17:#16        // o2:Ljava/lang/Object;
  #31 = NameAndType        #11:#12        // pi:D
  #32 = Class              #37            // java/lang/Double
  #33 = NameAndType        #38:#39        // valueOf:(D)Ljava/lang/Double;
  #34 = NameAndType        #13:#14        // piO:Ljava/lang/Double;
  #35 = NameAndType        #15:#16        // o1:Ljava/lang/Object;
  #36 = Utf8               TestStatic
  #37 = Utf8               java/lang/Double
  #38 = Utf8               valueOf
  #39 = Utf8               (D)Ljava/lang/Double;
{
  static double pi;
    descriptor: D
    flags: ACC_STATIC

  static java.lang.Double piO;
    descriptor: Ljava/lang/Double;
    flags: ACC_STATIC

  static java.lang.Object o1;
    descriptor: Ljava/lang/Object;
    flags: ACC_STATIC

  java.lang.Object o2;
    descriptor: Ljava/lang/Object;
    flags:

  public TestStatic();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=3, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: aload_0
         5: new           #2                  // class java/lang/Object
         8: dup
         9: invokespecial #1                  // Method java/lang/Object."<init>":()V
        12: putfield      #3                  // Field o2:Ljava/lang/Object;
        15: return
      LineNumberTable:
        line 1: 0
        line 6: 4
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      16     0  this   LTestStatic;

  static {};
    descriptor: ()V
    flags: ACC_STATIC
    Code:
      stack=2, locals=0, args_size=0
         0: ldc2_w        #4                  // double 3.14d
         3: putstatic     #6                  // Field pi:D
         6: ldc2_w        #4                  // double 3.14d
         9: invokestatic  #7                  // Method java/lang/Double.valueOf:(D)Ljava/lang/Double;
        12: putstatic     #8                  // Field piO:Ljava/lang/Double;
        15: new           #2                  // class java/lang/Object
        18: dup
        19: invokespecial #1                  // Method java/lang/Object."<init>":()V
        22: putstatic     #9                  // Field o1:Ljava/lang/Object;
        25: return
      LineNumberTable:
        line 3: 0
        line 4: 6
        line 5: 15
}
SourceFile: "TestStatic.java"

javap给我们提供了贴心的注释，下面我们就一起大致的解析一下输出内容

Classfile /F:/workspace/TestProject/out/production/TestProject/TestStatic.class
  Last modified 2018-4-28; size 530 bytes
  MD5 checksum 9df14e179094d429736915c43214ae86
  Compiled from "TestStatic.java"

这几行输出了class文件的目录、修改时间、md5、编译来源

public class TestStatic
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER

接下来，描述了jdk版本，52表示JDK1.8，类访问标识，ACC_PUBLIC表示此类是的作用域是public，ACC_SUPER是超类方法的调用方式，JDK1.02后都会有

Constant pool:
   #1 = Methodref          #2.#28         // java/lang/Object."<init>":()V
   #2 = Class              #29            // java/lang/Object
   #3 = Fieldref           #10.#30        // TestStatic.o2:Ljava/lang/Object;
   #4 = Double             3.14d
   #6 = Fieldref           #10.#31        // TestStatic.pi:D
   #7 = Methodref          #32.#33        // java/lang/Double.valueOf:(D)Ljava/lang/Double;
   #8 = Fieldref           #10.#34        // TestStatic.piO:Ljava/lang/Double;
   #9 = Fieldref           #10.#35        // TestStatic.o1:Ljava/lang/Object;
  #10 = Class              #36            // TestStatic
  #11 = Utf8               pi
  #12 = Utf8               D
  #13 = Utf8               piO
  #14 = Utf8               Ljava/lang/Double;
  #15 = Utf8               o1
  #16 = Utf8               Ljava/lang/Object;
  #17 = Utf8               o2
  #18 = Utf8               <init>
  #19 = Utf8               ()V
  #20 = Utf8               Code
  #21 = Utf8               LineNumberTable
  #22 = Utf8               LocalVariableTable
  #23 = Utf8               this
  #24 = Utf8               LTestStatic;
  #25 = Utf8               <clinit>
  #26 = Utf8               SourceFile
  #27 = Utf8               TestStatic.java
  #28 = NameAndType        #18:#19        // "<init>":()V
  #29 = Utf8               java/lang/Object
  #30 = NameAndType        #17:#16        // o2:Ljava/lang/Object;
  #31 = NameAndType        #11:#12        // pi:D
  #32 = Class              #37            // java/lang/Double
  #33 = NameAndType        #38:#39        // valueOf:(D)Ljava/lang/Double;
  #34 = NameAndType        #13:#14        // piO:Ljava/lang/Double;
  #35 = NameAndType        #15:#16        // o1:Ljava/lang/Object;
  #36 = Utf8               TestStatic
  #37 = Utf8               java/lang/Double
  #38 = Utf8               valueOf
  #39 = Utf8               (D)Ljava/lang/Double;

接下来是本类的常量池，类中用到的别的类、自身的成员变量、名字类型等都在这里
常量池是从1开始的，与JAVA的习惯不符，是因为0有特殊含义，表示不引用任何常量池项目
注意看#4和#8
#4是基本类型double的pi，值为3.14d
#8是包装类型Double的piO，值为#9.#30，

这里回答了问题1，可以清楚的看到，piO并没有拆箱操作，指向的是一个Double类型，而不是3.14这个值

有朋友问，#5去哪里了？
你问编译器去啊，我怎么知道。。。（推测：Class是一个非常严谨的文件，每一个变量占多长都是有规定的，可能是Double占据了#5的位置，所以就没有了。）

接下来看#3和#9，也就是o2和o1，仔细观察后，发现真没什么区别，暂时还回答不了问题2，继续

注：常量池的第一列表示的是类型，参考图1，出自《深入理解JAVA虚拟机：JVM高级特性与最佳实践》


图1 
static double pi;
    descriptor: D
    flags: ACC_STATIC

  static java.lang.Double piO;
    descriptor: Ljava/lang/Double;
    flags: ACC_STATIC

  static java.lang.Object o1;
    descriptor: Ljava/lang/Object;
    flags: ACC_STATIC

  java.lang.Object o2;
    descriptor: Ljava/lang/Object;
    flags:

这一部是我们声明的成员变量，注意看pi和piO的描述符（descriptor），pi是D，是一个基本类型，piO则是一个Double类型，是一个类。o1和o2的区别在于o1有ACC_STATIC标识，o2没有，这显然与我们写的static关键字有关。

public TestStatic();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=3, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: aload_0
         5: new           #2                  // class java/lang/Object
         8: dup
         9: invokespecial #1                  // Method java/lang/Object."<init>":()V
        12: putfield      #3                  // Field o2:Ljava/lang/Object;
        15: return
      LineNumberTable:
        line 1: 0
        line 6: 4
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      16     0  this   LTestStatic;

这里是构造函数（本例中，是一个默认构造函数）
()V表示void，无返回
主要看下Code中的内容

1: invokespecial #1 // Method java/lang/Object."<init>":()V

没错，构造函数先调用父类的构造函数，也就是super();

5: new           #2                  // class java/lang/Object
9: invokespecial #1                  // Method java/lang/Object."<init>":()V
12: putfield      #3                  // Field o2:Ljava/lang/Object;

以上三行是对o2的赋值，可推出如下结论：

虽然代码中o2是直接赋值的，但是实际上直到TestStatic这个类的构造函数执行时，才会给o2赋值。

接下来，LineNumberTable对应了源码中的行号（上面贴的源代码精简过，有可能不一致），调试的时候，断点和源码就可以对应上了
再然后，LocalVariableTable列出了用到的本地变量，只有一个this，也就是存在栈帧中的本地变量

  static {};
    descriptor: ()V
    flags: ACC_STATIC
    Code:
      stack=2, locals=0, args_size=0
         0: ldc2_w        #4                  // double 3.14d
         3: putstatic     #6                  // Field pi:D
         6: ldc2_w        #4                  // double 3.14d
         9: invokestatic  #7                  // Method java/lang/Double.valueOf:(D)Ljava/lang/Double;
        12: putstatic     #8                  // Field piO:Ljava/lang/Double;
        15: new           #2                  // class java/lang/Object
        18: dup
        19: invokespecial #1                  // Method java/lang/Object."<init>":()V
        22: putstatic     #9                  // Field o1:Ljava/lang/Object;
        25: return
      LineNumberTable:
        line 3: 0
        line 4: 6
        line 5: 15

最后，是一个静态代码块，我们没写，显然是自动生成的，在类初始化时执行

注，有且只有在以下情况，会对TestStatic初始化
1. new TestStatic()时
2. 读取或设置piO、o1（静态变量）时
3. 反射调用TestStatic时
4. 初始化TestStatic的子类时
5. 当TestStatic中的main方法作为程序入口时
6. JDK1.7动态语言调用TestStatic时

         0: ldc2_w        #4                  // double 3.14d
         3: putstatic     #6                  // Field pi:D

这里是给pi赋值，直接给了3.14

         6: ldc2_w        #4                  // double 3.14d
         9: invokestatic  #7                  // Method java/lang/Double.valueOf:(D)Ljava/lang/Double;
        12: putstatic     #8                  // Field piO:Ljava/lang/Double;

这里是给piO复制，根本没有自动拆箱好吗？invokestatic这个指令生成了一个Double对象，然后才put给了#8

        15: new           #2                  // class java/lang/Object
        19: invokespecial #1                  // Method java/lang/Object."<init>":()V
        22: putstatic     #9                  // Field o1:Ljava/lang/Object;

给o2赋值，也是在初始化阶段

至此，TestStatic这个类的字节码就分析完了，我们证明了包装类型为static时不会自动拆箱，static对象在初始化时赋值，非static在构造函数中赋值。

final和volitle关键字

接下来看另外两个测试类，相信读者已经掌握了基本的阅读Class文件的技巧，为了节省版面，这里不再详细分析
测试类：

public class TestA {
    public final TestB finalB = new TestB();
    public volatile TestB testB = new TestB();
    public final TestB notInitFinalB;
    
    public TestA(TestB notInitFinalB) {
        this.notInitFinalB = notInitFinalB;
    }
}

public class TestB {
}

TestA引用了TestB，finalB使用了final修饰符，testB使用了volatle修饰符，notInitFinalB使用了final并在构造函数中赋值（Spring推荐这种注入方式，在构造函数上@Autoware）
让我们一起看看TestA的Class文件

Classfile /F:/workspace/TestProject/out/production/TestProject/TestA.class
  Last modified 2018-4-28; size 419 bytes
  MD5 checksum f18d8c33c93237cf8e9d92783c500660
  Compiled from "TestA.java"
public class TestA
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #8.#22         // java/lang/Object."<init>":()V
   #2 = Class              #23            // TestB
   #3 = Methodref          #2.#22         // TestB."<init>":()V
   #4 = Fieldref           #7.#24         // TestA.finalB:LTestB;
   #5 = Fieldref           #7.#25         // TestA.testB:LTestB;
   #6 = Fieldref           #7.#26         // TestA.notInitFinalB:LTestB;
   #7 = Class              #27            // TestA
   #8 = Class              #28            // java/lang/Object
   #9 = Utf8               finalB
  #10 = Utf8               LTestB;
  #11 = Utf8               testB
  #12 = Utf8               notInitFinalB
  #13 = Utf8               <init>
  #14 = Utf8               (LTestB;)V
  #15 = Utf8               Code
  #16 = Utf8               LineNumberTable
  #17 = Utf8               LocalVariableTable
  #18 = Utf8               this
  #19 = Utf8               LTestA;
  #20 = Utf8               SourceFile
  #21 = Utf8               TestA.java
  #22 = NameAndType        #13:#29        // "<init>":()V
  #23 = Utf8               TestB
  #24 = NameAndType        #9:#10         // finalB:LTestB;
  #25 = NameAndType        #11:#10        // testB:LTestB;
  #26 = NameAndType        #12:#10        // notInitFinalB:LTestB;
  #27 = Utf8               TestA
  #28 = Utf8               java/lang/Object
  #29 = Utf8               ()V
{
  public final TestB finalB;
    descriptor: LTestB;
    flags: ACC_PUBLIC, ACC_FINAL

  public volatile TestB testB;
    descriptor: LTestB;
    flags: ACC_PUBLIC, ACC_VOLATILE

  public final TestB notInitFinalB;
    descriptor: LTestB;
    flags: ACC_PUBLIC, ACC_FINAL

  public TestA(TestB);
    descriptor: (LTestB;)V
    flags: ACC_PUBLIC
    Code:
      stack=3, locals=2, args_size=2
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: aload_0
         5: new           #2                  // class TestB
         8: dup
         9: invokespecial #3                  // Method TestB."<init>":()V
        12: putfield      #4                  // Field finalB:LTestB;
        15: aload_0
        16: new           #2                  // class TestB
        19: dup
        20: invokespecial #3                  // Method TestB."<init>":()V
        23: putfield      #5                  // Field testB:LTestB;
        26: aload_0
        27: aload_1
        28: putfield      #6                  // Field notInitFinalB:LTestB;
        31: return
      LineNumberTable:
        line 6: 0
        line 2: 4
        line 3: 15
        line 7: 26
        line 8: 31
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      32     0  this   LTestA;
            0      32     1 notInitFinalB   LTestB;
}
SourceFile: "TestA.java"

过程略

结论：

1. final在字节码的表现上，只是多了ACC_FINAL标签，真正的优化在运行时
2. volatile同理，多了ACC_VOLATILE标签，运行时处理
3. 没有static变量，就不会生成static{}代码块
4. final变量直接等于值和在构造函数赋值，在字节码上表现是一样的

重新回答一下最开始的问题
问：JVM对final和static有什么优化？
我：final会在字节码中打上ACC_FINAL标签，在运行时会进行处理和优化（想要知道具体有什么优化，请查看运行时常量池的相关资料），static变量会在静态代码块中赋值，非static变量都是在构造函数中赋值，static的基本类型会在编译时把字面值放入常量池中

问：举一个字节码优化的栗子？
答：没有使用的本地变量不会编译到本地变量表（LocalVariableTable）

public class TestC {
    static{
        TestB bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = new TestB();
    }
}

编译后静态块如下，没有bbbb什么事

  static {};
    descriptor: ()V
    flags: ACC_STATIC
    Code:
      stack=2, locals=1, args_size=0
         0: new           #2                  // class TestB
         3: dup
         4: invokespecial #3                  // Method TestB."<init>":()V
         7: astore_0
         8: return
      LineNumberTable:
        line 3: 0
        line 4: 8
      LocalVariableTable:
        Start  Length  Slot  Name   Signature

如有错漏，欢迎指正

weixin_34345753
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
深入理解Java中的volatile关键字（总结篇）
08-26
volatile这个关键字，不仅仅在Java语言中有，在很多语言中都有的，而且其用法和语义也都是不尽相同的。这篇文章主要介绍了Java中的volatile关键字,需要的朋友可以参考下
Java字节码技术(一)static、final、volatile、synchronized关键字的字节码体现
hosaos的博客
09-23 3376
文章目录基本概念什么是字节码Javap命令查看字节码文件字节码文件解读static、final、volatile在字节码中的体现 基本概念 static：static修饰的变量被所有类实例共享，静态变量在其所在类被加载时进行初始化 final：final修饰的变量不可修改(基本类型值不能修改，引用类型引用不可修改)，final修饰的方法，不可重写、不可继承 volatile：volatile修饰的...
Java中获取Lambda表达式的参数类型和返回值类型
byx的博客
02-21 2626
Java 1.8之后，新增了一个叫做SerializedLambda的类，它用来保存Lambda表达式序列化之后的数据，通过SerializedLambda可以获取Lambda表达式的各种元信息，包括参数类型、返回值类型等。 下面的代码可以获取一个Lambda表达式对应的SerializedLambda实例： interface Function2<R, T1, T2> extends Serializable { R apply(T1 t1, T2 t2); } try {
Java中final与static关键字特点以及使用
qq_59335499的博客
05-27 624
final关键字和static关键子的特点和使用
static、final、volatile笔记
IT小将
03-20 249
[size=large][b]一、关键字final[/b][/size] Java关键字final有“这是无法改变的”或者“终态的”含义。 1、final类：不能被继承，其类的成员方法不能被覆盖。 2、final方法：如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法，final方法能被继承。使用final方法的原因： a）把方法锁定，防止任何继承类...
Java中volatile关键字实现原理
08-30
本文详细解读一下volatile关键字如何保证变量在多线程之间的可见性,对Java中volatile关键字实现原理感兴趣的朋友一起通过本文学习吧
Java中volatile关键字的作用与用法详解
09-01
volatile关键字虽然从字面上理解起来比较简单，但是要用好不是一件容易的事情。这篇文章主要介绍了Java中volatile关键字的作用与用法详解的相关资料,需要的朋友可以参考下
Java开发中的volatile你必须要了解一下
08-27
主要给大家介绍了关于Java开发中volatile的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用java具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
一文精通Java中的volatile关键字
08-26
volatile是java中的关键词之一，这篇文章主要给大家介绍了关于Java中volatile关键字的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用Java具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
JNI字段描述符“([Ljava/lang/String;)V”
pan_00_hao的专栏
03-01 2258
转自：http://fgsink.blog.163.com/blog/static/16716997020124310169911/ “([Ljava/lang/String;)V” 它是一种对函数返回值和参数的编码。这种编码叫做JNI字段描述符（JavaNative Interface FieldDescriptors)。一个数组int[]，就需要表示为这样"[I"。如果多个数组dou
Java 中final、static、volatile关键字
迪宝宝的博客
02-28 894
final关键字 当用final修饰一个类时，表明这个类不能被继承 修饰方法是方法不能被重写 修饰变量 如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。 String a = “helloworld”; final String b = “hello”; ...
java中 static,final,transient,volatile关键字的作用
i0048egi的专栏
02-12 3384
static 和final   static  静态修饰关键字，可以修饰 变量，程序块，类的方法； 　当你定义一个static的变量的时候jvm会将将其分配在内存堆上，所有程序对它的引用都会指向这一个地址而不会重新分配内存； 修饰一个程序块的时候(也就是直接将代码写在static{...}中)时候，虚拟机就会优先加载静态块中代码，这主要用于系统初始化；当修饰一个类方法时候你就可以直接通过类来
java的四个关键子final,static,volatile,transient
xiaoqistudy的博客
06-14 207
1.4 java关键字 1.final final: 变量，对象引用不可变，方法不可覆盖，类不可以被继承。 对象引用不可变 @Test public void method1(){ final StringBuilder s = new StringBuilder("a"); s.append('b'); System.out.println(s.toString()); } 输出ab @Test public void me
final关键字_这一篇我们来了解Synchronized、Volatile、Final关键字
weixin_39969298的博客
11-23 195
题外话：蓝银王觉醒了！！ --来自于一个斗罗大陆动漫爱好者(鹅，打钱！)湿兄这两天回家了，办了点大事，回来的时候我弟弟还舍不得我，哭着不愿意让我回京(我弟还是小学)，我也心里很不舍，但是还是要回京奋斗啊先来回顾下之前的有关并发的文章：学习并发先看这一介绍篇五分钟带你入门线程Thread类和Runnable接口的源码剖析这个我们为什么只聊Synchronized、Volatile、Final这几个关...
从Java内存模型理解synchronized、volatile和final关键字
Hopefully Sky的博客
03-05 4394
你是否真正理解并会用volatile, synchronized, final进行线程间通信呢，如果你不能回答下面的几个问题，那就说明你并没有真正的理解： 1、对volatile变量的操作一定具有原子性吗？（原子操作是不需要synchronized。所谓原子操作是指不会被线程调度机制打断的操作；这种操作一旦开始，就一直运行到结束，中间不会有任何线程切换） 2、synchronized所谓的加锁
volatile 与 final 变量
favomj的博客
12-09 2577
volatile
重新学习一下Java中的几个关键字（final/static/volatile......）
三兆的学习笔记
03-11 1358
1、 final关键字           final关键字可以修饰类，方法和变量，对于每一种修饰都有不同的意义，但目的是相同的，保持完整性防止改变。           例如，在Java中final类不可以被继承，final变量的值不可以修改，final方法不可以被重载。           在Java中，我们无法让对象被修饰为final，而只能修饰对象的引用，这意
java static volatile
最新发布
07-13
在 Java 中，`static` 和 `volatile` 是两个不同的关键字，它们分别表示不同的语义： 1. `static` 关键字：在 Java 中，`static` 用于修饰类的成员变量或方法。当一个成员被声明为 `static` 时，它属于类本身，而...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值