synchronized(this)理解

1. public class Thread1 implements
2.   
3. /**
4.      * 一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。
5.      * 另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块
6.      * @param args
7.      */
8. public static void
9. new
10. new Thread(t1,"A");  
11. new Thread(t1,"B");  
12.         ta.start();  
13.         tb.start();  
14.     }  
15.   
16. @Override
17. public void
18. synchronized(this){  
19. for(int i=0;i

1. package
2.   
3. public class Thread2 implements
4.   
5. /**
6.      * 然而，当一个线程访问object的一个synchronized(this)同步代码块时，
7.      * 另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。
8.      * @param args
9.      */
10. public static void
11. final Thread2 myt2=new
12. new
13. new
14. public void
15.                 myt2.m4t1();  
16.             }  
17. "t1"
18.         );  
19. new
20. new
21. public void
22.                         myt2.m4t2();  
23.                     }  
24. "t2"
25.                 );  
26.         t1.start();  
27.         t2.start();  
28.     }  
29. public void
30. synchronized(this){  
31. int i=5;  
32. while(i-->0){  
33. " : "+i);  
34.             }  
35. try
36. 500);  
37. catch
38.                 e.printStackTrace();  
39.             }  
40.         }  
41.     }  
42. public void
43. int i=5;  
44. while(i-->0){  
45. " : "+i);  
46.         }  
47. try
48. 500);  
49. catch
50.             e.printStackTrace();  
51.         }  
52.     }  
53. @Override
54. public void
55.           
56.     }  
57.   
58. }

1. package
2.   
3. public class
4.   
5. /**
6.      * 三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，
7.      * 其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。
8.      * @param args
9.      */
10. public static void
11. final Thread3 myt2=new
12. new
13. new
14. public void
15.                 myt2.m4t1();  
16.             }  
17. "Thread3_t1"
18.         );  
19. new
20. new
21. public void
22.                         myt2.m4t2();  
23.                     }  
24. "Thread3_t2"
25.                 );  
26.         t1.start();  
27.         t2.start();  
28.     }  
29. public void
30. synchronized(this){  
31. int i=5;  
32. while(i-->0){  
33. " : "+i);  
34.             }  
35. try
36. 500);  
37. catch
38.                 e.printStackTrace();  
39.             }  
40.         }  
41.     }  
42. public void
43. synchronized(this){  
44. int i=5;  
45. while(i-->0){  
46. " : "+i);  
47.             }  
48. try
49. 500);  
50. catch
51.                 e.printStackTrace();  
52.             }  
53.         }  
54.           
55.     }  
56. }

1. package
2.   
3. public class
4.   
5. /**
6.      * 四、第三个例子同样适用其它同步代码块。
7.      * 也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。
8.      * 结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。
9.      * @param args
10.      */
11. public static void
12. final Thread4 myt4=new
13. new
14. new
15. public void
16.                 myt4.m4t1();  
17.             }  
18. "Thread4_t1"
19.         );  
20. new
21. new
22. public void
23.                         myt4.m4t2();  
24.                     }  
25. "Thread4_t2"
26.                 );  
27.         t1.start();  
28.         t2.start();  
29.     }  
30. public void
31. synchronized(this){  
32. int i=5;  
33. while(i-->0){  
34. " : "+i);  
35.             }  
36. try
37. 500);  
38. catch
39.                 e.printStackTrace();  
40.             }  
41.         }  
42.     }  
43. public synchronized void
44. int i=5;  
45. while(i-->0){  
46. " : "+i);  
47.             }  
48. try
49. 500);  
50. catch
51.                 e.printStackTrace();  
52.             }  
53.           
54.     }  
55. }

1. package

1. public class

1. /**
2.   * @param args
3.   */
4. public static void
5. final Thread5 myt5=new
6. final Inner inner=myt5.new
7. new Thread(new
8. public void
9.     myt5.m4t1(inner);  
10.    }  
11. "Thread5_t1"
12.      );  
13. new Thread(new
14. public void
15.     myt5.m4t2(inner);  
16.    }  
17. "Thread5_t2"
18.      );  
19.   t1.start();  
20.   t2.start();  
21.  }  
22. class
23. private void
24. int i=5;  
25. while(i-->0){  
26. ":Inner.m4t1()="+i);  
27. try{  
28. 500);  
29. catch(Exception e){  
30.           
31.        }  
32.       }  
33.      }  
34. private void
35. int i=5;  
36. while(i-->0){  
37. ":Inner.m4t2()="+i);  
38. try{  
39. 500);  
40. catch(Exception e){    
41.              }  
42.          }  
43.         }  
44.     }  
45. private void
46. synchronized(inner){//使用对象锁
47.      inner.m4t1();  
48.      }  
49.     }  
50. private void
51.      inner.m4t2();  
52.     }  
53.       
54. }