java線程管理_Java中如何保證線程安全性

㈠ java線程池中的核心線程是如何被重復利用的

Java線程池中的核心線程是如何被重復利用的？

引言

在Java開發中，經常需要創建線程去執行一些任務，實現起來也非常方便，但如果並發的線程數量很多，並且每個線程都是執行一個時間很短的任務就結束了，這樣頻繁創建線程就會大大降低系統的效率，因為頻繁創建線程和銷毀線程需要時間。此時，我們很自然會想到使用線程池來解決這個問題。

使用線程池的好處：

降低資源消耗。java中所有的池化技術都有一個好處，就是通過復用池中的對象，降低系統資源消耗。設想一下如果我們有n多個子任務需要執行，如果我們為每個子任務都創建一個執行線程，而創建線程的過程是需要一定的系統消耗的，最後肯定會拖慢整個系統的處理速度。而通過線程池我們可以做到復用線程，任務有多個，但執行任務的線程可以通過線程池來復用，這樣減少了創建線程的開銷，系統資源利用率得到了提升。
降低管理線程的難度。多線程環境下對線程的管理是最容易出現問題的，而線程池通過框架為我們降低了管理線程的難度。我們不用再去擔心何時該銷毀線程，如何最大限度的避免多線程的資源競爭。這些事情線程池都幫我們代勞了。
提升任務處理速度。線程池中長期駐留了一定數量的活線程，當任務需要執行時，我們不必先去創建線程，線程池會自己選擇利用現有的活線程來處理任務。

很顯然，線程池一個很顯著的特徵就是「長期駐留了一定數量的活線程」，避免了頻繁創建線程和銷毀線程的開銷，那麼它是如何做到的呢？我們知道一個線程只要執行完了run()方法內的代碼，這個線程的使命就完成了，等待它的就是銷毀。既然這是個「活線程」，自然是不能很快就銷毀的。為了搞清楚這個「活線程」是如何工作的，下面通過追蹤源碼來看看能不能解開這個疑問。

分析方法

在分析源碼之前先來思考一下要怎麼去分析，源碼往往是比較復雜的，如果知識儲備不夠豐厚，很有可能會讀不下去，或者讀岔了。一般來講要時刻緊跟著自己的目標來看代碼，跟目標關系不大的代碼可以不理會它，一些異常的處理也可以暫不理會，先看正常的流程。就我們現在要分析的源碼而言，目標就是看看線程是如何被復用的。那麼對於線程池的狀態的管理以及非正常狀態下的處理代碼就可以不理會，具體來講，在ThreadPollExcutor類中，有一個欄位private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));是對線程池的運行狀態和線程池中有效線程的數量進行控制的，它包含兩部分信息: 線程池的運行狀態 (runState) 和線程池內有效線程的數量 (workerCount)，還有幾個對ctl進行計算的方法:

// 獲取運行狀態

private static int runStateOf(int c) { return c & ~CAPACITY; }

// 獲取活動線程數

private static int workerCountOf(int c) { return c & CAPACITY; }123456

以上兩個方法在源碼中經常用到，結合我們的目標，對運行狀態的一些判斷及處理可以不用去管，而對當前活動線程數要加以關注等等。

下面將遵循這些原則來分析源碼。

解惑

當我們要向線程池添加一個任務時是調用ThreadPollExcutor對象的execute(Runnable command)方法來完成的，所以先來看看ThreadPollExcutor類中的execute(Runnable command)方法的源碼：

public void execute(Runnable command) {

if (command == null)

throw new NullPointerException();

int c = ctl.get();

if (workerCountOf(c) < corePoolSize) {

if (addWorker(command, true))

return;

c = ctl.get();

}

if (isRunning(c) && workQueue.offer(command)) {

int recheck = ctl.get();

if (! isRunning(recheck) && remove(command))

reject(command);

else if (workerCountOf(recheck) == 0)

addWorker(null, false);

}

else if (!addWorker(command, false))

reject(command);

}

按照我們在分析方法中提到的一些原則，去掉一些相關性不強的代碼，看看核心代碼是怎樣的。

// 為分析而簡化後的代碼

public void execute(Runnable command) {

int c = ctl.get();

if (workerCountOf(c) < corePoolSize) {

// 如果當前活動線程數小於corePoolSize，則新建一個線程放入線程池中，並把任務添加到該線程中

if (addWorker(command, true))

return;

c = ctl.get();

}

// 如果當前活動線程數大於等於corePoolSize，則嘗試將任務放入緩存隊列

if (workQueue.offer(command)) {

int recheck = ctl.get();

if (workerCountOf(recheck) == 0)

addWorker(null, false);

}else {

// 緩存已滿，新建一個線程放入線程池，並把任務添加到該線程中（此時新建的線程相當於非核心線程）

addWorker(command, false)

}

這樣一看，邏輯應該清晰很多了。

如果當前活動線程數 < 指定的核心線程數，則創建並啟動一個線程來執行新提交的任務（此時新建的線程相當於核心線程）；
如果當前活動線程數 >= 指定的核心線程數，且緩存隊列未滿，則將任務添加到緩存隊列中；
如果當前活動線程數 >= 指定的核心線程數，且緩存隊列已滿，則創建並啟動一個線程來執行新提交的任務（此時新建的線程相當於非核心線程）；

接下來看addWorker(Runnable firstTask, boolean core)方法

private boolean addWorker(Runnable firstTask, boolean core) {

retry:

for (;;) {

int c = ctl.get();

int rs = runStateOf(c);

// Check if queue empty only if necessary.

if (rs >= SHUTDOWN &&

! (rs == SHUTDOWN &&

firstTask == null &&

! workQueue.isEmpty()))

return false;

for (;;) {

int wc = workerCountOf(c);

if (wc >= CAPACITY ||

wc >= (core ? corePoolSize : maximumPoolSize))

return false;

if ((c))

break retry;

c = ctl.get(); // Re-read ctl

if (runStateOf(c) != rs)

continue retry;

// else CAS failed e to workerCount change; retry inner loop

}

}

boolean workerStarted = false;

boolean workerAdded = false;

Worker w = null;

try {

w = new Worker(firstTask);

final Thread t = w.thread;

if (t != null) {

final ReentrantLock mainLock = this.mainLock;

mainLock.lock();

try {

// Recheck while holding lock.

// Back out on ThreadFactory failure or if

// shut down before lock acquired.

int rs = runStateOf(ctl.get());

if (rs < SHUTDOWN ||

(rs == SHUTDOWN && firstTask == null)) {

if (t.isAlive()) // precheck that t is startable

throw new IllegalThreadStateException();

workers.add(w);

int s = workers.size();

if (s > largestPoolSize)

largestPoolSize = s;

workerAdded = true;

}

} finally {

mainLock.unlock();

}

if (workerAdded) {

t.start();

workerStarted = true;

}

}

} finally {

if (! workerStarted)

addWorkerFailed(w);

}

return workerStarted;

}

同樣，我們也來簡化一下：

// 為分析而簡化後的代碼

private boolean addWorker(Runnable firstTask, boolean core) {

int wc = workerCountOf(c);

if (wc >= (core ? corePoolSize : maximumPoolSize))

// 如果當前活動線程數 >= 指定的核心線程數，不創建核心線程

// 如果當前活動線程數 >= 指定的最大線程數，不創建非核心線程

return false;

boolean workerStarted = false;

boolean workerAdded = false;

Worker w = null;

try {

// 新建一個Worker，將要執行的任務作為參數傳進去

w = new Worker(firstTask);

final Thread t = w.thread;

if (t != null) {

workers.add(w);

workerAdded = true;

if (workerAdded) {

// 啟動剛剛新建的那個worker持有的線程，等下要看看這個線程做了啥

t.start();

workerStarted = true;

}

}

} finally {

if (! workerStarted)

addWorkerFailed(w);

}

return workerStarted;

}2223242526272829303132

看到這里，我們大概能猜測到，addWorker方法的功能就是新建一個線程並啟動這個線程，要執行的任務應該就是在這個線程中執行。為了證實我們的這種猜測需要再來看看Worker這個類。

private final class Worker

extends AbstractQueuedSynchronizer

implements Runnable{

// ....

}

Worker(Runnable firstTask) {

setState(-1); // inhibit interrupts until runWorker

this.firstTask = firstTask;

this.thread = getThreadFactory().newThread(this);

}123456789101112

從上面的Worker類的聲明可以看到，它實現了Runnable介面，以及從它的構造方法中可以知道待執行的任務賦值給了它的變數firstTask，並以它自己為參數新建了一個線程賦值給它的變數thread，那麼運行這個線程的時候其實就是執行Worker的run()方法，來看一下這個方法：

public void run() {

runWorker(this);

}

final void runWorker(Worker w) {

Thread wt = Thread.currentThread();

Runnable task = w.firstTask;

w.firstTask = null;

w.unlock(); // allow interrupts

boolean completedAbruptly = true;

try {

while (task != null || (task = getTask()) != null) {

w.lock();

// If pool is stopping, ensure thread is interrupted;

// if not, ensure thread is not interrupted. This

// requires a recheck in second case to deal with

// shutdownNow race while clearing interrupt

if ((runStateAtLeast(ctl.get(), STOP) ||

(Thread.interrupted() &&

runStateAtLeast(ctl.get(), STOP))) &&

!wt.isInterrupted())

wt.interrupt();

try {

beforeExecute(wt, task);

Throwable thrown = null;

try {

task.run();

} catch (RuntimeException x) {

thrown = x; throw x;

} catch (Error x) {

thrown = x; throw x;

} catch (Throwable x) {

thrown = x; throw new Error(x);

} finally {

afterExecute(task, thrown);

}

} finally {

task = null;

w.completedTasks++;

w.unlock();

}

}

completedAbruptly = false;

} finally {

processWorkerExit(w, completedAbruptly);

}

}04142434445464748

在run()方法中只調了一下 runWorker(this) 方法，再來簡化一下這個 runWorker() 方法

// 為分析而簡化後的代碼

final void runWorker(Worker w) {

Runnable task = w.firstTask;

w.firstTask = null;

while (task != null || (task = getTask()) != null) {

try {

task.run();

} finally {

task = null;

}

}

}12345678910111213

很明顯，runWorker()方法裡面執行了我們新建Worker對象時傳進去的待執行的任務，到這里為止貌似這個worker的run()方法就執行完了，既然執行完了那麼這個線程也就沒用了，只有等待虛擬機銷毀了。那麼回顧一下我們的目標：Java線程池中的核心線程是如何被重復利用的？好像並沒有重復利用啊，新建一個線程，執行一個任務，然後就結束了，銷毀了。沒什麼特別的啊，難道有什麼地方漏掉了，被忽略了？再仔細看一下runWorker()方法的代碼，有一個while循環，當執行完firstTask後task==null了，那麼就會執行判斷條件(task = getTask()) != null，我們假設這個條件成立的話，那麼這個線程就不止只執行一個任務了，可以執行多個任務了，也就實現了重復利用了。答案呼之欲出了，接著看getTask()方法

private Runnable getTask() {

boolean timedOut = false; // Did the last poll() time out?

for (;;) {

int c = ctl.get();

int rs = runStateOf(c);

// Check if queue empty only if necessary.

if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {

decrementWorkerCount();

return null;

}

int wc = workerCountOf(c);

// Are workers subject to culling?

boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

if ((wc > maximumPoolSize || (timed && timedOut))

&& (wc > 1 || workQueue.isEmpty())) {

if ((c))

return null;

continue;

}

try {

Runnable r = timed ?

workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :

workQueue.take();

if (r != null)

return r;

timedOut = true;

} catch (InterruptedException retry) {

timedOut = false;

}

}

}

老規矩，簡化一下代碼來看：

// 為分析而簡化後的代碼

private Runnable getTask() {

boolean timedOut = false;

for (;;) {

int c = ctl.get();

int wc = workerCountOf(c);

// timed變數用於判斷是否需要進行超時控制。

// allowCoreThreadTimeOut默認是false，也就是核心線程不允許進行超時；

// wc > corePoolSize，表示當前線程池中的線程數量大於核心線程數量；

// 對於超過核心線程數量的這些線程，需要進行超時控制

boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

if (timed && timedOut) {

// 如果需要進行超時控制，且上次從緩存隊列中獲取任務時發生了超時，那麼嘗試將workerCount減1,即當前活動線程數減1，

// 如果減1成功，則返回null，這就意味著runWorker()方法中的while循環會被退出，其對應的線程就要銷毀了，也就是線程池中少了一個線程了

if ((c))

return null;

continue;

}

try {

Runnable r = timed ?

workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :

workQueue.take();

// 注意workQueue中的poll()方法與take()方法的區別

//poll方式取任務的特點是從緩存隊列中取任務,最長等待keepAliveTime的時長，取不到返回null

//take方式取任務的特點是從緩存隊列中取任務，若隊列為空,則進入阻塞狀態，直到能取出對象為止

if (r != null)

return r;

timedOut = true;

} catch (InterruptedException retry) {

timedOut = false;

}

}

從以上代碼可以看出，getTask()的作用是

如果當前活動線程數大於核心線程數，當去緩存隊列中取任務的時候，如果緩存隊列中沒任務了，則等待keepAliveTime的時長，此時還沒任務就返回null，這就意味著runWorker()方法中的while循環會被退出，其對應的線程就要銷毀了，也就是線程池中少了一個線程了。因此只要線程池中的線程數大於核心線程數就會這樣一個一個地銷毀這些多餘的線程。
如果當前活動線程數小於等於核心線程數，同樣也是去緩存隊列中取任務，但當緩存隊列中沒任務了，就會進入阻塞狀態，直到能取出任務為止，因此這個線程是處於阻塞狀態的，並不會因為緩存隊列中沒有任務了而被銷毀。這樣就保證了線程池有N個線程是活的，可以隨時處理任務，從而達到重復利用的目的。

小結

通過以上的分析，應該算是比較清楚地解答了「線程池中的核心線程是如何被重復利用的」這個問題，同時也對線程池的實現機制有了更進一步的理解：

當有新任務來的時候，先看看當前的線程數有沒有超過核心線程數，如果沒超過就直接新建一個線程來執行新的任務，如果超過了就看看緩存隊列有沒有滿，沒滿就將新任務放進緩存隊列中，滿了就新建一個線程來執行新的任務，如果線程池中的線程數已經達到了指定的最大線程數了，那就根據相應的策略拒絕任務。
當緩存隊列中的任務都執行完了的時候，線程池中的線程數如果大於核心線程數，就銷毀多出來的線程，直到線程池中的線程數等於核心線程數。此時這些線程就不會被銷毀了，它們一直處於阻塞狀態，等待新的任務到來。

注意：
本文所說的「核心線程」、「非核心線程」是一個虛擬的概念，是為了方便描述而虛擬出來的概念，在代碼中並沒有哪個線程被標記為「核心線程」或「非核心線程」，所有線程都是一樣的，只是當線程池中的線程多於指定的核心線程數量時，會將多出來的線程銷毀掉，池中只保留指定個數的線程。那些被銷毀的線程是隨機的，可能是第一個創建的線程，也可能是最後一個創建的線程，或其它時候創建的線程。一開始我以為會有一些線程被標記為「核心線程」，而其它的則是「非核心線程」，在銷毀多餘線程的時候只銷毀那些「非核心線程」，而「核心線程」不被銷毀。這種理解是錯誤的。

另外還有一個重要的介面 BlockingQueue 值得去了解，它定義了一些入隊出隊同步操作的方法，還可以阻塞，作用很大。

㈡ java中線程池如何管理多個線程

ExecutorService threadPoll = Executors.newCachedThreadPool(); //創建線程池
threadPoll.execute(線程1);//執行線程一

線程池根據程序需求創建新線程的，需求多時，創建的就多，需求少時，JVM自己會慢慢的釋放掉多餘的線程

不需求程序員去做什麼,JVM自己會處理,程序員調用就行了..

㈢在 Java 程序中怎麼保證多線程的運行安全

零基礎學習java可按照這份大綱來進行學習
第一階段：Java專業基礎課程
階段目標：
1. 熟練掌握Java的開發環境與編程核心知識
2. 熟練運用Java面向對象知識進行程序開發
3. 對Java的核心對象和組件有深入理解
4. 熟練應用JavaAPI相關知識
5. 熟練應用JAVA多線程技術
6. 能綜合運用所學知識完成一個項目
知識點：
1、基本數據類型，運算符，數組，掌握基本數據類型轉換，運算符，流程式控制制。
2、數組，排序演算法，Java常用API，類和對象，了解類與對象，熟悉常用API。
3、面向對象特性，集合框架，熟悉面向對象三大特性，熟練使用集合框架。
4、IO流，多線程。
5、網路協議，線程運用。
第二階段：JavaWEB核心課程
階段目標:
1. 熟練掌握資料庫和MySQL核心技術
2. 深入理解JDBC與DAO資料庫操作
3. 熟練運用JSP及Servlet技術完成網站後台開發
4. 深入理解緩存，連接池，註解，反射，泛型等知識
5. 能夠運用所學知識完成自定義框架
知識點：
1、資料庫知識，範式，MySQL配置，命令，建庫建表，數據的增刪改查，約束，視圖，存儲過程，函數，觸發器，事務，游標，建模工具。
2、深入理解資料庫管理系統通用知識及MySQL資料庫的使用與管理。為Java後台開發打下堅實基礎。Web頁面元素，布局，CSS樣式，盒模型，JavaScript，jQuery。
3、掌握前端開發技術，掌握jQuery。
4、Servlet，EL表達式，會話跟蹤技術，過濾器，FreeMarker。
5、掌握Servlet相關技術，利用Servlet，JSP相關應用技術和DAO完成B/S架構下的應用開發。
6、泛型，反射，註解。
7、掌握JAVA高級應用，利用泛型，註解，枚舉完成自己的CRUD框架開發為後續框架學習做鋪墊。
8、單點登錄，支付功能，項目整合，分頁封裝熟練運用JSP及Servlet核心知識完成項目實戰。
第三階段：JavaEE框架課程
階段目標：
1. 熟練運用Linux操作系統常見命令及完成環境部署和Nginx伺服器的配置
2. 熟練運用JavaEE三大核心框架：Spring,SpringMVC,MyBatis
3. 熟練運用Maven,並使用SpringBoot進行快速框架搭建
4. 深入理解框架的實現原理，Java底層技術，企業級應用等
5. 使用Shiro,Ztree和Spring,SpringMVC,Myts完成企業項目
知識點：
1、Linux安裝配置，文件目錄操作，VI命令，管理，用戶與許可權，環境部署，Struts2概述，hiberante概述。
2、Linux作為一個主流的伺服器操作系統，是每一個開發工程師必須掌握的重點技術，並且能夠熟練運用。
3、SSH的整合,MyBatis,SpringMVC,Maven的使用。
4、了解AOP原理，了解中央控制器原理，掌握MyBatis框架，掌握SSM框架的整合。
5、Shiro,Ztree，項目文檔，項目規范，需求分析，原型圖設計，資料庫設計，工程構建，需求評審，配置管理，BUG修復，項目管理等。
6、獨立自主完成一個中小型的企業級綜合項目的設計和整體架構的原型和建模。獨立自主完成一個大型的企業級綜合項目，並具備商業價值

㈣ java線程池怎麼實現的

線程池簡介：

多線程技術主要解決處理器單元內多個線程執行的問題，它可以顯著減少處理器單元的閑置時間，增加處理器單元的吞吐能力。

假設一個伺服器完成一項任務所需時間為：T1 創建線程時間，T2 在線程中執行任務的時間，T3 銷毀線程時間。

如果：T1 + T3 遠大於 T2，則可以採用線程池，以提高伺服器性能。

一個線程池包括以下四個基本組成部分：

1、線程池管理器（ThreadPool）：用於創建並管理線程池，包括創建線程池，銷毀線程池，添加新任務；

2、工作線程（PoolWorker）：線程池中線程，在沒有任務時處於等待狀態，可以循環的執行任務；

3、任務介面（Task）：每個任務必須實現的介面，以供工作線程調度任務的執行，它主要規定了任務的入口，任務執行完後的收尾工作，任務的執行狀態等；

4、任務隊列（taskQueue）：用於存放沒有處理的任務。提供一種緩沖機制。

線程池技術正是關注如何縮短或調整T1,T3時間的技術，從而提高伺服器程序性能的。它把T1，T3分別安排在伺服器程序的啟動和結束的時間段或者一些空閑的時間段，這樣在伺服器程序處理客戶請求時，不會有T1，T3的開銷了。

線程池不僅調整T1,T3產生的時間段，而且它還顯著減少了創建線程的數目，看一個例子：

假設一個伺服器一天要處理50000個請求，並且每個請求需要一個單獨的線程完成。在線程池中，線程數一般是固定的，所以產生線程總數不會超過線程池中線程的數目，而如果伺服器不利用線程池來處理這些請求則線程總數為50000。一般線程池大小是遠小於50000。所以利用線程池的伺服器程序不會為了創建50000而在處理請求時浪費時間，從而提高效率。

代碼實現中並沒有實現任務介面，而是把Runnable對象加入到線程池管理器（ThreadPool），然後剩下的事情就由線程池管理器（ThreadPool）來完成了

packagemine.util.thread;

importjava.util.LinkedList;
importjava.util.List;

/**
*線程池類，線程管理器：創建線程，執行任務，銷毀線程，獲取線程基本信息
*/
publicfinalclassThreadPool{
//線程池中默認線程的個數為5
privatestaticintworker_num=5;
//工作線程
privateWorkThread[]workThrads;
//未處理的任務
_task=0;
//任務隊列，作為一個緩沖,List線程不安全
privateList<Runnable>taskQueue=newLinkedList<Runnable>();
;

//創建具有默認線程個數的線程池
privateThreadPool(){
this(5);
}

//創建線程池,worker_num為線程池中工作線程的個數
privateThreadPool(intworker_num){
ThreadPool.worker_num=worker_num;
workThrads=newWorkThread[worker_num];
for(inti=0;i<worker_num;i++){
workThrads[i]=newWorkThread();
workThrads[i].start();//開啟線程池中的線程
}
}

//單態模式，獲得一個默認線程個數的線程池
(){
returngetThreadPool(ThreadPool.worker_num);
}

//單態模式，獲得一個指定線程個數的線程池,worker_num(>0)為線程池中工作線程的個數
//worker_num<=0創建默認的工作線程個數
(intworker_num1){
if(worker_num1<=0)
worker_num1=ThreadPool.worker_num;
if(threadPool==null)
threadPool=newThreadPool(worker_num1);
returnthreadPool;
}

//執行任務,其實只是把任務加入任務隊列，什麼時候執行有線程池管理器覺定
publicvoidexecute(Runnabletask){
synchronized(taskQueue){
taskQueue.add(task);
taskQueue.notify();
}
}

//批量執行任務,其實只是把任務加入任務隊列，什麼時候執行有線程池管理器覺定
publicvoidexecute(Runnable[]task){
synchronized(taskQueue){
for(Runnablet:task)
taskQueue.add(t);
taskQueue.notify();
}
}

//批量執行任務,其實只是把任務加入任務隊列，什麼時候執行有線程池管理器覺定
publicvoidexecute(List<Runnable>task){
synchronized(taskQueue){
for(Runnablet:task)
taskQueue.add(t);
taskQueue.notify();
}
}

//銷毀線程池,該方法保證在所有任務都完成的情況下才銷毀所有線程，否則等待任務完成才銷毀
publicvoiddestroy(){
while(!taskQueue.isEmpty()){//如果還有任務沒執行完成，就先睡會吧
try{
Thread.sleep(10);
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
//工作線程停止工作，且置為null
for(inti=0;i<worker_num;i++){
workThrads[i].stopWorker();
workThrads[i]=null;
}
threadPool=null;
taskQueue.clear();//清空任務隊列
}

//返回工作線程的個數
publicintgetWorkThreadNumber(){
returnworker_num;
}

//返回已完成任務的個數,這里的已完成是只出了任務隊列的任務個數，可能該任務並沒有實際執行完成
(){
returnfinished_task;
}

//返回任務隊列的長度，即還沒處理的任務個數
publicintgetWaitTasknumber(){
returntaskQueue.size();
}

//覆蓋toString方法，返回線程池信息：工作線程個數和已完成任務個數
@Override
publicStringtoString(){
return"WorkThreadnumber:"+worker_num+"finishedtasknumber:"
+finished_task+"waittasknumber:"+getWaitTasknumber();
}

/**
*內部類，工作線程
*/
{
//該工作線程是否有效，用於結束該工作線程
privatebooleanisRunning=true;

/*
*關鍵所在啊，如果任務隊列不空，則取出任務執行，若任務隊列空，則等待
*/
@Override
publicvoidrun(){
Runnabler=null;
while(isRunning){//注意，若線程無效則自然結束run方法，該線程就沒用了
synchronized(taskQueue){
while(isRunning&&taskQueue.isEmpty()){//隊列為空
try{
taskQueue.wait(20);
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
if(!taskQueue.isEmpty())
r=taskQueue.remove(0);//取出任務
}
if(r!=null){
r.run();//執行任務
}
finished_task++;
r=null;
}
}

//停止工作，讓該線程自然執行完run方法，自然結束
publicvoidstopWorker(){
isRunning=false;
}
}
}

㈤ JAVA線程的機制有哪些

Java的線程機制摘要：多線程機制是Java的重要技術，闡述了線程和進程的差別；Java中線程4個狀態之間的轉換；並結合例子說明了兩種創建線程的方法。線程是指程序中能順序執行的一個序列。一個線程只有一個入口點� 但可能有幾個出口點� 不過，每個時刻的執行點總是只有一個。線程是不能獨立運行的程序，而只是某個整體程序內部的一個順序執行流。多線程是Java的一個重要特點。如果一個程序是單線程的，那麼，任何時刻都只有一個執行點。這種單線程執行方法使系統運行效率低，而且，由於必須依靠中斷來處理輸入／輸出。所以，當出現頻繁輸入／輸出或者有優先順序較低的中斷請求時，實時性就變得很差。多線程系統可以避免這個缺點。所謂多線程，就是通過系統的調度使幾個具有不同功能的程序流即線程同時並行地運行。在單處理器計算機系統中，實際上是不可能使多個線程真正並行運行的，而要通過系統用極短的時間、極快的速度對多個線程進行切換，宏觀上形成多個線程並發執行的效果。１線程和進程機制上的差別線程和進程很相象,它們都是程序的一個順序執行序列,但兩者又有區別。進程是一個實體,每個進程有自己獨立的狀態,並有自己的專用數據段，創建進程時, 必須建立和復制其專用數據段，線程則互相共享數據段。同一個程序中的所有線程只有一個數據段, 所以, 創建線程時不必重新建立和復制數據段。由於數據段建立和復制這方面的差異，使線程的建立和線程間的切換速度大大優於進程,另一方面,線程又具備進程的大多數優點。假設銀行系統辦理存款和取款手續,將帳本看成數據段。如果按進程這種機制,那麼,當儲戶去存／取款時,銀行應先把帳本復制一遍,為儲戶建立一個獨立的帳本再結算。如果按線程機制, 那麼,銀行里所有的出納員都用同一個帳本,儲戶來辦存／取款時,也從這個帳本直接結算。用線程機制省去了數據段復制這一步顯然是線程獨具的特點。由於多個線程共享一個數據段,所以，也出現了數據訪問過程的互斥和同步問題,這使系統管理功能變得相對復雜。總的來說，一個多線程系統在提高系統的輸入／輸出速度、有效利用系統資源、改善計算機通信功能以及發揮多處理器硬體功能方面顯示了很大優勢。因此，一些最新的操作系統如Windows95、Windows98、Windows NT等都提供了對多線程的支持。但是，在多線程操作系統下設計多線程的程序仍然是一個比較復雜和困難的工作。由於需要解決對數據段的共享，所以，原則上應該從程序設計角度採用加鎖和釋放措施，稍有不慎，便會使系統產生管理上的混亂。而Java從語言一級提供對多線程的支持，這樣，可由語言和運行系統聯合提供對共享數據段的管理功能和同步機制，使得多線程並行程序設計相對比較容易。２ Java線程的生命周期每個線程都是和生命周期相聯系的，一個生命周期含有多個狀態，這些狀態間可以互相轉化。 Java的線程的生命周期可以分為4個狀態;創建（new)狀態;可運行(runnable)狀態;不執行(notrunnable)狀態;消亡(dead)狀態。創建狀態是指創建一個線程對應的對象的過程，Java系統中,些對象都是從Java．lang包內一個稱為Thread的類用關鍵字new創建的。剛創建的線程不能執行,必須向系統進行注冊、分配必要的資源後才能進入可運行狀態，這個步驟是由start操作完成的,而處於可運行狀態的線程也未必一定處於運行中,它有可能由於外部的I/O請求而處於不運行狀態。進入消亡狀態後,此線程就不再存在了。一個線程創建之後，總是處於其生命周期的4個狀態之一中，線程的狀態表明此線程當前正在進行的活動,而線程的狀態是可以通過程序來進行控制的,就是說,可以對線程進行操作來改變狀態。這些操作包括啟動(start)、終止(stop)、睡眠(sleep)、掛起(suspend)、恢復(resume)、等待(wait)和通知(notify)。每一個操作都對應了一個方法� 這些方法是由軟體包Java．lang提供的。通過各種操作,線程的4個狀態之間可按圖1所示進行轉換。 2.1 創建(new)狀態如果創建了一個線程而沒有啟動它,那麼，此線程就處於創建狀態。比如，下述語句執行以後，使系統有了一個處於創建狀態的線程myThread:� Thread myThread=new MyThreadClass(); 其中，MyThreadClass()是Thread的子類，而Thread是由Java系統的Java．lang軟體包提供的。處於創建狀態的線程還沒有獲得應有的資源,所以，這是一個空的線程,線程只有通過啟動後,系統才會為它分配資源。對處於創建狀態的線程可以進行兩種操作：一是啟動(start)操作,使其進入可運行狀態；二是終止(stop)操作,使其進入消亡狀態。如果進入到消亡狀態,那麼，此後這個線程就不能進入其它狀態,也就是說，它不復存在了。 start方法是對應啟動操作的方法,其具體功能是為線程分配必要的系統資源,將線程設置為可運行狀態,從而可以使系統調度這個線程。 2.2 可運行(runnable)狀態如果對一個處於創建狀態的線程進行啟動操作,則此線程便進入可運行狀態。比如,用下列語句� myThread.start();� � 則使線程myThread進入可運行狀態。上述語句實質上是調用了線程體即run()方法,注意，run()方法包含在myThread線程中,也就是先由java．lang包的Thread類將run()方法傳遞給子類MyThreadClass(),再通過創建線程由子類MyThreadClass,傳遞給線程myThread。線程處於可運行狀態只說明它具備了運行條件,但可運行狀態並不一定是運行狀態,因為在單處理器系統中運行多線程程序,實際上在一個時間點只有一個線程在運行,而系統中往往有多個線程同時處於可運行狀態,系統通過快速切換和調度使所有可運行線程共享處理器,造成宏觀上的多線程並發運行。可見,一個線程是否處於運行狀, 除了必須處於可運行狀態外,還取決於系統的調度。在可運行狀態可以進行多種操作，最通常的是從run()方法正常退出而使線程結束,進入消亡狀態。此, 還可以有如下操作� 掛起操作,通過調用suspend方法來實現；睡眠操作,通過調用sleep方法來實現；等待操作,通過調用wait方法來實現；退讓操作,通過調用yield方法來實現；終止操作,通過調用stop方法來實現。前面三種操作都會使一個處於可運行狀態的線程進入不可運行狀態。比如，仍以myThread線程為例,當其處於可運行狀態後,再用如下語句� myThread.sleep (5000); 則調用sleep方法使myThread線程睡眠5s(5000ms)。這5s內,此線程不能被系統調度運行,只有過5s後,myThread線程才會醒來並自動回到可運行狀態。如果一個線程被執行掛起操作而轉到不可運行狀態,則必須通過調用恢復(resume)操作,才能使這個線程再回到可運行狀態。退讓操作是使某個線程把CPU控制權提前轉交給同級優先權的其他線程。對可運行狀態的線程也可以通過調用stop方法使其進入消亡狀態。 2.3 不可運行(not runnable)狀態不可運行狀態都是由可運行狀態轉變來的。一個處於可運行狀態的線程,如果遇到掛起(suspend)操作、睡眠(sleep)操作或者等待(wait)操作,就會進入不可運行狀態。另外,如果一個線程是和I/O操作有關的,那麼，在執行I/O指令時，由於外設速度遠遠低於處理器速度而使線程受到阻, 從而進入不可運行狀態，只有外設完成輸入／輸出之後,才會自動回到可運行狀態。線程進入不可運行狀態後,還可以再回到可運行狀態,通常有三種途徑使其恢復到可運行狀態。一是自動恢復。通過睡眠(sleep)操作進入不可運行狀態的線程會在過了指定睡眠時間以後自動恢復到可運行狀態,由於I/O阻塞而進入不可運行狀態的線程在外設完成I/O操作後,自動恢復到可運行狀態。二是用恢復(resume)方法使其恢復。如果一個線程由於掛起(suspend)操作而從可運行狀態進入不可運行狀態,那麼，必須用恢復(resume)操作使其再恢復到可運行狀態。三是用通知(notify或notifyAll)方法使其恢復。如果一個處於可運行狀態的線程由於等待(wait)操作而轉入不可運行狀態,那麼，必須通過調用notify方法或notifyAll方法才能使其恢復到可運行狀態,採用等待操作往往是由於線程需要等待某個條件變數,當獲得此條件變數後,便可由notify或ontifyAll方法使線程恢復到可運行狀態。恢復到可運行狀態的每一種途徑都是有針對性的,不能交叉。比如，對由於阻塞而進入不可運行狀態的線程採用恢復操作將是無效的。在不可運行狀態,也可由終止(stop)操作使其進入消亡狀態。 2.4 消亡(dead)狀態一個線程可以由其他任何一個狀態通過終止(stop)操作而進入消亡狀態。線程一旦進入消亡狀態,那它就不再存在了,所以也不可能再轉到其它狀態。通常,在一個應用程序運行時,如果通過其它外部命令終止當前應用程序,那麼就會調用(stop)方法終止線程。但是，最正常、最常見的途徑是由於線程在可運行狀態正常完成自身的任務而″壽終正寢″,從而進入消亡狀態,這個完成任務的動作是由run方法實現的。３ Java線程的兩種創建途徑一種途徑是通過對Thread的繼承來派生一個子類,再由此子類生成一個對象來實現線程的創建，這是比較簡單直接的辦法。Thread類包含在系統API提供的8個軟體包之一Java．lang中,Thread類中包含了很多與線程有關的方, 其中,一個名為run的方法就是用來實現線程行為的。比如:� １ import java.lang.*� ／／引用lang包２ class Mango exteds Thread { ３ public void run() { ４．．．．．．５ �} ６ �} 上述程序段中，第１行語句引用軟體包lang，這樣做是為了給編譯器一個信息，從而使後面程序中有關lang包中的方法可直接用方法名，而不必帶前綴「Java．lang」。第２行語句是從lang包Thread派生一個子類Mango, 而這個子類中提供了run方法的實現,這樣,運行時，將由子類Mango 的 run方法置換父類Thread的run方法。不過這一步還沒有創建線, 必須由子類生成一個對象，並且進行啟動操作，這樣才能得到一個處於可運行狀態的線程。生成對象其實就是完成線程的創建,而啟動是對已創建的線程進行操作。具體語句如下:� Mango t=new Mango(); � t.start(); � 上面先用關鍵字new使線程進入創建狀態,又調用start()方法使線程進入可運行狀態。注意，start()方法是由Thread繼承給子類Mango、然後又在生成對象時由對象t從類Mango得到的。另一種途徑是通過一個類去繼承介面runnable來實現線程的創建� 而這個類必須提供runnable介面中定義的方法run()的實現。runnable是Java．lang包中的一個介面，在runnable介面中,只定義了一個抽象方法run()。所以，如用這種途徑來創建線程,則應先由一個類連接介面runnable，並且提供run()方法的實現。比如，下面的程序段實現了與介面的連接。１ public class xyz implements Runnable{ ２ int i; � ３ public voed run(){ ４ while (true){ � ５ System.out.println("Hello"+i++); ６ � } ７ � } ８ � } 然後再創建一個線程� runnable r=new xyz(); � Thread t=new Thread(r); 這種途徑創建線程比第一種途徑靈活。當一個類既需要繼承一個父類又要由此創建一個線程時，由於Java不支持多重繼承，這樣，用第一種途徑將行不通,因為，按此思路創建線程也是以繼承的方法實現的。於是，就需要一個類既繼承Thread類,又繼承另一個父類。但用介面方法卻能實現這個目標。４線程的啟動和終止 Thread的start()方法對應於啟動操作,它完成兩方面的功能：一方面是為線程分配必要的資源,使線程處於可運行狀態,另一方面是調用線程的run()方法置換Thread的中run()方法或者置換runnable中的run()方法來運行線程。使用start()方法的語句很簡單,即： ThreadName.start(); 下面的程序段先創建並啟動線程myThread, 然後使用sleep()方法讓其睡眠20000ms即20s，使其處於不可運行狀態,過20s後,線程又自動恢復到可運行狀態。 Thread MyThread=new MyThreadClass(); MyThread.start();� � try{ � MyThread.sleep(20000); �} catch(InterrujptedException e){ }

㈥ Java中，線程是什麼意思，多線程又是什麼

在計算機中當一個程序運行的時候就會創建至少一個進程，例如當我們運行QQ的時候，系統就會創建進程來處理我們平時的一些操作，當我們打開任務管理器的時候，在進程的列表裡面就可以找到QQ.exe的運行程序;

在計算機中處理進程之外還有另一個概念就是線程，線程是存在於進程當中，一個進程可以包含多個線程;當我們的計算機有多核處理器的時候，使用多線程可以加快程序的運算速率;如果一個進程中只有一個線程，當程序遇到一個比較耗時的計算的時候，由於程序是單線程的，那麼程序只能等待這個運算結束的時候再繼續運行，這樣會大大的降低程序的效率;當時用多個線程的時候，在某個線程遇到比較耗時的運算的時候，該線程可以繼續自己的運算，但是其他的線程也可以同步進行，這樣當耗時的計算結束之後，其他線程也將自己所需要的東西執行完畢，這樣就會很大的提高程序執行效率;

在程序運行中對於文件的保存相對於處理器的運算速度來說是很慢的，當我們程序中接收到一個保存文件的信息之後，我們可以創建一個保存文件的線程，在主線程中我們可以繼續進行我們的其他運算，這樣當文件保存好之後，我們的其他運算也會完成，互不影響;

在Java中我們可以創建一個自己的類繼承於Thread類，並且重寫run() 方法，當線程啟動之後，run()方法裡面的操作都在線程中進行處理，而不會影響主線程的信息;

當我們創建好一個自定義線程類之後，我們可以創建這個自定義線程的對象，進行線程的啟動;線程須調用start();方法進行啟動，這樣run()方法裡面的內容才會在線程中運行;如果我們不去調用start()方法，那我們只是創建了一個普通的類，即使我們手動調用run()方法，run()方法裡面的內容也不會在線程中運行;

在Java中線程主要有初始狀態，運行狀態，阻塞狀態，終止狀態等;當我們新創建一個線程對象的時候，此時線程的狀態為初始狀態;當我們調用start()之後，此時的線程才被激活成為運行狀態，之後run()方法裡面的信息才會在子線程中運行;我們可以在不同的階段調用不同的方法將線程設置為不同的狀態;比如有時候我們的操作需要等待其他線程中運算結束之後才可以繼續進行，這時候我們就可以將線程設置為等待狀態，當需要的資源滿足條件之後，可以繼續運行當前的線程;

以上的內容就是關於Java中線程是什麼，更多關於Java方面的問題可以看下這個視頻教程：網頁鏈接，希望我的回答能幫到你。

㈦ Java中如何保證線程安全性

並發（concurrency）一個並不陌生的詞，簡單來說，就是cpu在同一時刻執行多個任務。

而Java並發則由多線程實現的。

在jvm的世界裡，線程就像不相乾的平行空間，串列在虛擬機中。（當然這是比較籠統的說法，線程之間是可以交互的，他們也不一定是串列。）

多線程的存在就是壓榨cpu，提高程序性能，還能減少一定的設計復雜度（用現實的時間思維設計程序）。

這么說來似乎線程就是傳說中的銀彈了，可事實告訴我們真正的銀彈並不存在。

多線程會引出很多難以避免的問題，如死鎖，臟數據，線程管理的額外開銷，等等。更大大增加了程序設計的復雜度。

但他的優點依舊不可替代。

死鎖和臟數據就是典型的線程安全問題。

簡單來說，線程安全就是：在多線程環境中，能永遠保證程序的正確性。

只有存在共享數據時才需要考慮線程安全問題。

java內存區域：

其中，方法區和堆就是主要的線程共享區域。那麼就是說共享對象只可能是類的屬性域或靜態域。

了解了線程安全問題的一些基本概念後，我們就來說說如何解決線程安全問題。我們來從一個簡單的servlet示例來分析：

1. 了解業務場景的線程模型

這里的線程模型指的是: 在該業務場景下，可能出現的線程調用實況。

眾所周知，Servlet是被設計為單實例，在請求進入tomcat後，由Connector建立連接，再講請求分發給內部線程池中的Processor，

此時Servlet就處於一個多線程環境。即如果存在幾個請求同時訪問某個servlet，就可能會有幾個線程同時訪問該servlet對象。如圖：

線程模型，如果簡單的話，就在腦海模擬一下就好了，復雜的話就可以用紙筆或其他工具畫出來。

2. 找出共享對象

這里的共享對象就很明顯就是ReqCounterServlet。

3. 分析共享對象的不變性條件

不變性條件，這個名詞是在契約式編程的概念中的。不變性條件保證類的狀態在任何功能被執行後都保持在一個可接受的狀態。

這里可以引申出，不可變對象是線程安全的。（因為不可變對象就沒有不變性條件）

不變性條件則主要由對可變狀態的修改與訪問構成。

這里的servlet很簡單，不變性條件大致可以歸納為：每次請求進入時count計數必須加一，且計數必須正確。

在復雜的業務中，類的不變性條件往往很難考慮周全。設計的世界是險惡的，只能小心謹慎，用測量去證明，最大程度地減少錯誤出現的幾率。

4. 用特定的策略解決線程安全問題。

如何解決的確是該流程的重點。目前分三種方式解決：

第一種，修改線程模型。即不在線程之間共享該狀態變數。一般這個改動比較大，需要量力而行。

第二種，將對象變為不可變對象。有時候實現不了。

第三種，就比較通用了，在訪問狀態變數時使用同步。 synchronized和Lock都可以實現同步。簡單點說，就是在你修改或訪問可變狀態時加鎖，獨占對象，讓其他線程進不來。

這也算是一種線程隔離的辦法。（這種方式也有不少缺點，比如說死鎖，性能問題等等）

其實有一種更好的辦法，就是設計線程安全類。《代碼大全》就有提過，問題解決得越早，花費的代價就越小。

是的，在設計時，就考慮線程安全問題會容易的多。

首先考慮該類是否會存在於多線程環境。如果不是，則不考慮線程安全。

然後考慮該類是否能設計為不可變對象，或者事實不可變對象。如果是，則不考慮線程安全

最後，根據流程來設計線程安全類。

設計線程安全類流程：

1、找出構成對象狀態的所有變數。

2、找出約束狀態變數的不變性條件。

3、建立對象狀態的並發訪問管理策略。

有兩種常用的並發訪問管理策略：

1、java監視器模式。一直使用某一對象的鎖來保護某狀態。

2、線程安全委託。將類的線程安全性委託給某個或多個線程安全的狀態變數。（注意多個時，這些變數必須是彼此獨立，且不存在相關聯的不變性條件。）

導航:首頁 > 編程語言 > java線程管理

java線程管理

線程池簡介：

與java線程管理相關的資料