Last updated on 2024年6月1日

What are the differences between the synchronized and volatile keywords in Java?

由人工智能和领英社区提供技术支持

Multithreading is a powerful feature of Java that allows you to run multiple tasks concurrently in a single program. However, it also introduces some challenges, such as ensuring the consistency and visibility of shared data among different threads. To address these issues, Java provides two keywords: synchronized and volatile. In this article, you will learn what are the differences between them and how to use them correctly.

本文章的要点总结

Understand keyword functions:

The synchronized keyword locks a method or block so only one thread can access it at a time, preventing multiple threads from causing inconsistencies with shared data.
Memory visibility with volatile:

Declaring a variable as volatile ensures all threads see the most recent value, providing a lighter, quicker safeguard for simple variables accessed by multiple threads.

本摘要由 AI 和以下专家提供支持

1 Synchronized keyword

The synchronized keyword is used to create blocks or methods that can only be executed by one thread at a time. This ensures that the shared data is protected from concurrent modifications and that the changes made by one thread are visible to others. For example, you can use synchronized to implement a counter that increments atomically:

class Counter {
  private int value = 0;

  public synchronized void increment() {
    value++;
  }

  public synchronized int getValue() {
    return value;
  }
}

添加您的观点

Constantine Sapuntzakis
举报内容
By writing code in such a way that a variable is only read or written inside the synchronized block, we can ensure that only one thread at a time is reading or writing to the variable. The changes made under one synchronized block are guaranteed to be visible in synchronized blocks that are subsequently executed, even on different threads. These two properties only apply to synchronize blocks on the same object. That is if you have two Counter objects, then setValue on the first counter and setValue on the second counter can run in parallel. Similarly calling setValue on the first counter is not guaranteed to make the second counter’s value visible.

已翻译

赞
Divyajyothi H.

Full Stack Software Engineer | Master’s in Computer Science | Expertise in Java, Microservices, and Cloud Technologies
举报内容
In Java, when multiple threads try to change the same shared piece of data simultaneously, it can cause a problem known as a "race condition." This is like several people trying to write on the same piece of paper at the same time – the result can be messy and incorrect. To prevent this chaos, Java offers a solution called "synchronization." It's like putting a traffic light at a busy intersection to make sure only one car can pass through at a time. When you mark a piece of code as "synchronized" in Java, you're basically saying, "Hey, only one thread can go through this part at a time, please." You can use synchronization on methods or blocks of code.

已翻译

赞
Shekhar Prasad Rajak

Open Source | Software Developer @ ?
举报内容
Internally it is a mutex, which can be used by one thread at a time, if it is in unlock state. Below C++ code snippet helps to absorb the concept better : std::mutex mtx; // Declare a mutex void increment() { mtx.lock(); // Lock the mutex before accessing shared resources value++; mtx.unlock(); // Unlock the mutex after accessing shared resources }

已翻译

赞

2 Volatile keyword

The volatile keyword is used to mark a variable as volatile, which means that its value is always read from and written to the main memory, not the local cache of each thread. This ensures that the variable is always updated and visible to all threads, without the need for synchronization. For example, you can use volatile to implement a flag that signals the termination of a thread:

class Worker implements Runnable {
  private volatile boolean stop = false;

  public void run() {
    while (!stop) {
      // do some work
    }
  }

  public void stop() {
    stop = true;
  }
}

添加您的观点

Divyajyothi H.

Full Stack Software Engineer | Master’s in Computer Science | Expertise in Java, Microservices, and Cloud Technologies
举报内容
In Java, when you have multiple threads running at the same time, they might try to access the same variable simultaneously. This can lead to unexpected behavior and errors in your program. To prevent this, Java offers a keyword called "volatile". When you declare a variable as volatile, it tells Java that this variable might be accessed by multiple threads. Think of it like a flag that tells Java, "Hey, other threads might be looking at this variable too, so be careful!" Using volatile is like using a very light form of protection for your variable. It's not as heavy as some other ways of protecting your variables, so it's good for situations where you want to keep things simple and fast.

已翻译

赞
Robert Horvick

Engineering Manager at Google Cloud
举报内容
Visibility is a key point but another is that volatile provides guarantees around ordering. It can also prevent torn reads (part of visibility)

已翻译

赞
Constantine Sapuntzakis
举报内容
“without the need for synchronization” probably should be “without the need for a synchronized block” Volatile arguable provides some synchronization between threads

已翻译

赞

3 Differences between synchronized and volatile

Synchronized and volatile have several key differences. Synchronized guarantees both atomicity and visibility, while volatile only guarantees visibility. Furthermore, synchronized can be applied to blocks or methods, whereas volatile can only be applied to variables. Additionally, synchronized has a performance cost due to its requirement for locking and unlocking, whereas volatile has a lower cost as it only affects memory access. Lastly, synchronized can be used for complex operations such as incrementing a counter, while volatile can only be used for simple assignments like setting a flag.

添加您的观点

4 When to use synchronized and volatile

When working with shared data, you should use synchronized or volatile depending on the situation and requirements. Generally, you should use synchronized when you need to ensure the atomicity and visibility of multiple statements or operations. On the other hand, volatile should be used when you need to ensure the visibility of a single variable that is accessed by multiple threads. It is best to avoid using both synchronized and volatile together, as it may cause performance issues. Where possible, it is preferable to use higher-level concurrency utilities, such as atomic classes, locks, or concurrent collections, which provide more functionality and flexibility than synchronized and volatile.

添加您的观点

Ankur Agarwal

Software Engineer 2 at Atlassian| Former SDE intern at Samsung R&D bangalore | NIT Warangal 2021
举报内容
Synchronized keywords bring mutual exclusion and can impact performance in scenarios with high contention because it is concerned with following commands acquiring/releasing locks, context switching, and additional CPU instructions for managing the locking mechanism whereas volatile keyword is lightweight because it is not concerned with mutual conclusion. So wherever mutual exclusion is not the requirement volatile is preferable to synchronized.

已翻译

赞

5 Common mistakes and pitfalls

Using synchronized and volatile correctly can be tricky and error-prone. You should not assume that volatile variables are thread-safe and can cause race conditions if they are involved in compound operations. Synchronized blocks can still interfere with each other if they use the same lock object or access the same shared data. Additionally, non-volatile variables can still be visible to other threads if they are accessed within synchronized blocks or methods, or if they are declared as final or static. To avoid such mistakes and pitfalls, you should use atomic classes, synchronized blocks, different lock objects, fine-grained synchronization, volatile, or synchronization.

添加您的观点

6 Here’s what else to consider

This is a space to share examples, stories, or insights that don’t fit into any of the previous sections. What else would you like to add?

添加您的观点

Multithreading

+ 关注

给文章评分

我们借助人工智能创建了此文章。您认为这篇文章怎么样？

很棒不太好

举报此文章

查看全部

What are the differences between the synchronized and volatile keywords in Java?

1

2

3

4

5

6

1 Synchronized keyword

2 Volatile keyword

3 Differences between synchronized and volatile

4 When to use synchronized and volatile

5 Common mistakes and pitfalls

6 Here’s what else to consider

Multithreading

给文章评分

感谢您的反馈

更多Multithreading相关文章

更多相关阅读内容