public class ShareData {
	public static int count=0;
	public static void main(String[] args){
		final ShareData data  = new ShareData();
		for(int i=0;i<10;i++){
			new Thread(
					new Runnable(){
						public void run(){
							try{
								Thread.sleep(1);
							}catch(InterruptedException e){
								e.printStackTrace();
							}
							for(int j=0;j<100;j++){
								data.addCount();
							}
							System.out.print(count+" ");
						}
					}
				).start();				
		}
		try{
			Thread.sleep(3000);
		}catch(InterruptedException e){
			e.printStackTrace();
		}
		System.out.print("count="+count);
	}
	public void addCount(){
		count++;
	}
}
 

程式啟動了十個執行緒，每個執行緒計100次數，操作的都是count這個變數，最後在等待3秒（所有執行緒均執行結束後）輸出此時的count值，每次執行後的輸出結果都不一定一樣，但是一般count小於1000，結果如下：

100 224 373 473 373 255 823 791 691 591 count=823

344 566 366 299 299 466 366 669 695 769 count=769

400 400 400 500 400 615 913 813 713 713 count=913

我們將addCount（）方法加上synchronized關鍵詞修飾下，讓它實現執行緒安全，

	public synchronized void addCount(){
		count++;
	}
 

再執行，結果如下：

200 200 411 677 774 864 1000 666 1000 891 count=1000

423 909 1000 428 802 512 691 706 512 914 count=1000

300 500 500 300 300 712 809 850 949 1000 count=1000

此時可以看出最終count的數值都會精確的是1000，講完了synchronized之後我們再來看下AtomicInteger類

AtomicInteger類可以用原子方式更新的 int 值，主要用於在高併發環境下的高效程式處理，使用非阻塞演算法來實現併發控制，它的方法有

//獲取當前的值
public final int get()
//取當前的值，並設定新的值
public final int getAndSet(int newValue)
//獲取當前的值，並自增
public final int getAndIncrement() 
//獲取當前的值，並自減
public final int getAndDecrement()
//獲取當前的值，並加上預期的值
public final int getAndAdd(int delta) 
 

package concurrent;

import java.util.concurrent.atomic.AtomicInteger;

public class ShareData_AtomicInteger {
	static AtomicInteger count = new AtomicInteger(0);
	public static void main(String[] args){
		final ShareData_AtomicInteger data  = new ShareData_AtomicInteger();
		for(int i=0;i<10;i++){
			new Thread(
					new Runnable(){
						public void run(){
							try{
								Thread.sleep(1);
							}catch(InterruptedException e){
								e.printStackTrace();
							}
							for(int j=0;j<100;j++){
								data.addCount();
							}
							System.out.print(count.get()+" ");
						}
					}
				).start();				
		}
		try{
			Thread.sleep(3000);
		}catch(InterruptedException e){
			e.printStackTrace();
		}
		System.out.print("count="+count.get());
	}
	public void addCount(){
		count.getAndIncrement();
	}
}

495 528 604 504 987 657 741 682 1000 925 count=1000

500 500 984 823 499 733 500 495 601 1000 count=1000

409 409 436 409 700 587 600 872 988 1000 count=1000

至此結束，AtomicInteger只是concurrent下的一個整數原子操作類，該包下還有很多其他關於執行緒鎖同步的機制，有興趣的同學可以自行搜尋下相關資料~謝謝