什么是synchronized

這篇文章主要講解了“什么是synchronized”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“什么是synchronized”吧！

synchronized使用

1. 上面也說了，synchronized可以寫在方法上，也可以寫在代碼塊上，只是有可能鎖的類型不同，如果寫在方法上，鎖的就是當前類的對象，在代碼塊上使用，可以指定鎖的對象。如果作用在靜態代碼塊上，鎖的就是指定的類的class對象了

2. synchronized鎖屬于全自動類型的，自動上鎖解鎖，而且在執行代碼的過程中，如果拋異常了，synchronized也會自動釋放鎖

3. synchronized鎖是可重入鎖，就是當前線程調用A的方法，A方法中調用B方法，可以直接調用，不用競爭鎖。jvm這樣設計，也是為了防止死鎖的產生，所以，在這里你應該也能明白了，為什么當前線程訪問A方法時，其他線程訪問其他方法時，不能讓其訪問的原因了。或者這樣說，T1線程訪問A方法時，T2線程也來訪問A方法，肯定不被允許的，這不不用多說，因為鎖的是一個對象，那個對象被T1線程鎖著呢，T2線程當然獲取不了鎖。那相同的，T2線程去訪問B方法時，B方法中鎖的不也是同一個對象嗎，也就是說T2線程還要去獲取T1線程在A方法中鎖定的對象的鎖。

4. threadlocal線程私有變量，舉個例子你就知道了：

public class ThreadLocalTest {
	class Person {
		String name = "zhangsan";
	}
	@Test
	public void threadLocal1() {
		ThreadLocal<Person> tl = new ThreadLocal<Person>();
		Person person = new Person();
		tl.set(person);
		new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("新啟線程"+tl.get());
			}
		}).start();
		System.out.println(tl.get());
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

新啟的線程打印person為null，也就是說，通過threadlocal設置的對象，只能在當前線程中使用，其他線程獲取為空。

5. volatile關鍵字，請點擊跳轉

6. 重點說下notify和wait，因為這里面的坑，稍不注意就掉進去了，之前寫過一篇，我再舉個生產者、消費者的例子： 需求：有2個生產者線程、10個消費者線程，如果容器滿了，則生產者暫停，如果容器空了，則消費者暫停

public class ProducerAndConsumer {
	//有2個生產者線程、10個消費者線程，如果容器滿了，則生產者暫停，如果容器空了，則消費者暫停
	final private LinkedList list = new LinkedList();
	final private int maxValue = 10;
	/**
	 * 生產者，按照要求：當容器滿了，就停止。
	 */
	public synchronized void producer(Object o) {
		/**
		 * 最初的實現是用if，但是為什么又改成if而改成while呢：（這是一個坑，很容易掉里面）
		 * 	1.你想啊，如果此時，容器滿了，然后第一個線程到這后，判斷if邏輯，然后執行wait方法進行等待，并【釋放當前對象鎖】
		 *  2.然后cpu調起哪個線程，是隨機選擇的，如果此時，又調起了一個生產者線程，那么也執行到了這個wait方法。
		 *  3.目前已經有兩個線程在wait這了，然后cpu執行消費者線程消費了1個，現在容器中還有9個，
		  *        然后消費者線程喚醒通過notifyall喚醒線程，喚醒了這兩個生產者線程，那么：
		 *  	3.1 首先第一個生產者線程開始執行，從wait處開始往下執行，添加元素，容器又滿了，釋放鎖
		 *  	3.2 然后第二個生產者線程開始執行，也是從wait處開始執行，因為使用的不是while循環，所以
		 *  		會直接往下執行，也就是添加元素，那么容器大小就不是10 個了。
		 *  4.所以，使用wait時的場景，99%都是與while循環配合使用
		 *  5.如果wait和notify不寫在synchronized鎖里面，會拋IllegalMonitorStateException異常，但是
		 *  	為什么必須在synchronized鎖中呢，那么肯定會出現wait調用發生在調用notify之后的情況。[參考博客](https://www.cnblogs.com/set-cookie/p/8686218.html)
		 */
//		if(list.size()==maxValue) {
		while(list.size()==maxValue) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		list.add(o);
		//容器中有東西了，喚醒等待的線程線程進行消費（喚醒的線程中包括生產者線程和消費者線程），其主要目的是消費者線程
		this.notifyAll();
	}
	/**
	 * 消費者
	 */
	public  synchronized Object consumer() {
		while(list.size()==0) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		//我拿走東西了，喚醒等待的線程進行生產（喚醒的線程中包括生產者線程和消費者線程），其主要目的是生產者線程
		Object o = list.removeFirst();
		this.notifyAll();
		return o;
	}
	public static void main(String[] args) {
		ProducerAndConsumer pcTest = new ProducerAndConsumer();
		//啟動消費者線程
		for(int i=0;i<10;i++) {
			new Thread(()->{
				for(int j=0;j<10;j++) {
					System.out.println(pcTest.consumer()+"aa");
				}
			},"c"+i) .start();
		}
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		//啟動生產者線程
		for(int i=0;i<2;i++) {
			new Thread(()->{
				for(int j=0;j<30;j++) {
					pcTest.producer(Thread.currentThread().getName());
				}
			},"p"+i) .start();
		}
	}

7. 線程停止stop、interrupt方法， thread.stop()，是直接把你干掉了，沒有一點余地的直接kill掉，都不會進入catch中，所以不到萬不得已，不要用stop方法。 thread.interrupt()時，線程還是可以進下面catch中的代碼的。 但是這兩個方法都不被推薦，更理想的辦法是定義變量，：

public class ThreadStopByArgs {
	/**
	 * 通過變量的形式，是線程進行停止
	 *
	 */
	public static void main(String[] args) {
		ThreadRunnerTest threadRunnerTest = new ThreadRunnerTest();
		Thread thread = new Thread(threadRunnerTest);
		thread.start();
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("stop");
		threadRunnerTest.changeFlag();
	}
}
class ThreadRunnerTest implements Runnable {
	private volatile boolean flag = true;
	public void run() {
		int i=0;
		while(flag) {
			//System.out.println(i++);測試多線程時，如果使用syso輸出，要小心使用,因為syso中有sync
		}
	}
	public void changeFlag(){
		flag = false;
	}
}

8. 其他的方法，比如sleep、yield、join、stop、interrupt等方法，請您自行學習吧，沒啥好記得 鎖必須鎖的是同一個對象的基礎上的，如同：你衛生間還能有多個門嗎？也就是說，訪問共享的資源時，只有一個門能讓你去訪問，這樣才能控制共享資源和線程的安全性。安全的意義并不只針對車禍那種類型的，只要預期結果被改變是因為在執行過程中被其他因素干擾導致的，就屬于不安全。

感謝各位的閱讀，以上就是“什么是synchronized”的內容了，經過本文的學習后，相信大家對什么是synchronized這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！