Java 中的易失性与静态

发布于 2024-08-25 02:47:17 字数 170 浏览 5 评论 0 原文

说 static 表示所有对象的值的一份副本，而 volatile 表示所有线程的值的一份副本是否正确？

无论如何，static 变量值也将成为所有线程的一个值，那么我们为什么要选择 volatile 呢？

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

猫瑾少女 2024-09-01 02:47:17

在 Java 中声明静态变量意味着无论创建多少个类的对象，都只会有一个副本。即使根本没有创建任何对象，该变量也可以访问。然而，线程可能有本地缓存的值。

当变量是易失性且不是静态时，每个对象都会有一个变量。所以，表面上看起来和普通变量没有什么区别，但和静态完全不同。然而，即使使用Object字段，线程也可以在本地缓存变量值。

这意味着，如果两个线程同时更新同一对象的变量，并且该变量未声明为易失性，则可能会出现其中一个线程在缓存中具有旧值的情况。

即使您通过多个线程访问静态值，每个线程都可以拥有其本地缓存副本！为了避免这种情况，您可以将变量声明为静态易失性，这将强制线程每次读取全局值。

然而，易失性并不能替代正确的同步！
例如：

private static volatile int counter = 0;

private void concurrentMethodWrong() {
  counter = counter + 5;
  //do something
  counter = counter - 5;
}

多次并发执行concurrentMethodWrong可能会导致counter的最终值不为零！
要解决这个问题，你必须实现一个锁：

private static final Object counterLock = new Object();

private static volatile int counter = 0;

private void concurrentMethodRight() {
  synchronized (counterLock) {
    counter = counter + 5;
  }
  //do something
  synchronized (counterLock) {
    counter = counter - 5;
  }
}

或者使用 AtomicInteger 类。

Declaring a static variable in Java, means that there will be only one copy, no matter how many objects of the class are created. The variable will be accessible even with no Objects created at all. However, threads may have locally cached values of it.

When a variable is volatile and not static, there will be one variable for each Object. So, on the surface it seems there is no difference from a normal variable but totally different from static. However, even with Object fields, a thread may cache a variable value locally.

This means that if two threads update a variable of the same Object concurrently, and the variable is not declared volatile, there could be a case in which one of the thread has in cache an old value.

Even if you access a static value through multiple threads, each thread can have its local cached copy! To avoid this you can declare the variable as static volatile and this will force the thread to read each time the global value.

However, volatile is not a substitute for proper synchronisation!
For instance:

private static volatile int counter = 0;

private void concurrentMethodWrong() {
  counter = counter + 5;
  //do something
  counter = counter - 5;
}

Executing concurrentMethodWrong concurrently many times may lead to a final value of counter different from zero!
To solve the problem, you have to implement a lock:

private static final Object counterLock = new Object();

private static volatile int counter = 0;

private void concurrentMethodRight() {
  synchronized (counterLock) {
    counter = counter + 5;
  }
  //do something
  synchronized (counterLock) {
    counter = counter - 5;
  }
}

Or use the AtomicInteger class.

回复收藏 0 原文

橘寄 2024-09-01 02:47:17

静态和易失性之间的区别：

静态变量：如果两个线程（假设t1和t2）正在访问同一个对象并更新一个变量，该变量是声明为静态则意味着 t1 和 t2 可以在各自的缓存中创建同一对象（包括静态变量）的本地副本，因此由 进行更新t1 到其本地缓存中的静态变量不会反映在 t2 缓存的静态变量中。

静态变量用在对象上下文中，其中一个对象所做的更新将反映在同一类的所有其他对象中但不会在线程上下文中，其中更新静态变量的一个线程将立即将更改反映到所有线程（在其本地缓存中）。

易失性变量：如果两个线程（假设t1和t2）正在访问同一个对象并更新声明为易失性的变量，那么这意味着t1 和 t2 可以为对象创建自己的本地缓存除了声明为 volatile 的变量。因此，易失性变量将只有一个主副本，该副本将由不同的线程更新，并且一个线程对易失性变量所做的更新将立即反映到另一个线程。