• 在多執行緒程式中，會出現多個執行緒搶佔一個資源的情況，這時間有可能會造成衝突，也就是一個執行緒可能還沒來得及將更改的 資源儲存，另一個執行緒的更改就開始了。可能造成資料不一致。因此引入多執行緒同步，也就是說多個執行緒只能一個對共享的資源進行更改，其他執行緒不能對資料進行修改。
• 1.如下一個兩個執行緒對一個銀行賬戶進行存錢的小例項，其中使用synchornized修飾方法實現執行緒的同步
• 程式碼如下：

class bank{
	private int count=100;
	public synchronized void dispit() {
		  count+=10;
	}
	public int getcount() {
		return count;
	}
}
class ThreadCount extends Thread{
	private bank count;
	private JTextArea textarea = new JTextArea();
	public ThreadCount(bank count,JTextArea textarea) {
		this.count = count;
		this.textarea = textarea;
	}
	public void run() {
		for(int i=0; i<10; i++) {
			count.dispit();
			textarea.append("賬戶餘額為："+count.getcount()+"\n");
		}
	}
}
 

2.同步是一種高開銷的操作，因此應該儘量減少同步內容，因此也可以使用修飾程式碼塊來代替修飾整個方法。

class bank{
	private int count=100;
	public void dispit() {
		synchronized(this) {
		  count+=10;
		}
	}
	public int getcount() {
		return count;
	}
}
class ThreadCount extends Thread{
	private bank count;
	private JTextArea textarea = new JTextArea();
	public ThreadCount(bank count,JTextArea textarea) {
		this.count = count;
		this.textarea = textarea;
	}
	public void run() {
		for(int i=0; i<10; i++) {
			count.dispit();
			textarea.append("賬戶餘額為："+count.getcount()+"\n");
		}
	}
}
 

3.使用volatile修飾資料，對於當下問題，只用使用volatile來修飾賬戶的餘額變數即可。該修飾詞是對域變數的訪問提供了以這種防鎖機制，相當於告訴虛擬機器，該域的變數可能被更改。因此每次使用該域都要重新計算，而不是從暫存器中取出資料。從而實現執行緒的同步。該修飾詞不能修改final型別變數

class bank{
	private volatile int count=100;
	public void dispit() {
		  count+=10;
	}
	public int getcount() {
		return count;
	}
}
class ThreadCount extends Thread{
	private bank count;
	private JTextArea textarea = new JTextArea();
	public ThreadCount(bank count,JTextArea textarea) {
		this.count = count;
		this.textarea = textarea;
	}
	public void run() {
		for(int i=0; i<10; i++) {
			count.dispit();
			textarea.append("賬戶餘額為："+count.getcount()+"\n");
		}
	}
}
 

4.使用重入鎖實現執行緒同步。使用類ReentrantLock類來定義鎖，其中lock()方法為開啟鎖，unlock()方法為關閉鎖
類似於synchronized修飾方法有一樣功能。使用鎖時間需要注意應該及時放開鎖，不然會進入死鎖狀態。一般是在finally中釋放鎖

class bank{
	private volatile int count=100;
	private Lock lock = new ReentrantLock();
	public void dispit() {
		 lock.lock();
		 try {
		  count+=10;
		 }finally{
			 lock.unlock();
		 }
	}
	public int getcount() {
		return count;
	}
}
class ThreadCount extends Thread{
	private bank count;
	private JTextArea textarea = new JTextArea();
	public ThreadCount(bank count,JTextArea textarea) {
		this.count = count;
		this.textarea = textarea;
	}
	public void run() {
		for(int i=0; i<10; i++) {
			count.dispit();
			textarea.append("賬戶餘額為："+count.getcount()+"\n");
		}
	}
}

程式碼的輸出結果如下：

可以看到，每次增加10 的時間只有一個執行緒在進行，也就是執行緒的同步

5.使用ThreadLocal類來管理。不過該方法和同步機制不相同。該類管理的變數在每個執行緒中都有自己的副本，副本之間相互獨立，因此獲得的結果和其他不同。

class bank{
	private static ThreadLocal<Integer> count = new ThreadLocal() {
	   protected Integer initialValue() {
		   return 100;
	   }
	};
	private Lock lock = new ReentrantLock();
	public void dispit() {
		 lock.lock();
		 try {
		  count.set(count.get()+10);
		 }finally{
			 lock.unlock();
		 }
	}
	public int getcount() {
		return count.get();
	}
}

class ThreadCount extends Thread{
	private bank count;
	private JTextArea textarea = new JTextArea();
	public ThreadCount(bank count,JTextArea textarea) {
		this.count = count;
		this.textarea = textarea;
	}
	public void run() {
		for(int i=0; i<10; i++) {
			count.dispit();
			textarea.append("賬戶餘額為："+count.getcount()+"\n");
		}
	}
}

結果如圖：

可以看到，在改程式中，好比兩個賬戶相互獨立，互不干擾一樣。同樣解決了相同的變數訪問衝突問題。