Static variables, instance variables, local variables for Java thread safety issues

Java multithreaded programming, there are many thread security issues, as to what is thread safety, it is difficult to give an easy-to-understand concept, as in the Java Concurrency programming practice, said:

It is difficult to write a definition of thread safety. There are many definitions, such as: "A class is thread safe when it can be called by multiple threads."

Do not repeat here, first give the static variables, instance variables, local variables in the multi-threaded environment of the thread safety conclusions, and then use the example to verify, please eyes peeled, wrong must investigate, otherwise fraught!

Static variable: thread is not secure.

A static variable is a class variable, located in the method area, shared for all objects, shares a portion of memory, and once the static variable is modified, the other objects are visible to the modification, so the thread is not secure.

Instance variables: Singleton mode (only one object instance exists) thread is not secure, not singleton thread safe.

Instance variables are private to the object instance, allocated in the heap of the virtual machine, if there is only one instance of this object in the system, in multi-threaded environment, "like" static variable, after being modified by a thread, other threads are visible to the modification, so the thread is not safe, if each thread executes in a different object, The modification of the instance variable between the object and the object will not affect each other, so thread safety.

Local variables: thread safety.

Each thread executes a local variable in the working memory of its own stack frame and is not shared between threads, so there is no thread-safety issue.

Static variable thread safety problem simulation:

----------------------------------------------------------------------------------

Java code

2. /**
4. * Thread safety problem simulation execution
6. *  ------------------------------
8. * Thread 1 | Thread 2
10. *  ------------------------------
12. * Static_i = 4; | Wait
14. * static_i = 10; | Wait
16. * wait | Static_i = 4;
18. * Static_i * 2; | Wait
20. *  -----------------------------
22. * */
24. Public class Test implements Runnable
26. {
28. private static int static_i; Static variables
32. public Void Run ()
34. {
36. Static_i = 4;
38. System.out.println ("[" + Thread.CurrentThread (). GetName ()
40. + "] Gets the value of the static_i:" + static_i);
42. Static_i = 10;
44. System.out.println ("[" + Thread.CurrentThread (). GetName ()
46. + "] Gets the value of the static_i*3:" + static_i * 2);
48. }
52. public static void Main (string[] args)
54. {
56. Test T = new test ();
58. //start as many threads as possible to simulate problems easily
60. For (int i = 0; i < ; i++)
62. {
64. //t can be replaced with new Test () to ensure that each thread executes in a different object, as the result
66. new Thread (t, "thread" + i). Start ();
68. }
70. }
72. }

According to the scenario that is simulated in the code comment, when thread 1 executes static_i = 4; Static_i = 10; After that, thread 2 gets the execution right, static_i = 4;  Then when thread 1 gets execution execution static_i * 2; Inevitably the output results are 4*2=8, according to this simulation, we may see the output as a result of 8 in the console.

wrote [Thread 27] Gets the value of Static_i: 4
[Thread 22] Gets the value of static_i*2:20
[Thread 28] Gets the value of Static_i: 4
[Thread 23] Gets the value of static_i*2:8
[Thread 29] Gets the value of Static_i: 4
[Thread 30] Gets the value of Static_i: 4
[Thread 31] Gets the value of Static_i: 4
[Thread 24] Gets the value of static_i*2:20

Looking at the red-labeled parts, we did have our expectations, as well as our conclusions.

Instance variable thread safety problem simulation:

----------------------------------------------------------------------------------

Java code

2. Public class Test implements Runnable
4. {
6. private int instance_i; Instance variable
10. public Void Run ()
12. {
14. Instance_i = 4;
16. System.out.println ("[" + Thread.CurrentThread (). GetName ()
18. + "] Gets the value of the instance_i:" + instance_i);
20. Instance_i = 10;
22. System.out.println ("[" + Thread.CurrentThread (). GetName ()
24. + "] Gets the value of the instance_i*3:" + instance_i * 2);
26. }
30. public static void Main (string[] args)
32. {
34. Test T = new test ();
36. //start as many threads as possible to simulate problems easily
38. For (int i = 0; i < ; i++)
40. {
42. //Each thread pair runs in object T, simulating a single case
44. new Thread (t, "thread" + i). Start ();
46. }
48. }
50. }

According to the analysis at the beginning of this article, as with static variables, each thread is modifying an instance variable of the same object, and there is definitely a thread-safety issue.

Wrote

[Thread 66] Gets the value of Instance_i: 10
[Thread 33] Gets the value of instance_i*2:20
[Thread 67] Gets the value of Instance_i: 4
[Thread 34] Gets the value of instance_i*2:8
[Thread 35] Gets the value of instance_i*2:20
[Thread 68] Gets the value of Instance_i: 4

Look at the red font, the instance variable thread is not safe in a single case.

Add the new thread (T, "thread" + i). Start (), and change to new thread (new Test (), "thread" + i). Start (); Simulates a non-singleton case where there is no thread safety issue.

Local variable threading Security problem simulation:

----------------------------------------------------------------------------------

Java code

2. Public class Test implements Runnable
4. {
6. public Void Run ()
8. {
10. int local_i = 4;
12. System.out.println ("[" + Thread.CurrentThread (). GetName ()
14. + "] Gets the value of the local_i:" + local_i);
16. Local_i = 10;
18. System.out.println ("[" + Thread.CurrentThread (). GetName ()
20. + "] Gets the value of the local_i*2:" + local_i * 2);
22. }
26. public static void Main (string[] args)
28. {
30. Test T = new test ();
32. //start as many threads as possible to simulate problems easily
34. For (int i = 0; i < ; i++)
36. {
38. //Each thread pair runs in object T, simulating a single case
40. new Thread (t, "thread" + i). Start ();
42. }
44. }
46. }

The console does not have exception data.

---------------------------------------------------------------

The above is just a simple example to show the static variables, instance variables, local variables, such as thread safety problems,

Without the underlying analysis, the next article will dissect the underlying thread problem.

Static methods are thread-safe

First look at a class

public class test{

public static string Hello (String str) {

String tmp= "";

tmp = tmp+str;

return tmp;

}

}

Will the Hello method have multiple thread safety issues? No!!

Static methods There is no thread-safety issue if static variables are not used.

Why is it? Because of variables declared within a static method, each thread is called to create a new copy without sharing a single storage unit. For example, the tmphere, each thread will create its own copy, so there is no wired security issues

Note that static variables, because they occupy a store during class loading, each thread is shared with this store, so if static variables are used in static methods, this will be a security issue for threads!

Summary: As long as the method contains static variables, it is non-thread-safe

From: http://blog.csdn.net/aaa1117a8w5s6d/article/details/8295527

(go) Static variables, instance variables, local variables for Java thread safety issues