java线程同步

发布于 2024-08-21 06:41:52 字数 226 浏览 8 评论 0原文

在下面的类中，方法 getIt() 线程安全吗？为什么？

public class X { 
  private long myVar; 
  public void setIt(long  var){ 
    myVar = var; 
   }  
   public long getIt() { 
     return myVar; 
  } 
}

原文

In the class below, is the method getIt() thread safe and why?

public class X { 
  private long myVar; 
  public void setIt(long  var){ 
    myVar = var; 
   }  
   public long getIt() { 
     return myVar; 
  } 
}

分享到QQ

分享到微博

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

发布评论

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

别想她 2024-08-28 06:41:52

它不是线程安全的。 Java 中 long 和 double 类型的变量被视为两个单独的 32 位变量。当另一个线程读取两半值时，一个线程可能正在写入并已写入一半值。在这种情况下，读者会看到一个不应该存在的值。

要使此线程安全，您可以将 myVar 声明为 volatile（Java 1.5 或更高版本），或者同时使用 setIt 和 getIt< /code> 已同步。

请注意，即使 myVar 是 32 位 int，您仍然可能会遇到线程问题，其中一个线程可能会读取另一个线程已更改的过时值。发生这种情况的原因是该值已被 CPU 缓存。要解决此问题，您需要再次将 myVar 声明为 volatile（Java 1.5 或更高版本），或者同时使用 setIt 和 getIt <代码>同步。

还值得注意的是，如果您在后续的 setIt 调用中使用 getIt 的结果，例如 x.setIt(x.getIt() * 2)< /code>，那么您可能希望在两个调用之间进行同步：

synchronized(x)
{
  x.setIt(x.getIt() * 2);
}

如果没有额外的同步，另一个线程可能会更改 getIt 和 setIt 调用导致其他线程的值丢失。

It is not thread-safe. Variables of type long and double in Java are treated as two separate 32-bit variables. One thread could be writing and have written half the value when another thread reads both halves. In this situation, the reader would see a value that was never supposed to exist.

To make this thread-safe you can either declare myVar as volatile (Java 1.5 or later) or make both setIt and getIt synchronized.

Note that even if myVar was a 32-bit int you could still run into threading issues where one thread could be reading an out of date value that another thread has changed. This could occur because the value has been cached by the CPU. To resolve this, you again need to declare myVar as volatile (Java 1.5 or later) or make both setIt and getIt synchronized.

It's also worth noting that if you are using the result of getIt in a subsequent setIt call, e.g. x.setIt(x.getIt() * 2), then you probably want to synchronize across both calls:

synchronized(x)
{
  x.setIt(x.getIt() * 2);
}

Without the extra synchronization, another thread could change the value in between the getIt and setIt calls causing the other thread's value to be lost.

回复收藏 0 原文

锦欢 2024-08-28 06:41:52

这不是线程安全的。即使您的平台保证 long 的原子写入，缺乏 synchronized 也可能导致一个线程调用 setIt()，甚至在此调用之后完成后，另一个线程可能可以调用 getIt() 并且此调用可能返回 myVar 的旧值。

synchronized 关键字的作用不仅仅是一个线程对块或方法的独占访问。它还保证第二个线程获知变量的更改。

因此，您要么必须将两种方法标记为“同步”，要么将成员“myVar”标记为“易失性”。

这里有一个关于同步的很好的解释：

原子操作不能交错，因此可以使用它们而不必担心线程干扰。然而，这并不能消除所有同步原子操作的需要，因为内存一致性错误仍然是可能的。使用易失性变量可以降低内存一致性错误的风险，因为对易失性变量的任何写入都会与同一变量的后续读取建立先发生关系。这意味着对易失性变量的更改始终对其他线程可见。更重要的是，这还意味着当一个线程读取一个 volatile 变量时，它不仅会看到 volatile 的最新更改，还会看到导致更改的代码的副作用。