Lock（本地同步）鎖的8種情況

總結與說明：

  1.  * 題目：
  2.  * 1.標準訪問，請問是先列印郵件還是簡訊  Email
  3.  * 2.email方法新增暫停4秒鐘，請問是先列印郵件還是簡訊    Email
  4.  * 3.新增普通的hello方法，請問先列印郵件還是hello    hello
  5.  * 4.兩部手機，請問先列印郵件還是簡訊   SMS
  6.  * 5.兩個靜態同步方法，1部手機，請問先列印郵件還是簡訊     Email
  7.  * 6.兩個靜態同步方法，2部手機，請問先列印郵件還是簡訊     Email
  8.  * 7.一個普通同步方法，一個靜態同步方法，1部手機，請問先列印郵件還是簡訊     SMS
  9.  * 8.一個普通同步方法，一個靜態同步方法，2部手機，請問先列印郵件還是簡訊     SMS
  10.  *
  11.  * lock1、2
  12.  * 一個物件裡面如果有多個synchronized方法，某一時刻內，只要一個執行緒去呼叫其中的一個synchronized方法，
  13.  * 其他的執行緒都只能等待，換句話說，某一時刻內，只能有唯一一個執行緒去訪問這些synchronized方法，
  14.  * 鎖的是當前物件的this，被鎖定後，其它的執行緒都不能進入到當前物件的其它的synchronized方法
  15.  *
  16.  * lock3、4
  17.  * 加個普通的方法後和同步鎖無關
  18.  * 換成兩個物件後，不是同一把鎖了，情況立刻變化
  19.  *
  20.  * lock5、6
  21.  * 都換成靜態同步方法後，情況又變化（靜態鎖的是Class類物件）
  22.  * 若是普通同步方法，new   this，具體的一部一部手機，所有的普通同步方法用的都是同一把鎖----示例物件本身
  23.  * 若是靜態同步方法，static   class，唯一的一個模板
  24.  * synchronized是實現同步的基礎：Java中的每一個物件都可以作為鎖
  25.  * 具體表現為一下3種形式。
  26.  * 對於普通同步方法，鎖是當前例項物件。它等同於 對於同步方法塊，鎖是synchronized括號裡的配置的物件。
  27.  * 對於靜態同步方法，鎖是當前類的Class類元資訊
  28.  *
  29.  * lock7、8
  30.  * 當一個執行緒試圖訪問同步程式碼塊時它首先必須得到鎖，退出或丟擲異常時必須釋放鎖
  31.  *
  32.  * 所有的同步方法用的都是同一把鎖----例項物件本身，就是new出來的具體例項物件本身
  33.  * 也就是說如果一個例項物件的普通同步方法獲取鎖後，該例項物件的其他普通同步方法必須等待獲取鎖的方法釋放鎖後才能獲得鎖
  34.  * 可是別的例項物件的普通同步方法因為跟該例項物件的普通同步方法用到是不同鎖，所以不用等待該例項物件已獲取鎖的普通
  35.  * 同步方法釋放鎖就可以獲取它們自己的鎖
  36.  *
  37.  * 所有的靜態同步方法用的也是同一把鎖----類物件本身，就是我們說過的唯一模板Class
  38.  * 具體例項物件this和唯一模板Class，這兩把鎖是兩個不同的物件，所有靜態同步方法與普通同步方法之間是不會有競態條件的，
  39.  * 但是一旦一個靜態同方法獲取鎖後，其他的靜態同步方法都必須等待該方法釋放鎖後才能獲取鎖。

lock1、2、3一個例項物件

lock4、5、6、7、8兩個例項物件

lock1

1.標準訪問，請問是先列印郵件還是簡訊？ 答案：Email

sendEmail()與sendSms()都是普通同步方法，都使用synchronized鎖

這裡按方法呼叫順序，依次執行，當前synchronized鎖住的是同一個例項物件

  1. package day02_lam;
  3. import java.util.concurrent.TimeUnit;
  5. class Phone{
  6.     public synchronized void sendEmail() throws InterruptedException{
  7.          System.out.println("------------sendEmail");
  8.     }
  10.     public  synchronized void sendSms(){
  11.      System.out.println("------------sendSMS");
  12.     }
  14. }
  16. /**
  17. *題目：
  18. *1.標準訪問，請問是先列印郵件還是簡訊     Email
  19. */
  20. public class Lock8{
  21. 	public static void main(String[] args) throws InterruptedException{
  22.         Phone phone=new Phone();
  23.         //執行緒A傳送Email
  24.         new Thread(()->{
  25.                 try{
  26.                     phone.sendEmail();
  27.                 }catch(InterruptedExceptione){
  28.                     e.printStackTrace();
  29.                 }
  30.             },"A").start();
  32.         Thread.sleep(300);
  34.         //執行緒B傳送簡訊
  35.         newThread(()->{
  36.             phone.sendSms();
  37.         },"B").start();
  38.     }
  39. }

lock2

2.email方法新增暫停4秒鐘，請問是先列印郵件還是簡訊？ 答案：Email

lock2是lock1的變形，其原理與lock1一致，synchronized鎖住的是同一個物件，必須等到第一個方法把鎖釋放後，第二個方法才能夠獲得鎖

  1. package day02_lam;
  3. import java.util.concurrent.TimeUnit;
  5. class Phone{
  6. 	public synchronized void sendEmail()throwsInterruptedException{
  7.         //睡眠4秒種
  8. 		TimeUnit.SECONDS.sleep(4);
  9. 		System.out.println("------------sendEmail");
  10. 	}
  12. 	public synchronized void sendSms(){
  13. 		System.out.println("------------sendSMS");
  14. 	}
  16. }
  18. /**
  19. *題目：
  20. *1.標準訪問，請問是先列印郵件還是簡訊Email
  21. *2.email方法新增暫停4秒鐘，請問是先列印郵件還是簡訊Email
  22. */
  23. public class Lock8{
  24.     public static void main(String[] args)throws InterruptedException{
  25.         //資源類
  26.         Phone phone=new Phone();
  28.         //執行緒A sendEmail
  29.         newThread(()->{
  30.             try{
  31.                 phone.sendEmail();
  32.             }catch(InterruptedExceptione){
  33.                 e.printStackTrace();
  34.             }
  35.         },"A").start();
  37. 		//這裡保證執行緒A能夠執行完
  38.    	 	Thread.sleep(300);
  40.         //執行緒B sendSms
  41.         newThread(()->{
  42.             phone.sendSms();
  43.         },"B").start();
  45.     }
  46. }

結果：等待4秒中後出現sendEmail與sendSMS同時輸出

lock3

3.新增普通的hello方法，請問先列印郵件還是hello? 答案：hello

只有新增synchronized關鍵字的方法才會被synchronized鎖控制

  1. package day02_lam;
  3. import java.util.concurrent.TimeUnit;
  5. class Phone{
  6. 	public synchronized void sendEmail()throws InterruptedException{
  7. 		TimeUnit.SECONDS.sleep(4);
  8. 		System.out.println("------------sendEmail");
  9. 	}
  11. 	public synchronized void sendSms(){
  12. 		System.out.println("------------sendSMS");
  13. 	}
  15. 	public void hello(){//未加synchronized
  16. 		System.out.println("hello");
  17. 	}
  18. }
  20. /**
  21. *題目：
  22. *1.標準訪問，請問是先列印郵件還是簡訊Email
  23. *2.email方法新增暫停4秒鐘，請問是先列印郵件還是簡訊Email
  24. *3.新增普通的hello方法，請問先列印郵件還是hello    hello
  25. */
  26. public  class Lock8{
  27.     public static void main(String[] args)throws InterruptedException{
  28.         Phone phone=new Phone();
  30.         //執行緒A呼叫sendEmail
  31.         new Thread(()->{
  32.             try{
  33.                 phone.sendEmail();
  34.             }catch(InterruptedExceptione){
  35.                 e.printStackTrace();
  36.             }
  37.         },"A").start();
  39.    		Thread.sleep(300);
  41.        	//執行緒B呼叫普通方法hello
  42.         new Thread(()->{
  43.             //phone.sendSms();
  44.             phone.hello();
  45.         },"B").start();
  47.     }
  48. }

結果：hello先輸出，4s後sendEmail再輸出

lock4

4.兩部手機，請問先列印郵件還是簡訊 ？ 答案：SMS

不同例項物件，synchronized鎖住的是對應的呼叫物件

  1. package day02_lam;
  3. import java.util.concurrent.TimeUnit;
  5. class Phone{
  6. 	public synchronized void sendEmail()throws InterruptedException{
  7.         //睡眠4秒種
  8. 		TimeUnit.SECONDS.sleep(4);
  9. 		System.out.println("------------sendEmail");
  10. 	}
  12. 	public synchronized void sendSms(){
  13. 		System.out.println("------------sendSMS");
  14. 	}
  16. 	public void hello(){
  17. 		System.out.println("hello");
  18. 	}
  19. }
  21. /**
  22. *題目：
  23. *1.標準訪問，請問是先列印郵件還是簡訊Email
  24. *2.email方法新增暫停4秒鐘，請問是先列印郵件還是簡訊Email
  25. *3.新增普通的hello方法，請問先列印郵件還是hellohello
  26. *4.兩部手機，請問先列印郵件還是簡訊 SMS
  27. */
  28. public class Lock8{
  29. public static void main(String[] args)throws InterruptedException{
  30. 		Phone phone=new Phone();
  31. 		Phone phone2=new Phone();
  33. 		//sychronized鎖定是當前物件對應的this，phone與phone2分別鎖的是自己的this
  35.     	//執行緒A使用例項phone呼叫sendEmail
  36. 		newThread(()->{
  37. 			try{
  38.                 //sendEmail方法中包含睡眠4秒種
  39. 				phone.sendEmail();
  40. 			}catch(InterruptedExceptione){
  41. 				e.printStackTrace();
  42. 			}
  43. 		},"A").start();
  45. 		Thread.sleep(300);
  47.     	//執行緒B使用例項phone2呼叫sendSms
  48. 		newThread(()->{
  49. 			phone2.sendSms();
  50. 			//phone.hello();
  51. 		},"B").start();
  53. 	}
  54. }

結果：sendSMS先輸出，4s後sendEmail再輸出

lock5

5.兩個靜態同步方法，1部手機，請問先列印郵件還是簡訊? 答案：Email

synchronized鎖靜態方法，實際是鎖住的類元資訊，因為靜態方法是隨類元資訊的載入而儲存到jvm的靜態區，是所有例項建立的模板

  1. package day02_lam;
  3. import java.util.concurrent.TimeUnit;
  5. class Phone{
  6. 	public static synchronized void sendEmail()throws InterruptedException{
  7. 		TimeUnit.SECONDS.sleep(4);
  8. 		System.out.println("------------sendEmail");
  9. 	}
  11. 	public static synchronized void sendSms(){
  13. 		System.out.println("------------sendSMS");
  14. 	}
  16. 	public void hello(){
  17. 		System.out.println("hello");
  18. 	}
  19. }
  21. /**
  22. *題目：
  23. *1.標準訪問，請問是先列印郵件還是簡訊Email
  24. *2.email方法新增暫停4秒鐘，請問是先列印郵件還是簡訊Email
  25. *3.新增普通的hello方法，請問先列印郵件還是hellohello
  26. *4.兩部手機，請問先列印郵件還是簡訊SMS
  27. *5.兩個靜態同步方法，1部手機，請問先列印郵件還是簡訊 Email
  28. */
  29. public class Lock8{
  30. public  static void main(String[] args)throws InterruptedException{
  31. 	Phone phone=new Phone();
  33. 	new Thread(()->{
  34. 		try{
  35. 			phone.sendEmail();
  36. 		}catch(InterruptedException e){
  37. 			e.printStackTrace();
  38. 		}
  39. 	},"A").start();
  41. 	Thread.sleep(300);
  43. 	newThread(()->{
  44. 		phone.sendSms();
  45. 	},"B").start();
  47. 	}
  48. }

結果：4秒種後，sendEmail率先輸出，sendSMS緊隨其後

lock6

6.兩個靜態同步方法，2部手機，請問先列印郵件還是簡訊？ 答案：Email

與lock5的執行結果一致，當前synchronized鎖住的是類元資訊

  1. package day02_lam;
  3. import java.util.concurrent.TimeUnit;
  5. class Phone{
  6.     public static synchronized void sendEmail() throws InterruptedException{
  7.         TimeUnit.SECONDS.sleep(4);
  8.         System.out.println("------------sendEmail");
  9.     }
  11.     public static synchronized void sendSms(){
  12.     	System.out.println("------------sendSMS");
  13.     }
  15.     public void hello(){
  16.    	 	System.out.println("hello");
  17.     }
  18. }
  20. /**
  21. *題目：
  22. *1.標準訪問，請問是先列印郵件還是簡訊Email
  23. *2.email方法新增暫停4秒鐘，請問是先列印郵件還是簡訊Email
  24. *3.新增普通的hello方法，請問先列印郵件還是hellohello
  25. *4.兩部手機，請問先列印郵件還是簡訊SMS
  26. *5.兩個靜態同步方法，1部手機，請問先列印郵件還是簡訊Email
  27. *6.兩個靜態同步方法，2部手機，請問先列印郵件還是簡訊Email
  28. */
  29. public class Lock8{
  30.     publicstaticvoidmain(String[]args)throwsInterruptedException{
  31.         Phone phone=new Phone();
  32.         Phone phone2=new Phone();
  34.         new Thread(()->{
  35.             try{
  36.             	phone.sendEmail();
  37.             }catch(InterruptedException e){
  38.            	 e.printStackTrace();
  39.             }
  40.         },"A").start();
  41.         Thread.sleep(300);
  42.         new Thread(()->{
  43.             //phone.sendSms();
  44.             phone2.sendSms();
  45.             //phone.hello();
  46.         },"B").start();
  48.     }
  49. }

結果：與lock5的執行結果一致，sendEmail與sendSMS都是4s後進行輸出，synchronized也是鎖住的類元資訊

lock7

7.一個普通同步方法，一個靜態同步方法，1部手機，請問先列印Email還是SMS？ 答案：SMS

原理：普通同步方法，synchronized鎖住的是當前例項物件，當前例項物件存在於jvm的堆記憶體區

靜態同步方法，synchronized鎖住的是當前類的類元資訊，存在於jvm元空間的靜態區中

  1. package day02_lam;
  3. import java.util.concurrent.TimeUnit;
  5. class Phone{
  6.     //靜態同步方法
  7. 	public static synchronized void sendEmail()throws InterruptedException{
  8. 		TimeUnit.SECONDS.sleep(4);
  9. 		System.out.println("------------sendEmail");
  10. 	}
  12.     //普通同步方法
  13. 	public synchronized void sendSms(){//無static
  15. 		System.out.println("------------sendSMS");
  16. 	}
  18. 	public void hello(){
  19. 		System.out.println("hello");
  20. 	}
  21. }
  23. /**
  24. *題目：
  25. *1.標準訪問，請問是先列印郵件還是簡訊Email
  26. *2.email方法新增暫停4秒鐘，請問是先列印郵件還是簡訊Email
  27. *3.新增普通的hello方法，請問先列印郵件還是hellohello
  28. *4.兩部手機，請問先列印郵件還是簡訊SMS
  29. *5.兩個靜態同步方法，1部手機，請問先列印郵件還是簡訊Email
  30. *6.兩個靜態同步方法，2部手機，請問先列印郵件還是簡訊Email
  31. *7.一個普通同步方法，一個靜態同步方法，1部手機，請問先列印郵件還是簡訊 SMS
  32. */
  33. public class Lock8{
  34. 	public static void main(String[] args) throws InterruptedException{
  35. 		Phonephone=newPhone();
  36. 		Phonephone2=newPhone();
  38. 		newThread(()->{
  39. 			try{
  40. 				phone.sendEmail();
  41. 			}catch(InterruptedExceptione){
  42. 				e.printStackTrace();
  43. 			}
  44. 		},"A").start();
  46. 		Thread.sleep(300);
  48. 		newThread(()->{
  49. 			phone.sendSms();
  50. 			//phone2.sendSms();
  51. 			//phone.hello();
  52. 		},"B").start();
  54. 	}
  55. }

結果：sendSMS先輸出，4s後sendEmail再輸出

lock8

8.一個普通同步方法，一個靜態同步方法，2部手機，請問先列印郵件還是簡訊？ 答案：SMS

原理：與lock7一致

  1. package day02_lam;
  3. import java.util.concurrent.TimeUnit;
  5. class Phone{
  6. 	public static synchronized void sendEmail()throwsInterruptedException{
  7. 		TimeUnit.SECONDS.sleep(3);
  8. 		System.out.println("------------sendEmail");
  9. 	}
  11. 	public synchronized void sendSms(){
  13. 		System.out.println("------------sendSMS");
  14. 	}
  16. 	public void hello(){
  17. 		System.out.println("hello");
  18. 	}
  19. }
  21. /**
  22. *題目：
  23. *1.標準訪問，請問是先列印郵件還是簡訊Email
  24. *2.email方法新增暫停4秒鐘，請問是先列印郵件還是簡訊Email
  25. *3.新增普通的hello方法，請問先列印郵件還是hellohello
  26. *4.兩部手機，請問先列印郵件還是簡訊SMS
  27. *5.兩個靜態同步方法，1部手機，請問先列印郵件還是簡訊Email
  28. *6.兩個靜態同步方法，2部手機，請問先列印郵件還是簡訊Email
  29. *7.一個普通同步方法，一個靜態同步方法，1部手機，請問先列印郵件還是簡訊SMS
  30. *8.一個普通同步方法，一個靜態同步方法，2部手機，請問先列印郵件還是簡訊SMS
  31. */
  32. public class Lock8{
  33. 	publicstaticvoidmain(String[]args)throwsInterruptedException{
  34. 		Phone phone=new Phone();
  35. 		Phone phone2=new Phone();
  37. 		new Thread(()->{
  38. 			try{
  39. 				phone.sendEmail();
  40. 			}catch(InterruptedExceptione){
  41. 				e.printStackTrace();
  42. 			}
  43. 		},"A").start();
  45. 		Thread.sleep(300);
  47. 		new Thread(()->{
  48. 			//phone.sendSms();
  49. 			phone2.sendSms();
  50. 			//phone.hello();
  51. 		},"B").start();
  53. 	}
  54. }

結果：執行結果與lock7一致，sendSMS先輸出，4s後sendEmail再輸出