Java併發編程（三）synchronized實現簡單同步

一、synchronized應用的簡單示例

下面兩段代碼示例，分別用同步塊，同步方法完成兩個線程共同操作的計數器，計數到10。

import java.util.concurrent.atomic.AtomicBoolean;

public class TwoThreadCounter {
	public static Integer counter = 0;
	public static AtomicBoolean goon = new AtomicBoolean(false);
	
	public static void main(String[] args) {
		Thread counter1 = new Thread(new Runnable() {			
			@Override
			public void run() {
				while(goon.get()){
					synchronized (TwoThreadCounter.class) {
						counter++;
						System.out.println(Thread.currentThread().getName() + "\t" + counter);
						if(counter == 10) {
							goon.set(false);
						}else{
							try {
								TwoThreadCounter.class.wait();
							} catch (InterruptedException e) {
								e.printStackTrace();
							}	
						}
					}
				}
			}
		}, "counter1");
		Thread counter2 = new Thread(new Runnable() {			
			@Override
			public void run() {
				while(goon.get()) {
					synchronized (TwoThreadCounter.class) {
						counter++;
						System.out.println(Thread.currentThread().getName() + "\t" + counter);
						if(counter == 10) {
							goon.set(false);
						}else{
							try {
								TwoThreadCounter.class.wait();
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
						}
					}	
				}
				
			}
		}, "counter2");
		
		goon.set(true);
		boolean hasStart = false;
		
		while(goon.get()){

			if(!hasStart) {
				counter1.start();
				counter2.start();
				hasStart = true;
			}
			synchronized (TwoThreadCounter.class) {
				TwoThreadCounter.class.notify();
			}
		}
	}
}

看下輸出結果：

counter1	1
counter2	2
counter1	3
counter2	4
counter1	5
counter2	6
counter1	7
counter2	8
counter1	9
counter2	10

sysnchronized也可以用於修飾方法，普通方法和靜態方法都可以，我們現在用普通同步方法改寫上面的代碼，因爲靜態方法術語類對象，而普通方法屬於類的實例，所以如果想用sysnchronized修飾普通方法來實現功能，要在有一個實例，代碼如下：

import java.util.concurrent.atomic.AtomicBoolean;

public class TwoThreadCounterSynNormalMethod {
	public static Integer counter = 0;
	public static AtomicBoolean goon = new AtomicBoolean(false);
	
	public TwoThreadCounterSynNormalMethod() {}
	
	public synchronized void counterIncreace(){
		counter ++;
		System.out.println(Thread.currentThread().getName() + "\t" + counter);
		try {
			this.wait();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
		TwoThreadCounterSynNormalMethod ttcsnm = new TwoThreadCounterSynNormalMethod();
		Thread counter1 = new Thread(new Runnable() {
			@Override
			public void run() {
				while(goon.get()){
					ttcsnm.counterIncreace();
					if(counter == 10) {
						goon.set(false);
					}
				}
			}
		}, "counter1");
		Thread counter2 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				while(goon.get()) {
					ttcsnm.counterIncreace();
					if(counter == 10) {
						goon.set(false);
					}
				}
			}
		}, "counter2");
		
		goon.set(true);
		boolean hasStart = false;
		
		while(goon.get()){
			if(!hasStart) {
				counter1.start();
				counter2.start();
				hasStart = true;
			}
			synchronized (ttcsnm) {// 這裏很重要，因爲對普通方法使用synchronized關鍵字修飾，其實是把調用該方法的實例作爲了鎖對象
				ttcsnm.notifyAll(); //所以當需要喚醒時，是調用的ttcsnm.notiffyAll();
			}
		}
	}
}

輸出結果是一樣的。

二、關於多線程不安全及鎖機制的簡單理解

synchronized關鍵字，用來實現線程同步，暫時拋棄它內部複雜的實現，對代碼運行做一個類比：

代碼的某幾行、或一個方法都是實現一個具體業務邏輯的功能模塊，他們都是需要線程來執行的，他們之間的關係是這樣的：

線程通過逐個執行功能模塊來實現程序整體功能，現在對應一個更具體的場景：發工資。在這個場景中每一個線程對應一個工人，發工資對應的功能模塊流程是：工人進入辦公室，在辦公室有一份公司的財務單，財務單上寫的是當前公司剩餘的資金數量，工人進入之後，拿走自己應得的工資，然後更新財務單，更新爲原有資金數量減去自己所拿走的數量後剩餘的資金數量，但是線程對應的這個工人有個不能改掉的習慣，他看到工資單後，先自己複印一份工資單，然後在複印的單子上改，改完後用自己的副本替換當前的那一份（它不記得之前是多少），流程如下：

現在是一個工人，不會存在什麼問題，現在假設有兩個工人，問題就來了，假設他們兩個一起進了這個房間（功能模塊），並且工人B在工人A替換賬單之前看到了賬單

A拿了40後，賬單應改爲60，但在A替換前，B看到了未被替換的賬單，此時B拿着寫有100的複印件，取走了自己的20，然後更改手裏的賬單爲80，現在A手裏有一張將要替換的賬單，數量是60，B手裏也有一張將要替換的賬單，數量是80，此時無論哪個工人把自己手裏的賬單替換原有賬單，數量都是不正確的。

爲了解決這個問題，就需要上帝（程序猿）來協助了，上帝說：我指定XXX作爲守衛在入口處守着，守衛有這麼幾個特點：

1、他手裏握着一個入場券，每次僅允許一個工人進去，進去時把入場券給這個工人，其他人在門口排隊等着

2.上一個工人領完工資了，守衛會把入場券拿過來，允許在入口處等着的人獲得入場券

3.守衛的權利極大，他可以剝奪已經進去的工人繼續完成領工資這件事的權利，把他的入場券拿過來，讓它也處於等待的狀態，當守衛手裏有入場券的時候，他就可以在任何時間通知其他等待的人。

有了守衛後，領工資這件事就變得有秩序的，從一個工人的角度來看，是這樣的：

工人X到達領工資的地點，先看看守衛手裏的入場券還有沒有，有的話，他就取過來，進去領工資，沒有的話，他就知道入場券已經被其他工人持有，此時如果在他之前已經有很多人在等，他就排在隊尾等候，假如現在裏面的人工資拿完了，守衛就把入場券再取回來，當守衛手裏有券時，守衛可以做兩件事：

1.他可以拿着入場券向排隊的所有人說，可以下一個人進了，這時，所有排隊的人都聽到了，大家都想進，那就要打架了！互相競爭，此時有一部分人是比較有優勢的，比如職位高的人，有特權，那麼他得到入場券的概率就大。

2.另外一種情況就是守衛只和隊伍最前面的人說，這時候後面人是不知道的，只有第一個人接受到了消息，如果他現在的確可以領工資的話，就可以順利進去了。

假如現在工人X正在拿工資，守衛突然進到屋子裏面來，搶走了工人X手裏的券，那麼工人X只能待着一動不動，房子也不能出，但他此時他可以和隊列裏其他人一樣，可以接收守衛喚醒的信息，現在券又到了守衛手裏，守衛現在又可以繼續做那兩件事。

又輪到工人X了，從上次沒做完的那裏開始，他領完工資後，在出口位置，把券歸還給守衛。

上面的場景，可以在代碼中找到相對應的地方：1.工人是線程 2.守衛可以是任何對象obj，程序猿用synchronized關鍵字指定誰就是誰 3.告訴隊列第一個人可以進了，就是obj.notify() 4.告訴所有人就是obj.notifyAll() 5.守衛想讓正在取工資的人放下手中的券回隊列等候，那麼務必務必和已經拿到券的人在同一間房子裏面，使用obj.wait()讓當前工人等候。

三、synchronized關鍵字的使用

上面通過類比已經說明了synchronized實現同步時涉及到的方法以及含義，涉及到的幾個方法分別爲：obj.wait()、obj.notify()、obj.notifyAll()，這幾個方法必須在同步塊中調用，synchronized關鍵字只要作用就是指定誰是鎖，在Java中每個對象都可以作爲鎖。

主要有三種形式：

對於普通同步方法，鎖是當前的實例對象。在上面的第二個代碼示例中，用synchronized修飾普通方法，調用這個方法的實例是ttcsnm，那麼要進入這個方法，就要取得實例對象ttcsnm對應的鎖，所以我在喚醒時，需要調用ttcsnm

對於靜態同步方法，鎖是當前類的Class對象。可以類比普通同步方法，普通同步方法屬於實例，所以要進入同步方法，需要獲得實例對應的鎖，而靜態方法屬於類，調用時也通過類名來調用，所以用synchronized關鍵字修飾靜態方法，那麼要訪問該方法，需要拿到類對象對應的鎖。

對於同步塊，synchronized後面括號裏的對象就是鎖，如上面第一個代碼示例所示，用的是類對象TwoThreadCounter.class作爲鎖，要訪問同步塊中的內容就必須拿到這個鎖。

接下來分析實現計數器功能的代碼。

3.1使用同步代碼塊

第一個示例中，使用的是同步塊，同步塊的書寫遵循以下格式：

synchronized (obj) {
	// 執行內容
}

obj即指定的鎖，任何對象均可以，執行內容即用戶要完成的業務邏輯，再回到代碼示例

synchronized (TwoThreadCounter.class) { //此處指定TwoThreadCouter的類對象爲鎖
	counter++; //這裏是真正要完成的功能，即每次讓計數器的值增加1
	System.out.println(Thread.currentThread().getName() + "\t" + counter);
	if(counter == 10) { // 判斷如果當前技術器增加到10，那就停止，讓線程停止的方式，此處選擇使用atomicBooelan類來作爲一個標誌，如果其值爲false,線程看到後就不再繼續進行
		goon.set(false);
		}else{
		try {
			TwoThreadCounter.class.wait(); // 這裏很關鍵，當一個線程對計數器進行加1操作後，如果沒有累加到10，就需要另外一個線程繼續加
		} catch (InterruptedException e) {     // 所以需要讓當前線程放棄鎖，根據上面分析的，想剝奪鎖，必須在同步塊內部，調用obj.wait()方法
			e.printStackTrace();           // 這個方法會讓當前線程在此方法等待（不是阻塞），直到線程死亡或被喚醒才能從該方法返回
		}
	}
}	// 當線程成功執行完同步代碼塊，出這個"｝"時，會主動調用notifyall()方法。

兩個線程的同步塊內容是一樣的，當前線程拿到鎖，對計數器執行加一操作，然後判斷是否結束，如果沒結束，就需要放棄鎖，原地等待，讓另外一個線程有機會獲得鎖，並執行相同的功能。另外一個線程執行相同的操作後，也在wait()方法處等待，所以此時需要另外在外面喚醒

		while(goon.get()){

			if(!hasStart) {
				counter1.start();
				counter2.start();
				hasStart = true;
			}
			synchronized (TwoThreadCounter.class) {
				TwoThreadCounter.class.notify();
			}
		}

這段代碼由主線程來執行，完成對兩個線程的控制，當執行計數器加一操作的兩個線程均運行到TwoThreadCounter.class.wait() 方法時，兩個線程放棄鎖，同時進入等待狀態，所以在主線中，main線程可以順利獲得鎖，進入同步塊

			synchronized (TwoThreadCounter.class) {
				TwoThreadCounter.class.notify();
			}// 當主線程執行完同步塊時，纔會釋放鎖，調用notify方法並不釋放鎖

在同步塊中，調用TwoThreadCounter.class.notify()，此時會喚醒等待隊列中的第一個線程，允許該線程擁有獲得鎖的機會，但此時鎖依然在主線程手裏，只有當主線程退出同步塊時，纔會把鎖釋放掉，被喚醒的線程才能獲得鎖。

這樣，處於排隊的線程可重新獲得鎖，從wait()方法返回，繼續執行，再判斷是否結束了，如果沒有結束，重新嘗試獲得鎖。

3.1使用同步方法

對於同步方法，注意鎖對象是調用該方法的實例即可，所以在喚醒時，要用實例來調用notifyAll（）方法。

		while(goon.get()){
			if(!hasStart) {
				counter1.start();
				counter2.start();
				hasStart = true;
			}
			synchronized (ttcsnm) {// 這裏很重要，因爲對普通方法使用synchronized關鍵字修飾，其實是把調用該方法的實例作爲了鎖對象
				ttcsnm.notifyAll(); //所以當需要喚醒時，是調用的ttcsnm.notiffyAll();
			}
		}

Java併發編程（三）synchronized實現簡單同步

一、synchronized應用的簡單示例

二、關於多線程不安全及鎖機制的簡單理解

三、synchronized關鍵字的使用

3.1使用同步代碼塊

3.1使用同步方法

Nginx R31 doc 官方文檔-01-nginx 如何安裝

Qt/C++音視頻開發74-合併標籤圖形/生成yolo運算結果圖形/文字和圖形合併成一個/水印濾鏡

挑戰程序設計競賽 2.2章習題 POJ - 3617 Best Cow Line 貪心

字節面試：MySQL什麼時候鎖表？如何防止鎖表？

.NET8連接SQL SERVER 2008 R2 報：證書鏈是由不受信任的頒發機構頒發的

golang開發環境搭建(win10)

python計算機視覺學習筆記——PIL庫的用法

Java併發編程（三）synchronized實現簡單同步

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結