300 行代碼帶你秒懂 Java 多線程！

　　線程的概念，百度是這樣解說的：
　　線程（英語：Thread）是操做體系能夠進行運算調度的最小單位。它被包括在進程之中，是進程中的實際運做單位。一條線程指的是進程中一個單一次序的操控流，一個進程中能夠併發多個線程，每條線程並行履行不一樣的使命。在UnixSystemV及SunOS中也被稱爲輕量進程（LightweightProcesses），但輕量進程更多指內核線程（KernelThread），而把用戶線程（UserThread）稱爲線程。
　　1.1線程與進程的差別
　　進程：指在體系中正在運轉的一個運用程序；程序一旦運轉即是進程；進程——資源分配的最小單位。
　　線程：體系分配處理器時間資源的基本單元，或許說進程以內獨立履行的一個單元履行流。線程——程序履行的最小單位。
　　也即是，進程能夠包括多個線程，而線程是程序履行的最小單位。
　　1.2線程的情況
　　NEW：線程剛創立
　　RUNNABLE:在JVM中正在運轉的線程，其間運轉情況能夠有運轉中RUNNING和READY兩種情況，由體系調度進行情況改變。
　　BLOCKED：線程處於堵塞情況，等候監督鎖，能夠從新進行同步代碼塊中履行
　　WAITING:等候情況
　　TIMED_WAITING:調用sleepjoinwait辦法或許致使線程處於等候情況
　　TERMINATED:線程履行完畢，現已退出
　　1.3Notify和Wait：
　　Notify和Wait的效果
　　首要看源碼給出的解說，這裏翻譯了一下：
　　Notify：喚醒一個正在等候這個目標的線程監控。假若有任何線程正在等候這個目標，那麼它們中的一個被選擇被喚醒。選擇是任意的，發生在履行的酌情權。一個線程等候一個目標通過調用一個{@codewait}辦法進行監督。
　　Notify需求在同步辦法或同步塊中調用，即在調用前，線程也必須得到該目標的目標等級鎖
　　Wait：致使當時線程等候，直到另外一個線程調用{@linkjava.lang.Object#notify}辦法或{@linkjava.lang.Object#notifyAll}辦法。
　　換句話說，這個辦法的行爲就像它簡略相同履行調用{@codewait(0)}。當時線程必須擁有該目標的監督器。
　　線程開釋此監督器的一切權，並等候另外一個線程告訴等候該目標的監督器的線程，喚醒通過調用{@codenotify}辦法或{@codenotifyAll}辦法。而後線程等候，直到它能夠從新得到監督器的一切權，而後持續履行。
　　Wait的效果是使當時履行代碼的線程進行等候，它是Object類的辦法，該辦法用來將當時線程置入預履行行列中，而且在Wait地點的代碼行處停止履行，直到接到告訴或被停止爲止。
　　在調用Wait辦法以前，線程必須得到該目標的目標等級鎖，即只能在同步辦法或同步塊中調用Wait辦法。
　　Wait和Sleep的差別：
　　它們最大本質的差別是，Sleep不開釋同步鎖，Wait開釋同步鎖。
　　還有用法的上的不一樣是：Sleep(milliseconds)能夠用時間指定來使他主動醒過來，假如時間不到你只能調用Interreput來強行打斷；Wait能夠用Notify直接喚起。
　　這兩個辦法來自不一樣的類分別是Thread和Object
　　最首要是Sleep辦法沒有開釋鎖，而Wait辦法開釋了鎖，使得其餘線程能夠運用同步操控塊或許辦法。
　　1.4Thread.sleep和Thread.yield的異同
　　相同：Sleep和yield都會開釋CPU。
　　不一樣：Sleep使當時線程進入阻滯情況，因此履行Sleep的線程在指定的時間內一定不會履行；yield僅僅使當時線程從新回到可履行情況，因此履行yield的線程有或許在進入到可履行情況後馬上又被履行。Sleep可以使優先級低的線程獲得履行的時機，固然也可讓同優先級和高優先級的線程有履行的時機；yield只能使同優先級的線程有履行的時機。
　　1.5彌補：死鎖的概念
　　死鎖：指兩個或兩個以上的進程（或線程）在履行過程當中，因搶奪資源而造成的一種互相等候的現象，若無外力效果，它們都將沒法推進下去。此刻稱體系處於死鎖情況或體系發生了死鎖，這些永遠在互相等候的進程稱爲死鎖進程。
　　死鎖發生的四個必要條件（缺一不可）：
　　互斥條件：望文生義，線程對資源的拜訪是排他性，當該線程開釋資源後下一線程纔可進行佔用。
　　懇求和堅持：簡略來講即是本身拿的不放手又等候新的資源到手。線程T1至少現已堅持了一個資源R1佔用,但又提出對另外一個資源R2懇求，而此刻，資源R2被其餘線程T2佔用，因而該線程T1也必須等候，但又對本身堅持的資源R1不開釋。
　　不可掠奪：在沒有運用完資源時，其餘線性不能進行掠奪。
　　循環等候：一貫等候對方線程開釋資源。
　　我們能夠根據死鎖的四個必要條件損壞死鎖的造成。
　　1.6彌補：併發和並行的差別
　　併發：是指在某個時間段內，多使命替換的履行使命。當有多個線程在操做時，把CPU運轉時間劃分紅若干個時間段,再將時間段分配給各個線程履行。在一個時間段的線程代碼運轉時，其它線程處於掛起狀。
　　並行：是指同一時間一塊兒處理多使命的才能。當有多個線程在操做時，CPU一塊兒處理這些線程懇求的才能。
　　差別就在於CPU是否能一塊兒處理一切使命，併發不能，並行能。
　　1.7彌補：線程安全三要素
　　原子性：Atomic包、CAS算法、Synchronized、Lock。
　　可見性：Synchronized、Volatile（不能確保原子性）。
　　有序性：Happens-before規矩。
　　1.8彌補：怎麼完成線程安全
　　互斥同步：Synchronized、Lock。
　　非堵塞同步：CAS。
　　無需同步的方案：假如一個辦法本來就不涉及共享數據，那它自然就無需任何同步操做去確保正確性。
　　1.9彌補：確保線程安全的機制：
　　Synchronized關鍵字
　　Lock
　　CAS、原子變量
　　ThreadLocl：簡略來講即是讓每一個線程，對同一個變量，都有本身的獨有副本，每一個線程實際拜訪的目標都是本身的，自然也就不存在線程安全問題了。
　　Volatile
　　CopyOnWrite寫時複製
　　隨着CPU中心的增多以及互聯網迅速發展，單線程的程序處理速度愈來愈跟不上發展速度和大數據量的增加速度，多線程應運而生，充分利用CPU資源的一塊兒，極大進步了程序處理速度。
　　創立線程的辦法
　　承繼Thread類：
　　publicclassThreadCreateTest{
　　publicstaticvoidmain(String[]args){
　　newMyThread.start;
　　}
　　}
　　classMyThreadextendsThread{
　　@Override
　　publicvoidrun{
　　System.out.println(Thread.currentThread.getName+"t"+Thread.currentThread.getId);
　　}
　　}
　　完成Runable接口：
　　publicclassRunableCreateTest{
　　publicstaticvoidmain(String[]args){
　　MyRunnablerunnable=newMyRunnable;
　　newThread(runnable).start;
　　}
　　}
　　classMyRunnableimplementsRunnable{
　　@Override
　　publicvoidrun{
　　System.out.println(Thread.currentThread.getName+"t"+Thread.currentThread.getId);
　　}
　　}
　　通過Callable和Future創立線程：
　　publicclassCallableCreateTest{
　　publicstaticvoidmain(String[]args)throwsException{
　　//將Callable包裝成FutureTask，FutureTask也是一種Runnable
　　MyCallablecallable=newMyCallable;
　　FutureTaskfutureTask=newFutureTask<>(callable);
　　newThread(futureTask).start;
　　//get辦法會堵塞調用的線程
　　Integersum=futureTask.get;
　　System.out.println(Thread.currentThread.getName+Thread.currentThread.getId+"="+sum);
　　}
　　}
　　classMyCallableimplementsCallable{
　　@Override
　　publicIntegercallthrowsException{
　　System.out.println(Thread.currentThread.getName+"t"+Thread.currentThread.getId+"t"+newDate+"tstarting...");
　　intsum=0;
　　for(inti=0;i<=100000;i++){
　　sum+=i;
　　}
　　Thread.sleep(5000);
　　System.out.println(Thread.currentThread.getName+"t"+Thread.currentThread.getId+"t"+newDate+"tover...");
　　returnsum;
　　}
　　}
　　線程池辦法創立：
　　完成Runnable接口這種辦法更受歡迎，因爲這不需求承繼Thread類。在運用規劃中現已承繼了其餘目標的狀況下，這需求多承繼（而Java不支撐多承繼，但能夠多完成啊），只能完成接口。一塊兒，線程池也是十分高效的，很容易完成和運用。
　　實際開發中，阿里巴巴開發插件一貫提倡運用線程池創立線程，緣由在下方會解說，因此上面的代碼我就只簡寫了一些Demo。
　　2.1線程池創立線程
　　線程池，望文生義，線程寄存的當地。和數據庫鏈接池相同，存在的目的即是爲了較少體系開銷，首要由如下幾個特色：
　　降低資源耗費。通過重複利用已創立的線程降低線程創立和毀掉造成的耗費（首要）。
　　進步響應速度。當使命抵達時，使命能夠不需求比及線程創立就能當即履行。
　　進步線程的可管理性。線程是稀缺資源，假如無限制地創立，不僅會耗費體系資源，還會降低體系的穩定性。
　　Java供給四種線程池創立辦法：
　　newCachedThreadPool創立一個可緩存線程池，假如線程池長度超越處理需求，可靈敏收回空閒線程，若無可收回，則新建線程。
　　newFixedThreadPool創立一個定長線程池，可操控線程最大併發數，超出的線程會在行列中等候。
　　newScheduledThreadPool創立一個定長線程池，支撐定時及週期性使命履行。
　　newSingleThreadExecutor創立一個單線程化的線程池，它只會用僅有的做業線程來履行使命，確保一切使命按照指定次序（FIFO,LIFO,優先級）履行。
　　通過源碼我們得知ThreadPoolExecutor承繼自AbstractExecutorService，而AbstractExecutorService完成了ExecutorService。
　　publicclassThreadPoolExecutorextendsAbstractExecutorService
　　publicabstractclassAbstractExecutorServiceimplementsExecutorService
　　2.2ThreadPoolExecutor介紹
　　實際項目中，用的最多的即是ThreadPoolExecutor這個類，而《阿里巴巴Java開發手冊》中強制線程池不容許運用Executors去創立，而是通過NewThreadPoolExecutor實例的辦法，這樣的處理辦法讓寫的同窗更加明確線程池的運轉規矩，規避資源耗盡的危險。
　　我們從ThreadPoolExecutor下手多線程創立辦法，先看一下線程池創立的最全參數。
　　publicThreadPoolExecutor(intcorePoolSize,
　　intmaximumPoolSize,
　　longkeepAliveTime,
　　TimeUnitunit,
　　BlockingQueueworkQueue,
　　ThreadFactorythreadFactory,
　　RejectedExecutionHandlerhandler){
　　if(corePoolSize<0||
　　maximumPoolSize<=0||
　　maximumPoolSize
　　keepAliveTime<0)
　　thrownewIllegalArgumentException;
　　if(workQueue==null||threadFactory==null||handler==null)
　　thrownewNullPointerException;
　　this.corePoolSize=corePoolSize;
　　this.maximumPoolSize=maximumPoolSize;
　　this.workQueue=workQueue;
　　this.keepAliveTime=unit.toNanos(keepAliveTime);
　　this.threadFactory=threadFactory;
　　this.handler=handler;
　　}
　　參數闡明以下：
　　corePoolSize：線程池的中心線程數，即使線程池裏沒有任何使命，也會有corePoolSize個線程在候着等使命。
　　maximumPoolSize：最大線程數，不論提交多少使命，線程池裏最多做業線程數即是maximumPoolSize。
　　keepAliveTime：線程的存活時間。當線程池裏的線程數大於corePoolSize時，假如等了keepAliveTime時長尚未使命可履行，則線程退出。
　　Unit：這個用來指定keepAliveTime的單位，好比秒：TimeUnit.SECONDS。
　　BlockingQueue：一個堵塞行列，提交的使命將會被放到這個行列裏。
　　threadFactory：線程工廠，用來創立線程，首要是爲了給線程起名字，默許工廠的線程名字：pool-1-thread-3。
　　handler：回絕戰略，當線程池裏線程被耗盡，且行列也滿了的時分會調用。
　　2.2.1BlockingQueue
　　對於BlockingQueue我的感受還需求單獨拿出來講一下。
　　BlockingQueue：堵塞行列，有先進先出（重視公平性）和先進後出（重視時效性）兩種，常見的有兩種堵塞行列：ArrayBlockingQueue和LinkedBlockingQueue
　　行列的數據結構大體如圖：
　　行列一端進入，一端輸出。而當行列滿時，堵塞。BlockingQueue中心辦法：1.放入數據put2.獲取數據take。常見的兩種Queue：
　　2.2.2ArrayBlockingQueue
　　基於數組完成，在ArrayBlockingQueue內部，保護了一個定長數組，以便緩存行列中的數據目標，這是一個經常使用的堵塞行列，除了一個定長數組外，ArrayBlockingQueue內部還保存着兩個整形變量，分別標識着行列的頭部和尾部在數組中的位置。
　　一段代碼來驗證一下：
　　packagemap;
　　importjava.util.concurrent.*;
　　publicclassMyTestMap{
　　//界說堵塞行列鉅細
　　privatestaticfinalintmaxSize=5;
　　publicstaticvoidmain(String[]args){
　　ArrayBlockingQueuequeue=newArrayBlockingQueue(maxSize);
　　newThread(newProductor(queue)).start;
　　newThread(newCustomer(queue)).start;
　　}
　　}
　　classCustomerimplementsRunnable{
　　privateBlockingQueuequeue;
　　Customer(BlockingQueuequeue){
　　this.queue=queue;
　　}
　　@Override
　　publicvoidrun{
　　this.cusume;
　　}
　　privatevoidcusume{
　　while(true){
　　try{
　　intcount=(int)queue.take;
　　System.out.println("customer正在消費第"+count+"個產品===");
　　//僅僅爲了便利觀察輸出成果
　　Thread.sleep(10);
　　}catch(InterruptedExceptione){
　　e.printStackTrace;
　　}
　　}
　　}
　　}
　　classProductorimplementsRunnable{
　　privateBlockingQueuequeue;
　　privateintcount=1;
　　Productor(BlockingQueuequeue){
　　this.queue=queue;
　　}
　　@Override
　　publicvoidrun{
　　this.product;
　　}
　　privatevoidproduct{
　　while(true){
　　try{
　　queue.put(count);
　　System.out.println("出產者正在出產第"+count+"個產品");
　　count++;
　　}catch(InterruptedExceptione){
　　e.printStackTrace;
　　}
　　}
　　}
　　}
　　//輸出以下
　　/**
　　出產者正在出產第1個產品
　　出產者正在出產第2個產品
　　出產者正在出產第3個產品
　　出產者正在出產第4個產品
　　出產者正在出產第5個產品
　　customer正在消費第1個產品===
　　*/
　　2.2.3LinkedBlockingQueue
　　基於鏈表的堵塞行列，內部也保護了一個數據緩衝行列。需求我們留意的是假如結構一個LinkedBlockingQueue目標，而沒有指定其容量鉅細。
　　LinkedBlockingQueue會默許一個相似無限鉅細的容量（Integer.MAX_VALUE），這樣的話，假如出產者的速度一旦大於顧客的速度，也許尚未比及行列滿堵塞發生，體系內存就有或許已被耗費殆盡了。
　　2.2.4LinkedBlockingQueue和ArrayBlockingQueue的首要差別
　　ArrayBlockingQueue的初始化必須傳入行列鉅細，LinkedBlockingQueue則能夠不傳入。
　　ArrayBlockingQueue用一把鎖操控併發，LinkedBlockingQueue倆把鎖操控併發，鎖的細粒度更細。即前者出產者顧客進出都是一把鎖，後者出產者出產進入是一把鎖，顧客消費是另外一把鎖。
　　ArrayBlockingQueue選用數組的辦法存取，LinkedBlockingQueue用Node鏈表辦法存取。
　　2.2.5handler回絕戰略
　　Java供給了4種丟掉處理的辦法，固然你也能夠本身完成，首要是要完成接口：RejectedExecutionHandler中的辦法。
　　AbortPolicy：不處理，直接拋出反常。
　　CallerRunsPolicy：只用調用者地點線程來運轉使命，即提交使命的線程。
　　DiscardOldestPolicy：LRU戰略，丟掉行列裏最近最久不運用的一個使命，並履行當時使命。
　　DiscardPolicy：不處理，丟掉掉，不拋出反常。
　　2.2.6線程池五種情況
　　privatestaticfinalintRUNNING=-1<
　　privatestaticfinalintSHUTDOWN=0<
　　privatestaticfinalintSTOP=1<
　　privatestaticfinalintTIDYING=2<
　　privatestaticfinalintTERMINATED=3<
　　RUNNING：在這個情況的線程池能判別承受新提交的使命，而且也能處理堵塞行列中的使命。
　　SHUTDOWN：處於封閉的情況，該線程池不能承受新提交的使命，但是能夠處理堵塞行列中現已保存的使命，在線程處於RUNNING情況，調用shutdown辦法能切換爲該情況。
　　STOP：線程池處於該情況時既不能承受新的使命也不能處理堵塞行列中的使命，而且能停止如今線程中的使命。當線程處於RUNNING和SHUTDOWN情況，調用shutdownNow辦法就可使線程變爲該情況。
　　TIDYING：在SHUTDOWN情況下堵塞行列爲空，且線程中的做業線程數量爲0就會進入該情況，當在STOP情況下時，只要線程中的做業線程數量爲0就會進入該情況。
　　TERMINATED：在TIDYING情況下調用terminated辦法就會進入該情況。能夠覺得該情況是最終的中止情況。
　　回到線程池創立ThreadPoolExecutor，我們瞭解了這些參數，再來看看ThreadPoolExecutor的內部做業原理：
　　判別中心線程是否已滿，是進入行列，否：創立線程
　　判別等候行列是否已滿，是：查看線程池是否已滿，否：進入等候行列
　　查看線程池是否已滿，是：回絕，否創立線程
　　2.3深刻了解ThreadPoolExecutor
　　進入Execute辦法能夠看到：
　　publicvoidexecute(Runnablecommand){
　　if(command==null)
　　thrownewNullPointerException;
　　intc=ctl.get;
　　//判別當時活躍線程數是否小於corePoolSize,假如小於，則調用addWorker創立線程履行使命
　　if(workerCountOf(c)
　　if(addWorker(command,true))
　　return;
　　c=ctl.get;
　　}
　　//假如不小於corePoolSize，則將使命增長到workQueue行列。
　　if(isRunning(c)&&workQueue.offer(command)){
　　intrecheck=ctl.get;
　　if(!isRunning(recheck)&&remove(command))
　　reject(command);
　　elseif(workerCountOf(recheck)==0)
　　addWorker(null,false);
　　}
　　//假如放入workQueue失敗，則創立線程履行使命，假如這時創立線程失敗(當時線程數不小於maximumPoolSize時)，就會調用reject(內部調用handler)回絕承受使命。
　　elseif(!addWorker(command,false))
　　reject(command);
　　}
　　AddWorker辦法：
　　創立Worker目標，一塊兒也會實例化一個Thread目標。在創立Worker時會調用threadFactory來創立一個線程。
　　而後啓動這個線程。
　　2.3.1線程池中CTL特色的效果是什麼？
　　看源碼榜首反響即是這個CTL究竟是個什麼東東？有啥用？一番研究得出以下定論：
　　CTL特色包括兩個概念：
　　privatefinalAtomicIntegerctl=newAtomicInteger(ctlOf(RUNNING,0));
　　privatestaticintctlOf(intrs,intwc){returnrs|wc;}
　　runState：即rs標明當時線程池的情況，是否處於Running，Shutdown，Stop，Tidying。
　　workerCount：即wc標明當時有效的線程數。
　　我們點擊workerCount即做業情況記載值，以RUNNING爲例，RUNNING=-1<
　　privatestaticfinalintCOUNT_BITS=Integer.SIZE-3;
　　既然是29位那麼即是Running的值爲：
　　11100000000000000000000000000000
　　|||
　　31~29位
　　那低28位呢，即是記載當時線程的總線數啦：
　　//Packingandunpackingctl
　　privatestaticintrunStateOf(intc){returnc&~CAPACITY;}
　　privatestaticintworkerCountOf(intc){returnc&CAPACITY;}
　　privatestaticintctlOf(intrs,intwc){returnrs|wc;}
　　從上述代碼能夠看到workerCountOf這個函數傳入ctl以後，是通過CTL&CAPACITY操做來獲取當時運轉線程總數的。
　　也即是RunningState|WorkCount&CAPACITY，算出來的即是低28位的值。因爲CAPACITY獲得的即是高3位（29-31位）位0，低28位（0-28位）都是1，因此獲得的即是ctl中低28位的值。
　　而runStateOf這個辦法的話，算的即是RunningState|WorkCount&CAPACITY，高3位的值，因爲CAPACITY是CAPACITY的取反，因此獲得的即是高3位（29-31位）爲1，低28位（0-28位）爲0，因此通過&運算後，所獲得的值即是高3爲的值。
　　簡略來講即是ctl中是高3位做爲情況值，低28位做爲線程總數值來進行存儲。
　　2.3.2shutdownNow和shutdown的差別
　　看源碼發現有兩種近乎相同的辦法，shutdownNow和shutdown，規劃者這麼規劃自然是有它的道理，那麼這兩個辦法的差別在哪呢？
　　shutdown會把線程池的情況改成SHUTDOWN，而shutdownNow把當時線程池情況改成STOP。
　　shutdown只會停止一切空閒的線程，而shutdownNow會停止一切的線程。
　　shutdown返回辦法爲空，會將當時使命行列中的一切使命履行完畢；而shutdownNow把使命行列中的一切使命都取出來返回。
　　2.3.3線程複用原理
　　finalvoidrunWorker(Workerw){
　　Threadwt=Thread.currentThread;
　　Runnabletask=w.firstTask;
　　w.firstTask=null;
　　w.unlock;//allowinterrupts
　　booleancompletedAbruptly=true;
　　try{
　　while(task!=null||(task=getTask)!=null){
　　w.lock;
　　//Ifpoolisstopping,ensurethreadisinterrupted;
　　//ifnot,ensurethreadisnotinterrupted.This
　　//requiresarecheckinsecondcasetodealwith
　　//shutdownNowracewhileclearinginterrupt
　　if((runStateAtLeast(ctl.get,STOP)||
　　(Thread.interrupted&&
　　runStateAtLeast(ctl.get,STOP)))&&
　　!wt.isInterrupted)
　　wt.interrupt;
　　try{
　　beforeExecute(wt,task);
　　Throwablethrown=null;
　　try{
　　task.run;
　　}catch(RuntimeExceptionx){
　　thrown=x;throwx;
　　}catch(Errorx){
　　thrown=x;throwx;
　　}catch(Throwablex){
　　thrown=x;thrownewError(x);
　　}finally{
　　afterExecute(task,thrown);
　　}
　　}finally{
　　task=null;
　　w.completedTasks++;
　　w.unlock;
　　}
　　}
　　completedAbruptly=false;
　　}finally{
　　processWorkerExit(w,completedAbruptly);
　　}
　　}
　　即是使命在並不僅履行創立時指定的firstTask榜首使命，還會從使命行列的中本身主動取使命履行，而且是有或許無時間限制的堵塞等候，以確保線程的存活。
　　默許的是不容許。
　　2.4CountDownLatch和CyclicBarrier差別
　　countDownLatch是一個計數器，線程完成一個記載一個，計數器遞減，只能只用一次。
　　CyclicBarrier的計數器更像一個閥門，需求一切線程都抵達，而後持續履行，計數器遞加，供給Reset功用，能夠屢次運用。
　　3.多線程間通信的幾種辦法
　　說起多線程又不得不說起多線程通信的機制。首要，要短信線程間通信的模型有兩種：共享內存和消息傳遞，如下辦法都是基本這兩種模型來完成的。我們來基本一道面試常見的標題來分析：
　　標題：有兩個線程A、B，A線程向一個集合裏面順次增長元素"abc"字符串，一共增長十次，當增長到第五次的時分，但願B線程能夠收到A線程的告訴，而後B線程履行相關的業務操做。
　　3.1運用volatile關鍵字
　　packagethread;
　　/**
　　*
　　*@authorhxz
　　*@deion多線程測驗類
　　*@version1.0
　　*@data2020年2月15日上午9:10:09
　　*/
　　publicclassMyThreadTest{
　　publicstaticvoidmain(String[]args)throwsException{
　　notifyThreadWithVolatile;
　　}
　　/**
　　*界說一個測驗
　　*/
　　privatestaticvolatilebooleanflag=false;
　　/**
　　*計算I++，當I==5時，告訴線程B
　　*@throwsException
　　*/
　　privatestaticvoidnotifyThreadWithVolatilethrowsException{
　　Threadthc=newThread("線程A"){
　　@Override
　　publicvoidrun{
　　for(inti=0;i<10;i++){
　　if(i==5){
　　flag=true;
　　try{
　　Thread.sleep(500L);
　　}catch(InterruptedExceptione){
　　//TODOAuto-generatedcatchblock
　　e.printStackTrace;
　　}
　　break;
　　}
　　System.out.println(Thread.currentThread.getName+"===="+i);
　　}
　　}
　　};
　　Threadthd=newThread("線程B"){
　　@Override
　　publicvoidrun{
　　while(true){
　　//防止僞喚醒因此運用了while
　　while(flag){
　　System.out.println(Thread.currentThread.getName+"收到告訴");
　　System.out.println("dosomething");
　　try{
　　Thread.sleep(500L);
　　}catch(InterruptedExceptione){
　　//TODOAuto-generatedcatchblock
　　e.printStackTrace;
　　}
　　return;
　　}
　　}
　　}
　　};
　　thd.start;
　　Thread.sleep(1000L);
　　thc.start;
　　}
　　}
　　我的覺得這是基本上最好的通信辦法，因爲A發出告訴B能夠立馬承受並DoSomething。