java並發編程之線程同步（java多線程同步器）

本文目錄一覽：

• 1、並發編程解惑之線程
• 2、Java線程同步，是什麼意思？
• 3、JAVA中線程同步方法有哪些
• 4、Java 如何同步順序執行多個線程
• 5、java多線程開發的同步機制有哪些
• 6、Java多線程同步的幾種方式

並發編程解惑之線程

主要內容：

進程是資源分配的最小單位，每個進程都有獨立的代碼和數據空間，一個進程包含 1 到 n 個線程。線程是 CPU 調度的最小單位，每個線程有獨立的運行棧和程序計數器，線程切換開銷小。

Java 程序總是從主類的 main 方法開始執行，main 方法就是 Java 程序默認的主線程，而在 main 方法中再創建的線程就是其他線程。在 Java 中，每次程序啟動至少啟動 2 個線程。一個是 main 線程，一個是垃圾收集線程。每次使用 Java 命令啟動一個 Java 程序，就相當於啟動一個 JVM 實例，而每個 JVM 實例就是在操作系統中啟動的一個進程。

多線程可以通過繼承或實現介面的方式創建。

Thread 類是 JDK 中定義的用於控制線程對象的類，該類中封裝了線程執行體 run() 方法。需要強調的一點是，線程執行先後與創建順序無關。

通過 Runnable 方式創建線程相比通過繼承 Thread 類創建線程的優勢是避免了單繼承的局限性。若一個 boy 類繼承了 person 類，boy 類就無法通過繼承 Thread 類的方式來實現多線程。

使用 Runnable 介面創建線程的過程：先是創建對象實例 MyRunnable，然後將對象 My Runnable 作為 Thread 構造方法的入參，來構造出線程。對於 new Thread(Runnable target) 創建的使用同一入參目標對象的線程，可以共享該入參目標對象 MyRunnable 的成員變數和方法，但 run() 方法中的局部變數相互獨立，互不干擾。

上面代碼是 new 了三個不同的 My Runnable 對象，如果只想使用同一個對象，可以只 new 一個 MyRunnable 對象給三個 new Thread 使用。

實現 Runnable 介面比繼承 Thread 類所具有的優勢：

線程有新建、可運行、阻塞、等待、定時等待、死亡 6 種狀態。一個具有生命的線程，總是處於這 6 種狀態之一。 每個線程可以獨立於其他線程運行，也可和其他線程協同運行。線程被創建後，調用 start() 方法啟動線程，該線程便從新建態進入就緒狀態。

NEW 狀態（新建狀態） 實例化一個線程之後，並且這個線程沒有開始執行，這個時候的狀態就是 NEW 狀態：

RUNNABLE 狀態（就緒狀態）：

阻塞狀態有 3 種：

如果一個線程調用了一個對象的 wait 方法， 那麼這個線程就會處於等待狀態（waiting 狀態）直到另外一個線程調用這個對象的 notify 或者 notifyAll 方法後才會解除這個狀態。

run() 里的代碼執行完畢後，線程進入終結狀態（TERMINATED 狀態）。

線程狀態有 6 種：新建、可運行、阻塞、等待、定時等待、死亡。

我們看下 join 方法的使用：

運行結果：

我們來看下 yield 方法的使用：

運行結果：

線程與線程之間是無法直接通信的，A 線程無法直接通知 B 線程，Java 中線程之間交換信息是通過共享的內存來實現的，控制共享資源的讀寫的訪問，使得多個線程輪流執行對共享數據的操作，線程之間通信是通過對共享資源上鎖或釋放鎖來實現的。線程排隊輪流執行共享資源，這稱為線程的同步。

Java 提供了很多同步操作（也就是線程間的通信方式），同步可使用 synchronized 關鍵字、Object 類的 wait/notifyAll 方法、ReentrantLock 鎖、無鎖同步 CAS 等方式來實現。

ReentrantLock 是 JDK 內置的一個鎖對象，用於線程同步（線程通信），需要用戶手動釋放鎖。

運行結果：

這表明同一時間段只能有 1 個線程執行 work 方法，因為 work 方法里的代碼需要獲取到鎖才能執行，這就實現了多個線程間的通信，線程 0 獲取鎖，先執行，線程 1 等待，線程 0 釋放鎖，線程 1 繼續執行。

synchronized 是一種語法級別的同步方式，稱為內置鎖。該鎖會在代碼執行完畢後由 JVM 釋放。

輸出結果跟 ReentrantLock 一樣。

Java 中的 Object 類默認是所有類的父類，該類擁有 wait、 notify、notifyAll 方法，其他對象會自動繼承 Object 類，可調用 Object 類的這些方法實現線程間的通信。

除了可以通過鎖的方式來實現通信，還可通過無鎖的方式來實現，無鎖同 CAS（Compare-and-Swap，比較和交換）的實現，需要有 3 個操作數：內存地址 V，舊的預期值 A，即將要更新的目標值 B，當且僅當內存地址 V 的值與預期值 A 相等時，將內存地址 V 的值修改為目標值 B，否則就什麼都不做。

我們通過計算器的案例來演示無鎖同步 CAS 的實現方式，非線程安全的計數方式如下：

線程安全的計數方式如下：

運行結果：

線程安全累加的結果才是正確的，非線程安全會出現少計算值的情況。JDK 1.5 開始，並發包里提供了原子操作的類，AtomicBoolean 用原子方式更新的 boolean 值，AtomicInteger 用原子方式更新 int 值，AtomicLong 用原子方式更新 long 值。 AtomicInteger 和 AtomicLong 還提供了用原子方式將當前值自增 1 或自減 1 的方法，在多線程程序中，諸如 ++i 或 i++ 等運算不具有原子性，是不安全的線程操作之一。 通常我們使用 synchronized 將該操作變成一個原子操作，但 JVM 為此種操作提供了原子操作的同步類 Atomic，使用 AtomicInteger 做自增運算的性能是 ReentantLock 的好幾倍。

上面我們都是使用底層的方式實現線程間的通信的，但在實際的開發中，我們應該盡量遠離底層結構，使用封裝好的 API，例如 J.U.C 包（java.util.concurrent，又稱並發包）下的工具類 CountDownLath、CyclicBarrier、Semaphore，來實現線程通信，協調線程執行。

CountDownLatch 能夠實現線程之間的等待，CountDownLatch 用於某一個線程等待若干個其他線程執行完任務之後，它才開始執行。

CountDownLatch 類只提供了一個構造器：

CountDownLatch 類中常用的 3 個方法：

運行結果：

CyclicBarrier 字面意思循環柵欄，通過它可以讓一組線程等待至某個狀態之後再全部同時執行。當所有等待線程都被釋放以後，CyclicBarrier 可以被重複使用，所以有循環之意。

相比 CountDownLatch，CyclicBarrier 可以被循環使用，而且如果遇到線程中斷等情況時，可以利用 reset() 方法，重置計數器，CyclicBarrier 會比 CountDownLatch 更加靈活。

CyclicBarrier 提供 2 個構造器：

上面的方法中，參數 parties 指讓多少個線程或者任務等待至 barrier 狀態；參數 barrierAction 為當這些線程都達到 barrier 狀態時會執行的內容。

CyclicBarrier 中最重要的方法 await 方法，它有 2 個重載版本。下面方法用來掛起當前線程，直至所有線程都到達 barrier 狀態再同時執行後續任務。

而下面的方法則是讓這些線程等待至一定的時間，如果還有線程沒有到達 barrier 狀態就直接讓到達 barrier 的線程執行任務。

運行結果：

CyclicBarrier 用於一組線程互相等待至某個狀態，然後這一組線程再同時執行，CountDownLatch 是不能重用的，而 CyclicBarrier 可以重用。

Semaphore 類是一個計數信號量，它可以設定一個閾值，多個線程競爭獲取許可信號，執行完任務後歸還，超過閾值後，線程申請許可信號時將會被阻塞。Semaphore 可以用來 構建對象池，資源池，比如資料庫連接池。

假如在伺服器上運行著若干個客戶端請求的線程。這些線程需要連接到同一資料庫，但任一時刻只能獲得一定數目的資料庫連接。要怎樣才能夠有效地將這些固定數目的資料庫連接分配給大量的線程呢？

給方法加同步鎖，保證同一時刻只能有一個線程去調用此方法，其他所有線程排隊等待，但若有 10 個資料庫連接，也只有一個能被使用，效率太低。另外一種方法，使用信號量，讓信號量許可與資料庫可用連接數為相同數量，10 個資料庫連接都能被使用，大大提高性能。

上面三個工具類是 J.U.C 包的核心類，J.U.C 包的全景圖就比較複雜了：

J.U.C 包（java.util.concurrent）中的高層類（Lock、同步器、阻塞隊列、Executor、並發容器）依賴基礎類（AQS、非阻塞數據結構、原子變數類），而基礎類是通過 CAS 和 volatile 來實現的。我們盡量使用頂層的類，避免使用基礎類 CAS 和 volatile 來協調線程的執行。J.U.C 包其他的內容，在其他的篇章會有相應的講解。

Future 是一種非同步執行的設計模式，類似 ajax 非同步請求，不需要同步等待返回結果，可繼續執行代碼。使 Runnable（無返回值不支持上報異常）或 Callable（有返回值支持上報異常）均可開啟線程執行任務。但是如果需要非同步獲取線程的返回結果，就需要通過 Future 來實現了。

Future 是位於 java.util.concurrent 包下的一個介面，Future 介面封裝了取消任務，獲取任務結果的方法。

在 Java 中，一般是通過繼承 Thread 類或者實現 Runnable 介面來創建多線程， Runnable 介面不能返回結果，JDK 1.5 之後，Java 提供了 Callable 介面來封裝子任務，Callable 介面可以獲取返回結果。我們使用線程池提交 Callable 介面任務，將返回 Future 介面添加進 ArrayList 數組，最後遍歷 FutureList，實現非同步獲取返回值。

運行結果：

上面就是非同步線程執行的調用過程，實際開發中用得更多的是使用現成的非同步框架來實現非同步編程，如 RxJava，有興趣的可以繼續去了解，通常非同步框架都是結合遠程 HTTP 調用 Retrofit 框架來使用的，兩者結合起來用，可以避免調用遠程介面時，花費過多的時間在等待介面返回上。

線程封閉是通過本地線程 ThreadLocal 來實現的，ThreadLocal 是線程局部變數（local vari able），它為每個線程都提供一個變數值的副本，每個線程對該變數副本的修改相互不影響。

在 JVM 虛擬機中，堆內存用於存儲共享的數據（實例對象），也就是主內存。Thread Local .set()、ThreadLocal.get() 方法直接在本地內存（工作內存）中寫和讀共享變數的副本，而不需要同步數據，不用像 synchronized 那樣保證數據可見性，修改主內存數據後還要同步更新到工作內存。

Myabatis、hibernate 是通過 threadlocal 來存儲 session 的，每一個線程都維護著一個 session，對線程獨享的資源操作很方便，也避免了線程阻塞。

ThreadLocal 類位於 Thread 線程類內部，我們分析下它的源碼：

ThreadLocal 和 Synchonized 都用於解決多線程並發訪問的問題，訪問多線程共享的資源時，Synchronized 同步機制採用了以時間換空間的方式，提供一份變數讓多個線程排隊訪問，而 ThreadLocal 採用了以空間換時間的方式，提供每個線程一個變數，實現數據隔離。

ThreadLocal 可用於資料庫連接 Connection 對象的隔離，使得每個請求線程都可以復用連接而又相互不影響。

在 Java 裡面，存在強引用、弱引用、軟引用、虛引用。我們主要來了解下強引用和弱引用：

上面 a、b 對實例 A、B 都是強引用

而上面這種情況就不一樣了，即使 b 被置為 null，但是 c 仍然持有對 C 對象實例的引用，而間接的保持著對 b 的強引用，所以 GC 不會回收分配給 b 的空間，導致 b 無法回收也沒有被使用，造成了內存泄漏。這時可以通過 c = null; 來使得 c 被回收，但也可以通過弱引用來達到同樣目的：

從源碼中可以看出 Entry 里的 key 對 ThreadLocal 實例是弱引用：

Entry 里的 key 對 ThreadLocal 實例是弱引用，將 key 值置為 null，堆中的 ThreadLocal 實例是可以被垃圾收集器（GC）回收的。但是 value 卻存在一條從 Current Thread 過來的強引用鏈，只有噹噹前線程 Current Thread 銷毀時，value 才能被回收。在 threadLocal 被設為 null 以及線程結束之前，Entry 的鍵值對都不會被回收，出現內存泄漏。為了避免泄漏，在 ThreadLocalMap 中的 set/get Entry 方法里，會對 key 為 null 的情況進行判斷，如果為 null 的話，就會對 value 置為 null。也可以通過 ThreadLocal 的 remove 方法（類似加鎖和解鎖，最後 remove 一下，解鎖對象的引用）直接清除，釋放內存空間。

總結來說，利用 ThreadLocal 來訪問共享數據時，JVM 通過設置 ThreadLocalMap 的 Key 為弱引用，來避免內存泄露，同時通過調用 remove、get、set 方法的時候，回收弱引用（Key 為 null 的 Entry）。當使用 static ThreadLocal 的時候（如上面的 Spring 多數據源），static 變數在類未載入的時候，它就已經載入，當線程結束的時候，static 變數不一定會被回收，比起普通成員變數使用的時候才載入，static 的生命周期變長了，若沒有及時回收，容易產生內存泄漏。

使用線程池，可以重用存在的線程，減少對象創建、消亡的開銷，可控制最大並發線程數，避免資源競爭過度，還能實現線程定時執行、單線程執行、固定線程數執行等功能。

Java 把線程的調用封裝成了一個 Executor 介面，Executor 介面中定義了一個 execute 方法，用來提交線程的執行。Executor 介面的子介面是 ExecutorService，負責管理線程的執行。通過 Executors 類的靜態方法可以初始化

ExecutorService 線程池。Executors 類的靜態方法可創建不同類型的線程池：

但是，不建議使用 Executors 去創建線程池，而是通過 ThreadPoolExecutor 的方式，明確給出線程池的參數去創建，規避資源耗盡的風險。

如果使用 Executors 去創建線程池：

最佳的實踐是通過 ThreadPoolExecutor 手動地去創建線程池，選取合適的隊列存儲任務，並指定線程池線程大小。通過線程池實現類 ThreadPoolExecutor 可構造出線程池的，構造函數有下面幾個重要的參數：

參數 1：corePoolSize

線程池核心線程數。

參數 2：workQueue

阻塞隊列，用於保存執行任務的線程，有 4 種阻塞隊列可選：

參數 3：maximunPoolSize

線程池最大線程數。如果阻塞隊列滿了（有界的阻塞隊列），來了一個新的任務，若線程池當前線程數小於最大線程數，則創建新的線程執行任務，否則交給飽和策略處理。如果是無界隊列就不存在這種情況，任務都在無界隊列里存儲著。

參數 4：RejectedExecutionHandler

拒絕策略，當隊列滿了，而且線程達到了最大線程數後，對新任務採取的處理策略。

有 4 種策略可選：

最後，還可以自定義處理策略。

參數 5：ThreadFactory

創建線程的工廠。

參數 6：keeyAliveTime

線程沒有任務執行時最多保持多久時間終止。當線程池中的線程數大於 corePoolSize 時，線程池中所有線程中的某一個線程的空閑時間若達到 keepAliveTime，則會終止，直到線程池中的線程數不超過 corePoolSize。但如果調用了 allowCoreThread TimeOut(boolean value) 方法，線程池中的線程數就算不超過 corePoolSize，keepAlive Time 參數也會起作用，直到線程池中的線程數量變為 0。

參數 7：TimeUnit

配合第 6 個參數使用，表示存活時間的時間單位最佳的實踐是通過 ThreadPoolExecutor 手動地去創建線程池，選取合適的隊列存儲任務，並指定線程池線程大小。

運行結果：

線程池創建線程時，會將線程封裝成工作線程 Worker，Worker 在執行完任務後，還會不斷的去獲取隊列里的任務來執行。Worker 的加鎖解鎖機制是繼承 AQS 實現的。

我們來看下 Worker 線程的運行過程：

總結來說，如果當前運行的線程數小於 corePoolSize 線程數，則獲取全局鎖，然後創建新的線程來執行任務如果運行的線程數大於等於 corePoolSize 線程數，則將任務加入阻塞隊列 BlockingQueue 如果阻塞隊列已滿，無法將任務加入 BlockingQueue，則獲取全局所，再創建新的線程來執行任務

如果新創建線程後使得線程數超過了 maximumPoolSize 線程數，則調用 Rejected ExecutionHandler.rejectedExecution() 方法根據對應的拒絕策略處理任務。

CPU 密集型任務，線程執行任務佔用 CPU 時間會比較長，應該配置相對少的線程數，避免過度爭搶資源，可配置 N 個 CPU+1 個線程的線程池；但 IO 密集型任務則由於需要等待 IO 操作，線程經常處於等待狀態，應該配置相對多的線程如 2*N 個 CPU 個線程，A 線程阻塞後，B 線程能馬上執行，線程多競爭激烈，能飽和的執行任務。線程提交 SQL 後等待資料庫返回結果時間較長的情況，CPU 空閑會較多，線程數應設置大些，讓更多線程爭取 CPU 的調度。

Java線程同步，是什麼意思？

一種是方法前加sychronized

public void sychronized start() {

System.out.println(“start”);

}

另一種是在代碼段之前加sychronized

(sychronized){

。。。。。

}

同步方法（synchronized關鍵字修飾的方法）可以較好地解決並發問題，在一定程度上可以避免出現資源搶佔、競爭條件和死鎖的情況，但其副作用是同步鎖可導致線程阻塞。這要求同步方法的執行時間不能太長。

這就是所謂的鎖機制，你何以使用sychronized(Object obj)鎖住某個對象，等你使用完這個對象之後，再進行鎖的釋放，其他需要該對象的線程才可以執行。

JAVA中線程同步方法有哪些

JAVA中線程同步方法一般有以下三種：

1 wait方法：

該方法屬於Object的方法，wait方法的作用是使得當前調用wait方法所在部分（代碼塊）的線程停止執行，並釋放當前獲得的調用wait所在的代碼塊的鎖，並在其他線程調用notify或者notifyAll方法時恢復到競爭鎖狀態（一旦獲得鎖就恢復執行）。

調用wait方法需要注意幾點：

第一點：wait被調用的時候必須在擁有鎖（即synchronized修飾的）的代碼塊中。

第二點：恢復執行後，從wait的下一條語句開始執行，因而wait方法總是應當在while循環中調用，以免出現恢復執行後繼續執行的條件不滿足卻繼續執行的情況。

第三點：若wait方法參數中帶時間，則除了notify和notifyAll被調用能激活處於wait狀態（等待狀態）的線程進入鎖競爭外，在其他線程中interrupt它或者參數時間到了之後，該線程也將被激活到競爭狀態。

第四點：wait方法被調用的線程必須獲得之前執行到wait時釋放掉的鎖重新獲得才能夠恢復執行。

2 notify方法和notifyAll方法：

notify方法通知調用了wait方法，但是尚未激活的一個線程進入線程調度隊列（即進入鎖競爭），注意不是立即執行。並且具體是哪一個線程不能保證。另外一點就是被喚醒的這個線程一定是在等待wait所釋放的鎖。

notifyAll方法則喚醒所有調用了wait方法，尚未激活的進程進入競爭隊列。

3 synchronized關鍵字：

第一點：synchronized用來標識一個普通方法時，表示一個線程要執行該方法，必須取得該方法所在的對象的鎖。

第二點：synchronized用來標識一個靜態方法時，表示一個線程要執行該方法，必須獲得該方法所在的類的類鎖。

第三點：synchronized修飾一個代碼塊。類似這樣：synchronized(obj) { //code…. }。表示一個線程要執行該代碼塊，必須獲得obj的鎖。這樣做的目的是減小鎖的粒度，保證當不同塊所需的鎖不衝突時不用對整個對象加鎖。利用零長度的byte數組對象做obj非常經濟。

Java 如何同步順序執行多個線程

這個要分段來實現， 第一步是讓線程同步，第二部是讓線程有順序。

同步：我們可以用synchronized來解決。

Java線程同步原理： java會為每個object對象分配一個monitor，當某個對象的同步方法（synchronized methods ）被多個線程調用時，該對象的monitor將負責處理這些訪問的並發獨佔要求。

當一個線程調用一個對象的同步方法時，JVM會檢查該對象的monitor。如果monitor沒有被佔用，那麼這個線程就得到了monitor的占有權，可以繼續執行該對象的同步方法；如果monitor被其他線程所佔用，那麼該線程將被掛起，直到monitor被釋放。

當線程退出同步方法調用時，該線程會釋放monitor，這將允許其他等待的線程獲得monitor以使對同步方法的調用執行下去。就像下面這樣:

public void test() {

synchronized (this) {

//做一些事

//這裡只會有一個線程來調用該方法，因為只有一個this對象作為資源分配給該線程

}

}

順序：我們可以用List來解決，因為它是有序的。我們只需要將要執行的線程放入到List中

上代碼：

/**

* 讓多個線程同步順序執行的線程管理器

* @author bianrx

* @date 2012.1.18

* SynchronizedRunMultiThread

*/

public class SyncManager {

/**

* 待執行的線程集合，注意這裡必須是Runnable介面類型，下面會解釋

*/

private ListRunnable runnableList;

public SyncManager(){}

public SyncManager(ListRunnable runnableList) {

this.runnableList = runnableList;

}

public void setRunnable(ListRunnable runnableList) {

this.runnableList = runnableList;

}

public void run() {

//遍歷代執行的線程集合

for(Runnable runnable: runnableList) {

runThread(runnable);

}

}

/**

* 按順序同步執行多個線程

* @author bianrx

* @date 2012.1.18

* @param runnable

*/

private void runThread(Runnable runnable) {

synchronized (this) {

runnable.run();//這裡需要注意的是：必須調用run方法，因為如果你調用了start方法，線程只會向JVM請求資源，但是未必就執行其中的run。

//這個方法是同步的，所以當前只有一個線程佔用了this對象。

}

}

}

java多線程開發的同步機制有哪些

Java同步

標籤： 分類：

一、關鍵字：

thread（線程）、thread-safe(線程安全)、intercurrent（並發的）

synchronized(同步的)、asynchronized(非同步的)、

volatile（易變的）、atomic（原子的）、share（共享）

二、總結背景：

一次讀寫共享文件編寫，嚯，好傢夥，竟然揪出這些零碎而又是一路的知識點。於是乎，Google和翻閱了《Java參考大全》、《Effective Java Second Edition》，特此總結一下供日後工作學習參考。

三、概念：

1、 什麼時候必須同步？什麼叫同步？如何同步？

要跨線程維護正確的可見性，只要在幾個線程之間共享非 final 變數，就必須使用 synchronized（或 volatile）以確保一個線程可以看見另一個線程做的更改。

為了在線程之間進行可靠的通信，也為了互斥訪問，同步是必須的。這歸因於java語言規範的內存模型，它規定了：一個線程所做的變化何時以及如何變成對其它線程可見。

因為多線程將非同步行為引進程序，所以在需要同步時，必須有一種方法強制進行。例如：如果2個線程想要通信並且要共享一個複雜的數據結構，如鏈表，此時需要

確保它們互不衝突，也就是必須阻止B線程在A線程讀數據的過程中向鏈表裡面寫數據（A獲得了鎖，B必須等A釋放了該鎖）。

為了達到這個目的，java在一個舊的的進程同步模型——監控器（Monitor）的基礎上實現了一個巧妙的方案：監控器是一個控制機制，可以認為是一個

很小的、只能容納一個線程的盒子，一旦一個線程進入監控器，其它的線程必須等待，直到那個線程退出監控為止。通過這種方式，一個監控器可以保證共享資源在

同一時刻只可被一個線程使用。這種方式稱之為同步。（一旦一個線程進入一個實例的任何同步方法，別的線程將不能進入該同一實例的其它同步方法，但是該實例

的非同步方法仍然能夠被調用）。

錯誤的理解：同步嘛，就是幾個線程可以同時進行訪問。

同步和多線程關係：沒多線程環境就不需要同步;有多線程環境也不一定需要同步。

鎖提供了兩種主要特性：互斥（mutual exclusion） 和可見性（visibility）。

互斥即一次只允許一個線程持有某個特定的鎖，因此可使用該特性實現對共享數據的協調訪問協議，這樣，一次就只有一個線程能夠使用該共享數據。

可見性要更加複雜一些，documents它必須確保釋放鎖之前對共享數據做出的更改對於隨後獲得該鎖的另一個線程是可見的 —— 如果沒有同步機制提供的這種可見性保證，線程看到的共享變數可能是修改前的值或不一致的值，這將引發許多嚴重問題

小結：為了防止多個線程並發對同一數據的修改，所以需要同步，否則會造成數據不一致（就是所謂的：線程安全。如java集合框架中Hashtable和

Vector是線程安全的。我們的大部分程序都不是線程安全的，因為沒有進行同步，而且我們沒有必要，因為大部分情況根本沒有多線程環境）。

2、 什麼叫原子的（原子操作）？

Java原子操作是指：不會被打斷地的操作。（就是做到互斥 和可見性？！）

那難道原子操作就可以真的達到線程安全同步效果了嗎？實際上有一些原子操作不一定是線程安全的。

那麼，原子操作在什麼情況下不是線程安全的呢？也許是這個原因導致的：java線程允許線程在自己的內存區保存變數的副本。允許線程使用本地的私有拷貝進

行工作而非每次都使用主存的值是為了提高性能（本人愚見：雖然原子操作是線程安全的，可各線程在得到變數（讀操作）後，就是各自玩

弄自己的副本了，更新操作（寫操作）因未寫入主存中，導致其它線程不可見）。

那該如何解決呢？因此需要通過java同步機制。

在java中，32位或者更少位數的賦值是原子的。在一個32位的硬體平台上，除了double和long型的其它原始類型通常都

是使用32位進行表示，而double和long通常使用64位表示。另外，對象引用使用本機指針實現，通常也是32位的。對這些32位的類型的操作是原

子的。

這些原始類型通常使用32位或者64位表示，這又引入了另一個小小的神話：原始類型的大小是由語言保證的。這是不對的。java語言保證的是原始類型的表

數範圍而非JVM中的存儲大小。因此，int型總是有相同的表數範圍。在一個JVM上可能使用32位實現，而在另一個JVM上可能是64位的。在此再次強

調：在所有平台上被保證的是表數範圍，32位以及更小的值的操作是原子的。

3、 不要搞混了：同步、非同步

舉個例子：普通B/S模式（同步）AJAX技術（非同步）

同步：提交請求-等待伺服器處理-處理完返回 這個期間客戶端瀏覽器不能幹任何事

非同步：請求通過事件觸發-伺服器處理（這是瀏覽器仍然可以作其他事情）-處理完畢

可見，彼「同步」非此「同步」——我們說的java中的那個共享數據同步（synchronized）

一個同步的對象是指行為（動作），一個是同步的對象是指物質（共享數據）。

4、 Java同步機制有4種實現方式：（部分引用網上資源）

① ThreadLocal ② synchronized( ) ③ wait() 與 notify() ④ volatile

目的：都是為了解決多線程中的對同一變數的訪問衝突

ThreadLocal

ThreadLocal 保證不同線程擁有不同實例，相同線程一定擁有相同的實例，即為每一個使用該變數的線程提供一個該變數值的副本，每一個線程都可以獨立改變自己的副本，而不是與其它線程的副本衝突。

優勢：提供了線程安全的共享對象

與其它同步機制的區別：同步機制是為了同步多個線程對相同資源的並發訪問，是為了多個線程之間進行通信；而 ThreadLocal 是隔離多個線程的數據共享，從根本上就不在多個線程之間共享資源，這樣當然不需要多個線程進行同步了。

volatile

volatile 修飾的成員變數在每次被線程訪問時，都強迫從共享內存中重讀該成員變數的值。而且，當成員變數發生變化時，強迫線程將變化值回寫到共享內存。

優勢：這樣在任何時刻，兩個不同的線程總是看到某個成員變數的同一個值。

緣由：Java

語言規範中指出，為了獲得最佳速度，允許線程保存共享成員變數的私有拷貝，而且只當線程進入或者離開同步代碼塊時才與共享成員變數的原

始值對比。這樣當多個線程同時與某個對象交互時，就必須要注意到要讓線程及時的得到共享成員變數的變化。而 volatile

關鍵字就是提示 VM ：對於這個成員變數不能保存它的私有拷貝，而應直接與共享成員變數交互。

使用技巧：在兩個或者更多的線程訪問的成員變數上使用 volatile 。當要訪問的變數已在 synchronized 代碼塊中，或者為常量時，不必使用。

線程為了提高效率，將某成員變數(如A)拷貝了一份（如B），線程中對A的訪問其實訪問的是B。只在某些動作時才進行A和B的同步，因此存在A和B不一致

的情況。volatile就是用來避免這種情況的。

volatile告訴jvm，它所修飾的變數不保留拷貝，直接訪問主內存中的（讀操作多時使用較好；線程間需要通信，本條做不到）

Volatile 變數具有 synchronized 的可見性特性，但是不具備原子特性。這就是說線程能夠自動發現 volatile

變數的最新值。Volatile

變數可用於提供線程安全，但是只能應用於非常有限的一組用例：多個變數之間或者某個變數的當前值與修改後值

之間沒有約束。

您只能在有限的一些情形下使用 volatile 變數替代鎖。要使 volatile 變數提供理想的線程安全，必須同時滿足下面兩個條件：

對變數的寫操作不依賴於當前值；該變數沒有包含在具有其他變數的不變式中。

sleep() vs wait()

sleep是線程類（Thread）的方法，導致此線程暫停執行指定時間，把執行機會給其他線程，但是監控狀態依然保持，到時後會自動恢復。調用sleep不會釋放對象鎖。

wait是Object類的方法，對此對象調用wait方法導致本線程放棄對象鎖，進入等待此對象的等待鎖定池，只有針對此對象發出notify方法（或notifyAll）後本線程才進入對象鎖定池準備獲得對象鎖進入運行狀態。

（如果變數被聲明為volatile，在每次訪問時都會和主存一致；如果變數在同步方法或者同步塊中被訪問，當在方法或者塊的入口處獲得鎖以及方法或者塊退出時釋放鎖時變數被同步。）

Java多線程同步的幾種方式

java中多線程的實現方法有兩種：1.直接繼承thread類；2.實現runnable介面；同步的實現方法有五種：1.同步方法；2.同步代碼塊；3.使用特殊域變數(volatile)實現線程同步；4.使用重入鎖實現線程同步；5.使用局部變數實現線程同步 。

其中多線程實現過程中需注意重寫或者覆蓋run()方法，而對於同步的實現方法中使用較常使用的是利用synchronized編寫同步方法和代碼塊。

謝謝採納！！