Shulou(Shulou.com)06/03 Report--

This article introduces the knowledge of "what is the difference between visibility in single-threaded and multithreaded". Many people will encounter this dilemma in the operation of actual cases. then let the editor lead you to learn how to deal with these situations! I hope you can read it carefully and be able to achieve something!

Brief introduction

When a thread modifies a shared variable (a non-local variable that is accessible to all threads), other threads can always read the latest value immediately, so we say that the variable is visible.

If it is a single thread, there is no doubt about the visibility, and you can see it if you change it (rectum, whatever you say, everyone can see it).

But if it is multithreaded, then visibility needs to be maintained through some means, such as locking or volatile modifiers.

PS: actually, there is no real rectum. According to scientific research, people's intestines are about 8 meters long (~ 5 times their height).

Catalogue

Visibility comparison between single-threaded and multithreaded

Volatile modifier

Instruction reordering

The difference between volatile and locking

Text 1. Visibility comparison between single-threaded and multithreaded

Here, let's take a look at two examples to understand what the visibility issue is.

Here is an example of a single thread with a shared variable

Public class SignleThreadVisibilityDemo {/ / shared variable private int number; public void setNumber (int number) {this.number = number;} public int getNumber () {return this.number;} public static void main (String [] args) {SignleThreadVisibilityDemo demo = new SignleThreadVisibilityDemo (); System.out.println (demo.getNumber ()); demo.setNumber (10) System.out.println (demo.getNumber ());}}

The output is as follows: you can see that the first shared variable number is the initial value of 0, but after calling setNumber (10), the read becomes 10.

010

If you change it, you can see that it would be nice if multithreading were so simple (from the rookie's inner monologue).

Let's look at an example of multithreading, the same shared variable.

Package com.jalon.concurrent.chapter3;/** *

* visibility: visibility issues of multithreading *

* * @ author: JavaLover * @ time: 2021-4-27 * / public class MultiThreadVisibilityDemo {/ / shared variable private int number; public static void main (String [] args) throws InterruptedException {MultiThreadVisibilityDemo demo = new MultiThreadVisibilityDemo (); new Thread (()-> {/ / here we do a false dead loop, only to loop while (0==demo.number) without assigning a value to number (except initialization) System.out.println (demo.number);}) .start (); Thread.sleep (1000); / / 168is not height, it's just an auspicious number demo.setNumber (1000);} public int getNumber () {return number;} public void setNumber (int number) {this.number = number;}}

The output is as follows:

You read it correctly, but the output is empty and the program is running all the time (you haven't tried it, if you don't turn it off, will there be a day when you output number)

Then there is the visibility problem, that is, the main thread changes the shared variable number, but the child thread cannot see it.

What is the reason?

Let's use the picture to talk. It will be easier.

The steps are as follows:

The child thread reads the number into its own stack and backs up

The main thread reads number, modifies, writes, and synchronizes to memory

The child thread is not aware of the change in number at this time, but still reads the backup ready in its own stack (possibly due to various performance optimizations)

So how to solve it?

Lock or volatile modifier, here we add volatile

The modified code is as follows:

Public class MultiThreadVisibilityDemo {/ / shared variable with volatile modifier added, number will not be backed up to other threads, only private volatile int number; public static void main (String [] args) throws InterruptedException {MultiThreadVisibilityDemo demo = new MultiThreadVisibilityDemo (); new Thread (()-> {while (0==demo.number); System.out.println (demo.number);} .start ()) will exist in shared heap memory. Thread.sleep (1000); / / 168It's not height, it's just a lucky number demo.setNumber;} public int getNumber () {return number;} public void setNumber (int number) {this.number = number;}}

The output is as follows:

one hundred and sixty eight

As you can see, as we expected, the child thread can see the changes made by the main thread

Let's explore the little world of volatile.

2. Volatile modifier

Volatile is a slightly weaker synchronization mechanism than locking. The biggest difference between it and locking is that it cannot guarantee atomicity, but it is lightweight.

Let's finish the above example first.

After we add the volatile modifier, the child thread can see the changes made by the main thread, so what exactly does volatile do?

In fact, we can think of volatile as a sign. If the virtual machine sees this flag, it will think that the variable modified by it is changeable, unstable, and may be modified by a thread at any time.

At this point, the virtual machine will not reorder the instructions related to this variable (described below), and will notify each thread of the change of this variable in real time (visibility).

If you use a picture, it looks like this:

As you can see, the number backup in the thread is no longer needed, and every time number is needed, it is read directly into the heap memory, thus ensuring the visibility of the data.

3. Instruction reordering

Instruction reordering means that the virtual machine sometimes adjusts the execution order of certain instructions in order to optimize performance, as long as the dependency of the instruction cannot be broken (for example, int a = 10; int b = a; there is no reordering at this time)

Let's take a look at the code that might be reordered:

Public class ReorderDemo {public static void main (String [] args) {int a = 1; int b = 2; int m = a + b; int c = 1; int d = 2; int n = c-d;}}

Here we need to understand a low-level knowledge, that is, the execution of each statement is carried out in several steps in the underlying system (for example, the first step, the second step, the third step, etc.). Here we will not involve the compilation knowledge. If you are interested, please refer to "practical Java High concurrency" 1.5.4).

Now let's go back to the above example, the dependency is as follows:

As you can see, they are stacked in groups of three or three, independent of each other, and if a reorder occurs at this time, it may be arranged like this

(the above figure is only a demonstration of the effect at the code level. In fact, the reordering of instructions is much more detailed than this. Here we mainly understand the idea of reordering.)

Because m=a+b depends on the values of an and b, when the instruction is executed to the add section of m=a+b, if b is not ready, m=a+b needs to wait for b, and the following instructions will also wait.

But if you reorder and put m=a+b behind, you can take advantage of the gap that add is waiting for to prepare c and d

This reduces waiting time and improves performance (it feels a bit like C in school, habitually defining a bunch of variables before writing code)

4. The difference between volatile and locking

The difference is as follows

Locked volatile atomicity ✅❎ visibility ✅✅ ordering ✅✅

The ordering mentioned above refers to prohibiting the reordering of instructions, so that the problem of disorder will not occur in multithreading.

As we can see, the biggest difference between locking and volatile is atomicity.

Mainly because volatile only modifies a variable, it is a bit like a compound operation of atomic variables (although atomic variables themselves are atomic operations, there is no guarantee that multiple atomic variables are put together)

That's all for the content of "what's the difference between visibility in single-threaded and multithreaded". Thank you for reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.