java線程隊列,Java線程池隊列

本文目錄一覽：

• 1、Java線程的知識要點？
• 2、java 如何實現一個線程安全的隊列
• 3、java多線程編程中涉及的基礎知識點？
• 4、java線程組，線程池，線程隊列分別是什麼？有什麼區別？
• 5、Java中關於如何實現多線程消息隊列的實例
• 6、java 線程池 工作隊列是如何工作的

Java線程的知識要點？

一、進程的概念

進程表示資源分配的基本單位，又是調度運行的基本單位。例如，用戶運行自己的程序，系統就創建一個進程，並給它分配資源，包括內存空間、磁碟空間、I/O設備等。然後，把該進程放入就緒隊列。進程調度程序選中它，為它分配CPU以及其他有關的資源，該進程才真正運行。所以，雲南電腦培訓發現進程是系統中的並發執行的單位。

二、線程的概念

線程：（英語：thread）是操作系統能夠進行運算調度的最小單位。它被包含在進程之中，是進程中的實際運作單位。一條線程指的是進程中一個單一順序的控制流，一個進程中可以並發多個線程，每條線程並行執行不同的任務。

三、引用線程的優勢

（1）易於調度。

（2）提高並發性。通過線程可方便有效地實現並發性。進程可創建多個線程來執行同一程序的不同部分或相同部分。

（3）開銷少。創建線程比創建進程要快，所需開銷很少。

（4）利於充分發揮多處理器的功能。通過創建多線程進程（即一個進程可具有兩個或更多個線程），每個線程在一個處理器上運行，從而實現應用程序的並發性，使每個處理器都得到充分運行。

四、進程與線程的關係

（1）一個線程只能屬於一個進程，而一個進程可以有多個線程，但至少有一個線程。

（2）資源分配給進程，同一進程的所有線程共享該進程的所有資源。

（3）處理機分給線程，即真正在處理機上運行的是線程。

（4）線程在執行過程中，要協作同步。不同進程的線程間要利用消息通信的辦法實現同步。

簡單來說：

1、一個程序至少有一個進程,一個進程至少有一個線程。

2、進程在執行過程中擁有獨立的資源，而多個線程共享進程中的資源。

java 如何實現一個線程安全的隊列

以下是兩個線程：

import java.util.*;

public class Thread_List_Operation {

//假設有這麼一個隊列

static List list = new LinkedList();

public static void main(String[] args) {

Thread t;

t = new Thread(new T1());

t.start();

t = new Thread(new T2());

t.start();

}

}

//線程T1,用來給list添加新元素

class T1 implements Runnable{

void getElemt(Object o){

Thread_List_Operation.list.add(o);

System.out.println(Thread.currentThread().getName() + “為隊列添加了一個元素”);

}

@Override

public void run() {

for (int i = 0; i 10; i++) {

getElemt(new Integer(1));

}

}

}

//線程T2,用來給list添加新元素

class T2 implements Runnable{

void getElemt(Object o){

Thread_List_Operation.list.add(o);

System.out.println(Thread.currentThread().getName() + “為隊列添加了一個元素”);

}

@Override

public void run() {

for (int i = 0; i 10; i++) {

getElemt(new Integer(1));

}

}

}

//結果（亂序）

Thread-0為隊列添加了一個元素

Thread-1為隊列添加了一個元素

Thread-0為隊列添加了一個元素

Thread-1為隊列添加了一個元素

Thread-1為隊列添加了一個元素

Thread-1為隊列添加了一個元素

Thread-1為隊列添加了一個元素

Thread-1為隊列添加了一個元素

Thread-1為隊列添加了一個元素

Thread-1為隊列添加了一個元素

Thread-1為隊列添加了一個元素

Thread-1為隊列添加了一個元素

Thread-0為隊列添加了一個元素

Thread-0為隊列添加了一個元素

Thread-0為隊列添加了一個元素

Thread-0為隊列添加了一個元素

Thread-0為隊列添加了一個元素

Thread-0為隊列添加了一個元素

Thread-0為隊列添加了一個元素

Thread-0為隊列添加了一個元素

java多線程編程中涉及的基礎知識點？

線程設計在軟體開發領域中是非常常見的一個設計構成，今天昆明北大青鳥就一起來了解一下，java多線程編程中都涉及到了哪些基礎知識點。

順序

用於表示多個操作「依次處理」。比如把十個操作交給一個人來處理時，這個人要一個一個地按順序來處理

並行

用於標識多個操作「同時處理」。比如十個操作分給兩個人處理時，這兩個人就會並行來處理。

並發

相對於順序和並行來說比較抽象，用於表示「將一個操作分割成多個部分並且允許無序處理」。比如將十個操作分成相對獨立的兩類，這樣便能夠開始並發處理了。如果一個人來處理，這個人就是順序處理分開的並發操作，而如果是兩個人，這兩個人就可以並行處理同一個操作。

總結

多線程程序都是並發處理的。如果CPU只有一個，那麼並發處理就是順序執行的，而如果有多個CPU，那麼並發處理就可能會並行運行。

等待隊列

所有實例都擁有一個等待隊列，它是在實例的wait方法執行後停止操作的線程隊列。就好比為每個實例準備的線程休息室

在執行wait方法後，線程便會暫停操作，進入等待隊列這個休息室。除非發生下列某一情況，否則線程會一直在等待隊列中休眠。

有其他線程的notify方法來喚醒線程

有其他線程的notifyAll方法來喚醒線程

有其他線程的interrupt方法來喚醒線程

wait方法超時

notify方法

該方法會將等待隊列中的一個線程去除。同wait方法一樣，若要執行notify方法，線程也必須持有要調用的實例的鎖。

notifyAll方法

notify方法僅喚醒一個線程，而notifyAll則喚醒所有線程，這是兩者之間的區別

同wait方法和notify方法一樣，notifyAll方法也只能由持有要調用的實例鎖的線程調用

notify和notifyAll選擇

notify方法和notifyAll方法非常相似，到底該使用哪個?

實際上，這很難選擇，由於notify喚醒的線程較少，所以處理速度要比使用notifyAll時快。但使用notify時，如果處理不好，程序便可能會停止。一般來說，使用notifyAll時的代碼要比使用notify時的更為健壯。

java線程組，線程池，線程隊列分別是什麼？有什麼區別？

你好，我可以給你詳細解釋一下：

線程組表示一個線程的集合。此外，線程組也可以包含其他線程組。線程組構成一棵樹，在樹中，除了初始線程組外，每個線程組都有一個父線程組。

允許線程訪問有關自己的線程組的信息，但是不允許它訪問有關其線程組的父線程組或其他任何線程組的信息。

線程池：我們可以把並發執行的任務傳遞給一個線程池，來替代為每個並發執行的任務都啟動一個新的線程。只要池裡有空閑的線程，任務就會分配給一個線程執行。在線程池的內部，任務被插入一個阻塞隊列（Blocking Queue ），線程池裡的線程會去取這個隊列里的任務。當一個新任務插入隊列時，一個空閑線程就會成功的從隊列中取出任務並且執行它。

線程池經常應用在多線程伺服器上。每個通過網路到達伺服器的連接都被包裝成一個任務並且傳遞給線程池。線程池的線程會並發的處理連接上的請求。以後會再深入有關 Java 實現多線程伺服器的細節。

線程隊列：是指線程處於擁塞的時候形成的調度隊列

排隊有三種通用策略：

直接提交。工作隊列的默認選項是 SynchronousQueue，它將任務直接提交給線程而不保持它們。在此，如果不存在可用於立即運行任務的線程，則試圖把任務加入隊列將失敗，因此會構造一個新的線程。此策略可以避免在處理可能具有內部依賴性的請求集時出現鎖。直接提交通常要求無界 maximumPoolSizes 以避免拒絕新提交的任務。當命令以超過隊列所能處理的平均數連續到達時，此策略允許無界線程具有增長的可能性。

無界隊列。使用無界隊列（例如，不具有預定義容量的 LinkedBlockingQueue）將導致在所有corePoolSize 線程都忙時新任務在隊列中等待。這樣，創建的線程就不會超過 corePoolSize。（因此，maximumPoolSize的值也就無效了。）當每個任務完全獨立於其他任務，即任務執行互不影響時，適合於使用無界隊列；例如，在 Web頁伺服器中。這種排隊可用於處理瞬態突發請求，當命令以超過隊列所能處理的平均數連續到達時，此策略允許無界線程具有增長的可能性。

有界隊列。當使用有限的 maximumPoolSizes時，有界隊列（如 ArrayBlockingQueue）有助於防止資源耗盡，但是可能較難調整和控制。隊列大小和最大池大小可能需要相互折衷：使用大型隊列和小型池可以最大限度地降低 CPU 使用率、操作系統資源和上下文切換開銷，但是可能導致人工降低吞吐量。如果任務頻繁阻塞（例如，如果它們是 I/O邊界），則系統可能為超過您許可的更多線程安排時間。使用小型隊列通常要求較大的池大小，CPU使用率較高，但是可能遇到不可接受的調度開銷，這樣也會降低吞吐量。

Java中關於如何實現多線程消息隊列的實例

java中的消息隊列

消息隊列是線程間通訊的手段：

import java.util.*

public class MsgQueue{

private Vector queue = null;

public MsgQueue(){

queue = new Vector();

}

public synchronized void send(Object o)

{

queue.addElement(o);

}

public synchronized Object recv()

{

if(queue.size()==0)

return null;

Object o = queue.firstElement();

queue.removeElementAt(0);//or queue[0] = null can also work

return o;

}

}

因為java中是locked by object的所以添加synchronized 就可以用於線程同步鎖定對象

可以作為多線程處理多任務的存放task的隊列。他的client包括封裝好的task類以及thread類

Java的多線程-線程間的通信2009-08-25 21:58

1. 線程的幾種狀態

線程有四種狀態，任何一個線程肯定處於這四種狀態中的一種：

1) 產生（New）：線程對象已經產生，但尚未被啟動，所以無法執行。如通過new產生了一個線程對象後沒對它調用start()函數之前。

2) 可執行（Runnable）：每個支持多線程的系統都有一個排程器，排程器會從線程池中選擇一個線程並啟動它。當一個線程處於可執行狀態時，表示它可能正處於線程池中等待排排程器啟動它；也可能它已正在執行。如執行了一個線程對象的start()方法後，線程就處於可執行狀態，但顯而易見的是此時線程不一定正在執行中。

3) 死亡（Dead）：當一個線程正常結束，它便處於死亡狀態。如一個線程的run()函數執行完畢後線程就進入死亡狀態。

4) 停滯（Blocked）：當一個線程處於停滯狀態時，系統排程器就會忽略它，不對它進行排程。當處於停滯狀態的線程重新回到可執行狀態時，它有可能重新執行。如通過對一個線程調用wait()函數後，線程就進入停滯狀態，只有當兩次對該線程調用notify或notifyAll後它才能兩次回到可執行狀態。

2. class　Thread下的常用函數函數

2.1 suspend()、resume()

1) 通過suspend()函數，可使線程進入停滯狀態。通過suspend()使線程進入停滯狀態後，除非收到resume()消息，否則該線程不會變回可執行狀態。

2) 當調用suspend()函數後，線程不會釋放它的「鎖標誌」。

例11：

class TestThreadMethod extends Thread{

public static int shareVar = 0;

public TestThreadMethod(String name){

super(name);

}

public synchronized void run(){

if(shareVar==0){

for(int i=0; i5; i++){

shareVar++;

if(shareVar==5){

this.suspend();　//（1）

}}}

else{

System.out.print(Thread.currentThread().getName());

System.out.println(” shareVar = ” + shareVar);

this.resume();　//（2）

}}

}

public class TestThread{

public static void main(String[] args){

TestThreadMethod t1 = new TestThreadMethod(“t1”);

TestThreadMethod t2 = new TestThreadMethod(“t2”);

t1.start();　//（5）

//t1.start();　//（3）

t2.start();　//（4）

}}

java 線程池 工作隊列是如何工作的

使用線程池的好處

1、降低資源消耗

可以重複利用已創建的線程降低線程創建和銷毀造成的消耗。

2、提高響應速度

當任務到達時，任務可以不需要等到線程創建就能立即執行。

3、提高線程的可管理性

線程是稀缺資源，如果無限制地創建，不僅會消耗系統資源，還會降低系統的穩定性，使用線程池可以進行統一分配、調優和監控

線程池的工作原理

首先我們看下當一個新的任務提交到線程池之後，線程池是如何處理的

1、線程池判斷核心線程池裡的線程是否都在執行任務。如果不是，則創建一個新的工作線程來執行任務。如果核心線程池裡的線程都在執行任務，則執行第二步。

2、線程池判斷工作隊列是否已經滿。如果工作隊列沒有滿，則將新提交的任務存儲在這個工作隊列里進行等待。如果工作隊列滿了，則執行第三步

3、線程池判斷線程池的線程是否都處於工作狀態。如果沒有，則創建一個新的工作線程來執行任務。如果已經滿了，則交給飽和策略來處理這個任務

線程池飽和策略

這裡提到了線程池的飽和策略，那我們就簡單介紹下有哪些飽和策略：

AbortPolicy

為Java線程池默認的阻塞策略，不執行此任務，而且直接拋出一個運行時異常，切記ThreadPoolExecutor.execute需要try catch，否則程序會直接退出。

DiscardPolicy

直接拋棄，任務不執行，空方法

DiscardOldestPolicy

從隊列裡面拋棄head的一個任務，並再次execute 此task。

CallerRunsPolicy

在調用execute的線程裡面執行此command，會阻塞入口

用戶自定義拒絕策略（最常用）

實現RejectedExecutionHandler，並自己定義策略模式

下我們以ThreadPoolExecutor為例展示下線程池的工作流程圖

1.jpg

2.jpg

1、如果當前運行的線程少於corePoolSize，則創建新線程來執行任務（注意，執行這一步驟需要獲取全局鎖）。

2、如果運行的線程等於或多於corePoolSize，則將任務加入BlockingQueue。

3、如果無法將任務加入BlockingQueue（隊列已滿），則在非corePool中創建新的線程來處理任務（注意，執行這一步驟需要獲取全局鎖）。

4、如果創建新線程將使當前運行的線程超出maximumPoolSize，任務將被拒絕，並調用RejectedExecutionHandler.rejectedExecution()方法。

ThreadPoolExecutor採取上述步驟的總體設計思路，是為了在執行execute()方法時，儘可能地避免獲取全局鎖（那將會是一個嚴重的可伸縮瓶頸）。在ThreadPoolExecutor完成預熱之後（當前運行的線程數大於等於corePoolSize），幾乎所有的execute()方法調用都是執行步驟2，而步驟2不需要獲取全局鎖。

線程池只是並發編程中的一小部分，下圖是史上最全面的Java的並發編程學習技術總匯

3.jpg

關鍵方法源碼分析

我們看看核心方法添加到線程池方法execute的源碼如下：

//     //Executes the given task sometime in the future.  The task     //may execute in a new thread or in an existing pooled thread.     //     // If the task cannot be submitted for execution, either because this     // executor has been shutdown or because its capacity has been reached,     // the task is handled by the current {@code RejectedExecutionHandler}.     //     // @param command the task to execute     // @throws RejectedExecutionException at discretion of     //         {@code RejectedExecutionHandler}, if the task     //         cannot be accepted for execution     // @throws NullPointerException if {@code command} is null     //    public void execute(Runnable command) {        if (command == null)            throw new NullPointerException();        //         // Proceed in 3 steps:         //         // 1. If fewer than corePoolSize threads are running, try to         // start a new thread with the given command as its first         // task.  The call to addWorker atomically checks runState and         // workerCount, and so prevents false alarms that would add         // threads when it shouldn’t, by returning false.         // 翻譯如下：         // 判斷當前的線程數是否小於corePoolSize如果是，使用入參任務通過addWord方法創建一個新的線程，         // 如果能完成新線程創建exexute方法結束，成功提交任務         // 2. If a task can be successfully queued, then we still need         // to double-check whether we should have added a thread         // (because existing ones died since last checking) or that         // the pool shut down since entry into this method. So we         // recheck state and if necessary roll back the enqueuing if         // stopped, or start a new thread if there are none.         // 翻譯如下：         // 在第一步沒有完成任務提交；狀態為運行並且能否成功加入任務到工作隊列後，再進行一次check，如果狀態         // 在任務加入隊列後變為了非運行（有可能是在執行到這裡線程池shutdown了），非運行狀態下當然是需要         // reject；然後再判斷當前線程數是否為0（有可能這個時候線程數變為了0），如是，新增一個線程；         // 3. If we cannot queue task, then we try to add a new         // thread.  If it fails, we know we are shut down or saturated         // and so reject the task.         // 翻譯如下：         // 如果不能加入任務到工作隊列，將嘗試使用任務新增一個線程，如果失敗，則是線程池已經shutdown或者線程池         // 已經達到飽和狀態，所以reject這個他任務         //        int c = ctl.get();        // 工作線程數小於核心線程數        if (workerCountOf(c) corePoolSize) {            // 直接啟動新線程，true表示會再次檢查workerCount是否小於corePoolSize            if (addWorker(command, true))                return;            c = ctl.get();        }        // 如果工作線程數大於等於核心線程數        // 線程的的狀態未RUNNING並且隊列notfull        if (isRunning(c) workQueue.offer(command)) {            // 再次檢查線程的運行狀態，如果不是RUNNING直接從隊列中移除            int recheck = ctl.get();            if (! isRunning(recheck) remove(command))                // 移除成功，拒絕該非運行的任務                reject(command);            else if (workerCountOf(recheck) == 0)                // 防止了SHUTDOWN狀態下沒有活動線程了，但是隊列里還有任務沒執行這種特殊情況。                // 添加一個null任務是因為SHUTDOWN狀態下，線程池不再接受新任務                addWorker(null, false);        }        // 如果隊列滿了或者是非運行的任務都拒絕執行        else if (!addWorker(command, false))            reject(command);    }