Java Multithreading Summary Four: volatile, synchronized example

1, Synchronized guarantee synchronization

Let's look at a class that generates even numbers.

[Java]View Plaincopy

2. <span style="FONT-SIZE:16PX;"  > Packagedemo.thread;
6. /**
8. * This is an abstract class for an int generator
10. *
12. */
14. Public Abstract class Intgenerator {
18. Private volatile Boolean canceled = false;
22. public Abstract int next ();
26. public void Cancel () {
28. Canceled = true;
30. }
34. Public Boolean isCanceled () {
36. return canceled;
38. }
40. }
42. </span>

[Java]View Plaincopy

2. <span style="FONT-SIZE:16PX;" >/*
4. * Generate even numbers
6. */
8. Class Evengenerator extends Intgenerator {
10. private int currentevenvalue = 0;
12. String s = "";
16. @Override
18. public int Next () {
20. <span style="color: #ff0000;" >synchronized </span> (s) {
22. ++currentevenvalue;
24. ++currentevenvalue;
26. return currentevenvalue;
28. }
30. }
34. This can also
36. Public <span style= "color: #ff0000;" >synchronized </span>int Next () {
38. ++currentevenvalue;
40. ++currentevenvalue;
42. return currentevenvalue;
44. //  }
46. }</span>

Note that in the generation of even is to add a synchronous lock, or maybe thread 1 just executed a sentence of ++currentevenvalue, the operation, the thread 2 was robbed of the CPU, the thread 2 executes return currentevenvalue, then returned is an odd number. Plus synchronized is the code of two threads that can execute synchronized blocks at the same time only one thread .

Test code:

[Java]View Plaincopy

2. <span style="FONT-SIZE:16PX;"  > Packagedemo.thread;
6. Import Java.util.concurrent.ExecutorService;
8. Import java.util.concurrent.Executors;
12. /*
14. * Consumption figures
16. */
18. Public class Evenchecker implements Runnable {
22. private Intgenerator Generator;
24. private final int id;
28. Public Evenchecker (intgenerator g, int ident) {
30. Generator = g;
32. id = ident;
34. }
38. public Void Run () {
40. While (!generator.iscanceled ()) {
42. int val = Generator.next ();
44. if (val% 2 = 0) {//If not even
46. System.out.println (val + "not enen!");
48. Generator.cancel ();
50. }
52. }
54. }
58. public static void Test (Intgenerator GP, int count) {
60. Executorservice exec = Executors.newcachedthreadpool ();
62. For (int i = 0; i < count; i++)
64. Exec.execute (New Evenchecker (GP, i));
66. Exec.shutdown ();
68. }
72. public static void Test (Intgenerator gp) {
74. Test (GP, 10);
76. }
80. public static void Main (string[] args) {
82. Test (New Evengenerator ());
84. }
86. }</span>

Analysis: If the class that produces even numbers is not synchronized, then the test program will appear odd to cause the program to exit.

2, volatile indicates atomicity, visibility.

For variables shared between multiple threads, each thread has its own copy, and when thread 1 changes the value of the variable, other threads do not immediately know that the variable value has changed, and volatile guarantees that the value of the variable is visible to each thread, and that the value is changed by a thread in the other thread immediately. Atomicity indicates that the operation is not interruptible, such as the basic variable assignment.

code example:

[Java]View Plaincopy

2. <span style="FONT-SIZE:16PX;"  > Packagedemo.thread;
6. Public class Volatiledemo implements Runnable {
10. Private volatile int i = 0; Volatile setting visibility
14. public synchronized int GetValue () {
16. return i;
18. }
22. private synchronized void Enenincrement () {
24. i++;
26. i++;
28. }
32. @Override
34. public Void Run () {
36. While (true)
38. Enenincrement ();
40. }
44. public static void Main (string[] args) {
46. Volatiledemo at = new Volatiledemo ();
48. new Thread (at). Start ();
50. While (true) {
52. int val = At.getvalue ();
54. if (val% 2 = 0) {//appears odd, exits the program
56. System.out.println (val+"is not enen!");
58. System.exit (0);
60. }
62. }
66. }
68. }
70. </span>

Note that the i++ operation is not an atomic line operation, and the GetValue () method should also be added synchronized.

Java Multithreading Summary Four: volatile, synchronized example