Threads are mutually exclusive to ensure that at most one thread executes the code at the same time. So what problems does it solve? Account deposits and withdrawals can only be operated by one person at the same time.

Let's look at a simple example (the problem of multithreading):

1. public class TraditionalThreadSynchronized {  
2.   
3.     /** 
4.      * @param args 
5.      */  
6.     public static void main(String[] args) {  
7.         new TraditionalThreadSynchronized().init();  
8.     }  
9.       
10.     private void init(){  
11.         //This method starts two threads at the same time to call the printed name of the same method.  
12.         final Outputer outputer = new Outputer();  
13.         new Thread(new Runnable(){  
14.             @Override  
15.             public void run() {  
16.                 while(true){  
17.                     try {  
18.                         Thread.sleep(10);  
19.                     } catch (InterruptedException e) {  
20.                         e.printStackTrace();  
21.                     }  
22.                     outputer.output("zhangxiaoxiang");  
23.                 }                 
24.             }  
25.         }).start();  
26.           
27.         new Thread(new Runnable(){  
28.             @Override  
29.             public void run() {  
30.                 while(true){  
31.                     try {  
32.                         Thread.sleep(10);  
33.                     } catch (InterruptedException e) {  
34.                         e.printStackTrace();  
35.                     }  
36.                     outputer.output3("lihuoming");  
37.                 }  
38.                   
39.             }  
40.         }).start();  
41.           
42.     }  
43.   
44.     static class Outputer{  
45.           
46.         public void output(String name){  
47.             int len = name.length();  
48. //          synchronized (Outputer.class)   
49. //          {  
50.                 for(int i=0;i<len;i++){  
51.                     System.out.print(name.charAt(i));  
52.                 }  
53.                 System.out.println();  
54. //          }  
55.         }  
56.           
57.     }  
58. }  

The printing results are as follows:

To solve the above problems:

Add the synchronized keyword, that is, unscramble the comment.

Print results:

Summary:

When two concurrent threads access this synchronized(this) block of synchronized code in the same object, only one thread can be executed in one time. Another thread must wait for the current thread to execute the code block before it can execute the code block. That is, when a thread accesses a synchronized(this) block of synchronized code in an object, access to all other synchronized(this) blocks of synchronized code in the object will be blocked by other threads.

Note: To be mutually exclusive, the lock must be the same. In the demo above, both threads use the same new output, so output is the same object.

See the blog for details. Synchronized threads

Brief Answer Notes:

1. public class Test implements Runnable {  
2.   
3.     public int cash = 100;  
4.   
5.     public synchronized void m() {  
6.         System.out.println("m View Accounts,The balance is"+cash);  
7.         try {  
8.              Thread.sleep(2000);  
9.         } catch (InterruptedException e) {  
10.              e.printStackTrace();  
11.         }  
12.         cash = cash - 100;  
13.         System.out.println("cash1 = " + cash);  
14.     }  
15.   
16.     public synchronized void run() {  
17.         System.out.println("run Look at the account with the balance of ____________"+cash);  
18.         cash += 1000;  
19.         try {  
20.             Thread.sleep(5000);  
21.          } catch (InterruptedException e) {  
22.              e.printStackTrace();  
23.          }  
24.         System.out.println("cash2 = " + cash);  
25.     }  
26.   
27.     public static void main(String[] args) {  
28.         Test test = new Test();  
29.         Thread thrad = new Thread(test);  
30.         thrad.start();  
31.         test.m();  
32.     }  
33. }  

You can see by adding the synchronized keyword. As long as m or run operates on the account, no matter how long it takes in the middle or how long it sleeps, the thread will execute this method before executing other methods. Both methods must add the synchronized keyword, and both lock the same object (the object locked here is the test object). That is to say, as long as one thread enters any locked method of the test object, the other threads can not access the method with the same lock in the object.