Use and learning of synchronize locks in java multithreading, Thread multithreading Learning (2), synchronizethread

Use and learning of synchronize locks in java multithreading, Thread multithreading Learning (2), synchronizethread

Synchronize I understand is to ensure atomicity and consistency in the program, that is, when you have two threads to operate a piece of code at the same time, make sure that the execution of this Code is correct in any State. First, make sure that synchronize is used for the same object and the same lock.

 

[Java]View plain copy print?

1. <Span style = "font-size: 14px;"> public class TraditionalThreadSynchronized {
4. Public static void main (String [] args ){
5. TraditionalThreadSynchronized test = new TraditionalThreadSynchronized ();
6. Test. init (); // create the same object
7. }
9. Private void init (){
10. OutPuter outPuter = new OutPuter ();
11. New Thread (new Runnable (){
12. @ Override
13. Public void run (){
14. Try {
15. While (true ){
16. Thread. sleep (10 );
17. OutPuter. outer ("abcdefg ");
18. }
19. } Catch (InterruptedException e ){
20. E. printStackTrace ();
21. }
22. }
23. }). Start (); // thread 1
24. New Thread (new Runnable (){
25. @ Override
26. Public void run (){
27. Try {
28. While (true ){
29. Thread. sleep (10 );
30. OutPuter. outer ("123456789 ");
31. }
32. } Catch (InterruptedException e ){
33. E. printStackTrace ();
34. }
35. }
36. }). Start (); // thread 2
37. }
38. Class OutPuter {
39. Public synchronized void outer (String name ){
40. For (int I = 0; I <name. length (); I ++ ){
41. System. out. print (name. charAt (I ));
42. }
43. System. out. println ();
44. }
45. }
46. } </Span>

The output result we want to print is abcdefg and 123456789, but the output result is

 

 

We found that the printed results are printed alternately by two strings, so this thread is not safe now, so we need to use synchronize to maintain the atomicity of the two threads, next, let's add the synchronize lock to the OutPut method in the above program.

 

[Java]View plain copy print?

1. <Span style = "font-size: 14px;"> class OutPuter {
2. Public void outer (String name ){
3. Synchronized (name ){
4. For (int I = 0; I <name. length (); I ++ ){
5. System. out. print (name. charAt (I ));
6. }
7. System. out. println ();
8. }
9. }
10. } </Span>

 

We found that this thread is not safe after the lock with the synchronize keyword is applied. Why? The reason lies in the lock name, because one of the two threads is abcdefg and the other is 123456789. The two locks are not a lock at all, so the thread is also insecure, then let's modify the above method.

 

[Java]View plain copy print?

1. <Span style = "font-size: 14px;"> class OutPuter {
2. Public void outer (String name ){
3. Synchronized (this) {// or create a new lock. You can change this to a lock. Here this refers to the outer object.
4. For (int I = 0; I <name. length (); I ++ ){
5. System. out. print (name. charAt (I ));
6. }
7. System. out. println ();
8. }
9. }
10. } </Span>

At this time, we found that the program running above will not have thread security issues.

 

We can add the above syn to the outer at this time.

 

[Java]View plain copy print?

1. Class OutPuter {
2. Public synchronized void outer (String name ){
3. For (int I = 0; I <name. length (); I ++ ){
4. System. out. print (name. charAt (I ));
5. }
6. System. out. println ();
7. }
8. }

This can also achieve thread security, but under normal circumstances, synchronize only needs to be used once in a piece of code, because multiple synchronize may have a deadlock problem!

 

Now let's modify the OutPuter class above.

 

[Java]View plain copy print?

1. Class OutPuter {
2. Public void outer (String name ){
3. Synchronized (this ){
4. For (int I = 0; I <name. length (); I ++ ){
5. System. out. print (name. charAt (I ));
6. }
7. System. out. println ();
8. }
9. }
10. Public synchronized void outer2 (String name ){
11. For (int I = 0; I <name. length (); I ++ ){
12. System. out. print (name. charAt (I ));
13. }
14. System. out. println ();
15. }
16. Span style = "font-size: 14px;" >}</span>

 

Then, change outPuter. outer ("123456789") to outPuter. outer2 ("123456789 ")

 

 

Can thread security be ensured at this time, that is, will output and output2 be mutually exclusive? Of course, it is also possible, because the two locks at this time also represent the same lock, both represent the current object, and the current object is an object at this time, so we can achieve the desired effect.

 

In this case

 

Change outPuter. outer ("123456789") to new outPuter (). outer ("123456789 ")

 

 

We will find that there will still be thread security issues. Why? That's because the new OutPuter () is not the same object each time. Therefore, synchronize must be the same object and the same lock.

Now let's add an output3 method.

 

 

[Java]View plain copy print?

1. Public static synchronized void outer3 (String name ){
2. For (int I = 0; I <name. length (); I ++ ){
3. System. out. print (name. charAt (I ));
4. }
5. System. out. println ();
6. Span style = "font-size: 14px;" >}</span>

 

Note that the output3 method is static, so we need to change the OutPuter class to a static class.

 

Then, change outPuter. outer ("123456789") to outPuter. outer3 ("123456789 ")

 

The answer is no, because the lock in output3 we use is a class lock, and the lock in output is the current object lock, which is not a lock at all, so what should we do if we want to synchronize output and output3? We can change this in output to OutPuter. class to implement synchronization. At this time, the locks of both methods are class locks, that is, the same lock.

The thread is still learning, and learning is painful, but I hope I can really stick to one thing!