在Java中的volatile关键字 - 澄清

30 浏览
0 Comments

在Java中的volatile关键字 - 澄清

我对我所读到的关于Java中volatile关键字的应用感到非常困惑。\n

    \n

  1. 下面的陈述是否正确？\n\"对volatile字段的写入在每次后续对同一字段的读取之前发生\"

    2. \n

  2. 理想情况下应该在什么时候使用volatile关键字？

    3. \n

  3. 下面的两个例子之间有什么区别？\n 
    class TestClass
{  private int x;
   synchronized int get(){return x;}
   synchronized void set(int x){this.x = x;}
}

    4. \n和\n

    class TestClass
{  private volatile int x;
   int get(){return x;}
   void set(int x){this.x = x;}
}

    \n

0

3 答案

0 Comments

在Java中，volatile关键字的出现是为了解决内存可见性的问题。在Java 1.5版本之前，volatile关键字的作用是声明该字段每次读取都会从主内存中获取最新的值，并且每次写入都会刷新到主内存中。

而今天的volatile关键字具有两个非常重要的特性：

1. 在读取一个volatile字段时，不必关心具体的实现方式，只需要知道你总是能获取到最新的值。

2. 编译器不能对volatile读/写进行重排序，以保持程序的执行顺序。

这两个特性的出现是为了解决多线程环境下的线程间数据共享的问题。在多线程环境中，为了提高性能，编译器和处理器可能会对指令进行重排序，这可能导致某些线程获取到的数据不是最新的，从而引发一系列问题。

通过使用volatile关键字，我们可以确保读取volatile字段时总是能获取到最新的值，而不会获取到过期的值。同时，编译器也不能对volatile读/写进行重排序，保证了程序的执行顺序。

下面是一个示例代码，演示了使用volatile关键字的情况：

public class VolatileExample {
    private volatile int count = 0;
    public void increment() {
        count++;
    }
    public int getCount() {
        return count;
    }
}

在上面的示例中，count字段被声明为volatile，这样在多线程环境中，每次对count的读取都会从主内存中获取最新的值，而每次对count的写入也会立即刷新到主内存中。

总之，volatile关键字的出现是为了解决多线程环境下的数据共享问题，通过保证内存可见性和程序执行顺序，确保了多线程环境下的数据一致性。

0
0 Comments

Java中的volatile关键字 - 澄清

在Java中，使用volatile关键字可以确保从变量中读取的值始终反映出最新的更新值。运行时可以通过各种方式实现这一点，包括在值发生更改时不缓存或刷新缓存。

然而，volatile关键字仅仅保证了可见性，即一个线程对该变量的修改对其他线程是可见的。但是，并不能保证原子性，即在一个线程对该变量进行写操作时，其他线程对该变量的读操作可能会读取到不一致的值。

那么为什么会出现这个问题以及如何解决呢？

问题的出现是因为在多线程环境下，由于线程之间的执行顺序是不确定的，存在着竞态条件（Race Condition）。当一个线程对变量进行写操作时，其他线程可能正在进行读操作，这时候读操作可能会读取到过期的缓存值，而不是最新的更新值。

为了解决这个问题，可以使用volatile关键字来修饰变量。当一个变量被声明为volatile时，编译器和运行时都会注意到这个变量是共享的，并且不会将其存储在寄存器或对其他线程不可见的地方。这样就确保了所有线程都能够看到最新的值。

下面是一个示例代码：

public class VolatileExample {
    private volatile int count = 0;
    
    public void increment() {
        count++;
    }
    
    public int getCount() {
        return count;
    }
}

在上面的代码中，count变量被声明为volatile。这样，在一个线程对count进行写操作时，其他线程对count的读操作会读取到最新的更新值。

总结起来，使用volatile关键字可以确保变量的可见性，即一个线程对该变量的修改对其他线程是可见的。但是，它并不能保证原子性，因此在需要保证原子性的操作时，还需要使用其他的同步机制，如synchronized关键字或Lock。

0
0 Comments

Java中的volatile关键字用于修饰字段，而synchronized关键字用于修饰代码块和方法。所以可以使用这两个关键字来定义三种简单访问器的变体。

geti1()方法在当前线程中访问当前存储在i1中的值。线程可以有变量的本地副本，其数据不一定与其他线程中保存的数据相同。特别是，另一个线程可能在其线程中更新了i1，但是当前线程中的值可能与更新后的值不同。事实上，Java中有一个"main"内存的概念，这是保存变量的当前"正确"值的内存。线程可以有其变量的自己的数据副本，并且线程副本可能与"main"内存中的数据不同。因此，实际上，如果thread1和thread2都更新了i1，但是这些更新的值尚未传播到"main"内存或其他线程中，那么"main"内存中i1的值可能为1，thread1中i1的值可能为2，thread2中i1的值可能为3。

另一方面，geti2()方法有效地从"main"内存中访问i2的值。不允许volatile变量具有与"main"内存中当前保存的值不同的变量的本地副本。实际上，声明为volatile的变量必须在所有线程之间同步其数据，以便无论在任何线程中访问或更新变量，所有其他线程都立即看到相同的值。通常，与"普通"变量相比，volatile变量具有更高的访问和更新开销。通常，线程允许拥有其自己的数据副本以提高效率。

volatile和synchronized之间有两个区别。

首先，synchronized在监视器上获取和释放锁，这可以强制一次只有一个线程执行代码块。这是关于synchronized的一个众所周知的方面。但是synchronized还同步内存。实际上，synchronized将整个线程内存与"main"内存同步。因此，执行geti3()方法会执行以下操作：

1. 线程获取对象this的监视器锁。

2. 线程内存刷新其所有变量，即从"main"内存中读取其所有变量。

3. 执行代码块（在这种情况下，将返回值设置为i3的当前值，该值可能刚刚从"main"内存中重置）。

4. （变量的任何更改通常现在将写入"main"内存，但是对于geti3()方法，我们没有任何更改。）

5. 线程释放对象this的监视器锁。

因此，volatile仅在线程内存和"main"内存之间同步一个变量的值，而synchronized在线程内存和"main"内存之间同步所有变量的值，并且还获取和释放监视器。显然，与volatile相比，synchronized可能具有更多的开销。

解决方案是使用volatile关键字来修饰需要在多个线程之间共享的变量，以确保所有线程都能立即看到相同的值。另一种解决方案是使用synchronized关键字来修饰访问共享变量的方法或代码块，以确保在执行这些方法或代码块时，线程的内存与"main"内存同步，并且只允许一个线程执行代码块。这可以防止多个线程同时访问和修改共享变量，从而避免数据不一致的问题。

0