executorjava
㈠ java ThreadPoolExecutor 線程池如何控制活動線程的執行時間，例如該線程執行時間超過30秒就自動終止
在線程開始的時候，用一個變數記錄當燃陸前系統時間，線程執行完後再取一次系統時間，兩個時間的差就是線程執行時間了皮磨頃。
這個類你參考一下
java.util.Timer
用這下面的TimeTask類（指定延時）
java裡面的sleep()並不能精確定時，TimeTask可以：例下面的小程序：
import java.util.*;
public class test{
public static void main (String []args){
Timer timer=new Timer();/游嘩/實例化Timer類
timer.schele(new TimerTask(){
public void run(){
System.out.println("退出");
this.cancel();}},30000);//這里百毫秒
System.out.println("本程序存在30秒後自動退出");
}
}
㈡ 在java中executor和executors的區別
1. Executor
它是"執行者"介面，它是來執行任務的。准確的說，Executor提供了execute()介面來執行已提交的 Runnable 任務的對象。Executor存在的目的是提供一種將"任務提交"與"任務如何運行"分李枯離開來梁擾鍵的機制。它只包含一個函數介面。
2. Executors
Executors是個靜態工廠橡巧類。它通過靜態工廠方法返回ExecutorService、ScheledExecutorService、ThreadFactory 和 Callable 等類的對象。
㈢ Java的ThreadPoolExecutor類是如何讓線程進入timed_waiting狀態的...
我簡單看了一下代碼，大概可能是這樣的：
ThreadPoolExecutor裡面是一個workQueue應該就是任務了。這個是BlockingQueue！所以等裡面沒有東西是，你再去取就會被掛起了。
ThreadPoolExecutor在getTask()的時候，會執行到這樣的代碼：
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
不管是poll()還是take()都會讓當前線程等待。
㈣ 在java中executor是框架嗎
不是框架，是java.util.concorrent包下的多線程調用類。。
㈤ 在java中executor和executors的區別
Executor使用線程池來管理線程，可以重復利用已經創建出來的線程而不是每次都必須橋扒宴新創建線程此鏈，節省了一部分的開銷。
線程池也可以很方便的管理線程的大小和當前在執行的線程數量。
可以認為Executor是幫助自己管理Thread的一個前人幫自己封裝好的工具。敏銀
㈥ java executors有哪些方法
Java通過Executors提供四種線程池，分別為：
newCachedThreadPool創建一個可肢棚緩存線程池，如果線程池長睜飢余度超過處理需要，可靈活回收空閑線程，若無可回收，則新建線程。
newFixedThreadPool 創建一個定長線程池，可控制線程最大並發數，超出的線程會在隊列中等待。
newScheledThreadPool 創建一個定長線程池，支持定時及周期性任務執行。
newSingleThreadExecutor 創建一個單線程化的線程池，它只會用唯一的工作線程來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先順序)執行。
(1) newCachedThreadPool
創建一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閑線程，若無可回收，則新建線程。示例代碼如下：
Java代碼
packagetest;
importjava.util.concurrent.ExecutorService;
importjava.util.concurrent.Executors;
{
publicstaticvoidmain(String[]args){
悉滾=Executors.newCachedThreadPool();
for(inti=0;i<10;i++){
finalintindex=i;
try{
Thread.sleep(index*1000);
}catch(InterruptedExceptione){
e.printStackTrace();
}
cachedThreadPool.execute(newRunnable(){
publicvoidrun(){
System.out.println(index);
}
});
}
}
}
線程池為無限大，當執行第二個任務時第一個任務已經完成，會復用執行第一個任務的線程，而不用每次新建線程。
(2) newFixedThreadPool（項目用過）
創建一個定長線程池，可控制線程最大並發數，超出的線程會在隊列中等待。示例代碼如下：
Java代碼
packagetest;
importjava.util.concurrent.ExecutorService;
importjava.util.concurrent.Executors;
{
publicstaticvoidmain(String[]args){
=Executors.newFixedThreadPool(3);
for(inti=0;i<10;i++){
finalintindex=i;
fixedThreadPool.execute(newRunnable(){
publicvoidrun(){
try{
System.out.println(index);
Thread.sleep(2000);
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
});
}
}
}
因為線程池大小為3，每個任務輸出index後sleep 2秒，所以每兩秒列印3個數字。
定長線程池的大小最好根據系統資源進行設置。如Runtime.getRuntime().availableProcessors()
(3) newScheledThreadPool
創建一個定長線程池，支持定時及周期性任務執行。延遲執行示例代碼如下：
Java代碼
packagetest;
importjava.util.concurrent.Executors;
importjava.util.concurrent.ScheledExecutorService;
importjava.util.concurrent.TimeUnit;
{
publicstaticvoidmain(String[]args){
=Executors.newScheledThreadPool(5);
scheledThreadPool.schele(newRunnable(){
publicvoidrun(){
System.out.println("delay3seconds");
}
},3,TimeUnit.SECONDS);
}
}
表示延遲3秒執行。
定期執行示例代碼如下：
Java代碼
packagetest;
importjava.util.concurrent.Executors;
importjava.util.concurrent.ScheledExecutorService;
importjava.util.concurrent.TimeUnit;
{
publicstaticvoidmain(String[]args){
=Executors.newScheledThreadPool(5);
scheledThreadPool.scheleAtFixedRate(newRunnable(){
publicvoidrun(){
System.out.println("delay1seconds,andexcuteevery3seconds");
}
},1,3,TimeUnit.SECONDS);
}
}
表示延遲1秒後每3秒執行一次。
(4) newSingleThreadExecutor
創建一個單線程化的線程池，它只會用唯一的工作線程來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先順序)執行。示例代碼如下：
Java代碼
packagetest;
importjava.util.concurrent.ExecutorService;
importjava.util.concurrent.Executors;
{
publicstaticvoidmain(String[]args){
=Executors.newSingleThreadExecutor();
for(inti=0;i<10;i++){
finalintindex=i;
singleThreadExecutor.execute(newRunnable(){
publicvoidrun(){
try{
System.out.println(index);
Thread.sleep(2000);
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
});
}
}
}
結果依次輸出，相當於順序執行各個任務。
你可以使用JDK自帶的監控工具來監控我們創建的線程數量，運行一個不終止的線程，創建指定量的線程，來觀察：
工具目錄：C:Program FilesJavajdk1.6.0_06injconsole.exe
運行程序做稍微修改：
Java代碼
packagetest;
importjava.util.concurrent.ExecutorService;
importjava.util.concurrent.Executors;
{
publicstaticvoidmain(String[]args){
=Executors.newCachedThreadPool();
for(inti=0;i<100;i++){
finalintindex=i;
singleThreadExecutor.execute(newRunnable(){
publicvoidrun(){
try{
while(true){
System.out.println(index);
Thread.sleep(10*1000);
}
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
});
try{
Thread.sleep(500);
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
}
}
㈦ Java：Executor號稱將任務的提交與執行解耦，從何看出來的呢
1、提交後，任務是放到一個Executor內部隊列中的，Executor從這個隊列中獲取任務並執行。也就是說，它們之間是非同步的關系。提交的成功或數咐梁失敗，跟執行的成功或失敗，沒有關聯。
2、只要任務的對象簡襪是Runnable實現就薯運行了，提交時並不涉及其他額外參數，沒有耦合情況。
㈧ ExecutorService和TaskExecutor的區別和使用
ExecutorService 和 TaskExecutor 都是使用線程池來管理多線程非同步執行任務，他們有什麼關聯和區別，什麼時候該用哪個呢？
ExecutorService 屬於 java.util.concurrent 包下面的，繼承於 java.util.concurrent.Executor ，一般使用 java.util.concurrent.Executors 工廠類創建。 Executor 和 ExecutorService 都是 JDK 5 才提供的。
TaskExecutor 屬於 org.springframework.core.task 包下面，也是繼承與 java.util.concurrent.Executor
Java 1.7 引入了一種新的並發框架,主要用於實現「分而治之」的演算法，特別是分治之後遞歸調用的函數，例如 quick sort 等。
ForkJoinPool 最適合的是計算密集型的任務，如果存在 I/O，線程間同步，sleep() 等會造成線程長時間阻塞的情況時，最好配合使用 ManagedBlocker。
具體請移步至
用於延時扮稿陸或者定期執行的非同步任務/線程
提供線程廳頃池執行任務
ThreadPoolTaskExecutor 同樣是提供線程池執行任務，但是可以使用xml或者JavaBean的形式進行配置，初始化。同樣， ThreadPoolTaskExecutor 是使用 ThreadPoolExecutor 。即也是 ThreadPoolExecutor 的Spring包裝。
ThreadPoolTaskScheler 是 ScheledThreadPoolExecutor 一個spring形式的包裝。Spring中任務的調度使敬塵用的就是這個類，比如 @Scheled
spring的 TaskExecutor 的兩個常用實現類均是基於 Executor 實現類的包裝，使其更加方便使用，更好的融入spring bean生態。
關於線程池的創建，拒絕策略，任務的執行狀態，任務取消，等待任務完成等，網上資料很多了，將來有機會整理一下。
㈨ java的Executor類的性能，該怎麼處理
public interface Executor
執行已提交的 Runnable 任務的對象。此介面提供一種將任務提交與每個任務將如何運行的機制（包括線程使用的細節、調度等）分離開來的方法。通常使游螞用 Executor 而不是顯式地創建線程。例如，可能會使用以下方法，而不是為一組任務中的每個任務調用 new Thread(new(RunnableTask())).start()：
Executor executor = anExecutor;
executor.execute(new RunnableTask1());
executor.execute(new RunnableTask2());
...
不過，Executor 介面並沒有嚴格地要求執行是非同步的。在最簡單的情況下，執行程序可以在調用者的線程中立即運行已提交的任務：
class DirectExecutor implements Executor {
public void execute(Runnable r) {
r.run();
}
}
更常見的是，任務是在某個不是調用者線程的線程中執行的。以下執行程序將為每個任務生成一個新線程。
class ThreadPerTaskExecutor implements Executor {
public void execute(Runnable r) {
new Thread(r).start();
}
}
許多 Executor 實現都對調度任務的方式和時間強加了某種限制。以下執行程序使任務提交與第二個執行程序保持連續，這說明了一個復合執行程序。
class SerialExecutor implements Executor {
final Queue<Runnable> tasks = new ArrayDeque<Runnable>();
final Executor executor;
Runnable active;
SerialExecutor(Executor executor) {
this.executor = executor;
}
public synchronized void execute(final Runnable r) {
tasks.offer(new Runnable() {
public void run() {
try {
r.run();
} finally {
scheleNext();
}
}
});
if (active == null) {
scheleNext();
}
}
protected synchronized void scheleNext() {
if ((active = tasks.poll()) != null) {
executor.execute(active);
}
}
}
此包中提供的 Executor 實現實現了 ExecutorService，這是一個使用更廣泛的介面。ThreadPoolExecutor 類提供一個可擴展辯褲的線程池實現。Executors 類為這些 Executor 提供了便捷的工廠方法。
內存一致性效果：線程中將 Runnable 對象提交到 Executor 之前的操作 happen-before 其執攜磨簡行開始（可能在另一個線程中）。
從以下版本開始：
1.5
不知道樓主需要什麼樣的。。。。。。
㈩ java 線程池ThreadPoolExecutor 共同完成一個任務
線程池可以解決兩個不同問題：由於減少了每個任務調用的開銷，它們通常可以在執行大量非同步任務時提供增強的性能，並且還可以提供綁定和管理資源（包括執行集合任務時使用的線程）的方法。每個ThreadPoolExecutor 還維護著一些基本的統計數據，如完成的任務數。
為了便於跨大量上下文使用，此類提供了很多可調整的參數和擴展掛鉤。但是，強烈建議程序員使用較為方便的 Executors 工廠方法 Executors.newCachedThreadPool()（無界線程池，可以進行自動線程回收）、Executors.newFixedThreadPool(int)（固定大小線程池）和 Executors.newSingleThreadExecutor()（單個後台線程），它們均為大多數使用場景預定義了設置。否則，在手動配置和調整此類時，使用以下指導：
核心和最大池大小
ThreadPoolExecutor 將根據 corePoolSize（參見 getCorePoolSize()）和 maximumPoolSize（參見getMaximumPoolSize()）設置的邊界自動調整池大小。當新任務在方法 execute(java.lang.Runnable) 中提交時，如果運行的線程少於 corePoolSize，則創建新線程來處理請求，即使其他輔助線程是空閑的。如果運行的線程多於corePoolSize 而少於 maximumPoolSize，則僅當隊列滿時才創建新線程。如果設置的 corePoolSize 和 maximumPoolSize相同，則創建了固定大小的線程池。如果將 maximumPoolSize 設置為基本的無界值（如 Integer.MAX_VALUE），則允許池適應任意數量的並發任務。在大多數情況下，核心和最大池大小僅基於構造來設置，不過也可以使用setCorePoolSize(int) 和 setMaximumPoolSize(int) 進行動態更改。
按需構造
默認情況下，即使核心線程最初只是在新任務需要時才創建和啟動的，也可以使用方法 prestartCoreThread()或 prestartAllCoreThreads() 對其進行動態重寫。
創建新線程
使用 ThreadFactory 創建新線程。如果沒有另外說明，則在同一個 ThreadGroup 中一律使用Executors.defaultThreadFactory() 創建線程，並且這些線程具有相同的 NORM_PRIORITY 優先順序和非守護進程狀態。通過提供不同的 ThreadFactory，可以改變線程的名稱、線程組、優先順序、守護進程狀態，等等。如果從 newThread返回 null 時 ThreadFactory 未能創建線程，則執行程序將繼續運行，但不能執行任何任務。
保持活動時間
如果池中當前有多於 corePoolSize 的線程，則這些多出的線程在空閑時間超過 keepAliveTime 時將會終止（參見getKeepAliveTime(java.util.concurrent.TimeUnit)）。這提供了當池處於非活動狀態時減少資源消耗的方法。如果池後來變得更為活動，則可以創建新的線程。也可以使用方法 setKeepAliveTime(long, java.util.concurrent.TimeUnit) 動態地更改此參數。使用 Long.MAX_VALUE TimeUnit.NANOSECONDS 的值在關閉前有效地從以前的終止狀態禁用空閑線程。
排隊
所有 BlockingQueue 都可用於傳輸和保持提交的任務。可以使用此隊列與池大小進行交互：
A. 如果運行的線程少於 corePoolSize，則 Executor 始終首選添加新的線程，而不進行排隊。
B. 如果運行的線程等於或多於 corePoolSize，則 Executor 始終首選將請求加入隊列，而不添加新的線程。
C. 如果無法將請求加入隊列，則創建新的線程，除非創建此線程超出 maximumPoolSize，在這種情況下，任務將被拒絕。
排隊有三種通用策略：
直接提交。工作隊列的默認選項是 SynchronousQueue，它將任務直接提交給線程而不保持它們。在此，如果不存在可用於立即運行任務的線程，則試圖把任務加入隊列將失敗，因此會構造一個新的線程。此策略可以避免在處理可能具有內部依賴性的請求集合時出現鎖定。直接提交通常要求無界 maximumPoolSizes 以避免拒絕新提交的任務。當命令以超過隊列所能處理的平均數連續到達時，此策略允許無界線程具有增長的可能性。
無界隊列。使用無界隊列（例如，不具有預定義容量的 LinkedBlockingQueue）將導致在所有 corePoolSize 線程都忙的情況下將新任務加入隊列。這樣，創建的線程就不會超過 corePoolSize。（因此，maximumPoolSize 的值也就無效了。）當每個任務完全獨立於其他任務，即任務執行互不影響時，適合於使用無界隊列；例如，在 Web 頁伺服器中。這種排隊可用於處理瞬態突發請求，當命令以超過隊列所能處理的平均數連續到達時，此策略允許無界線程具有增長的可能性。
有界隊列。當使用有限的 maximumPoolSizes 時，有界隊列（如 ArrayBlockingQueue）有助於防止資源耗盡，但是可能較難調整和控制。隊列大小和最大池大小可能需要相互折衷：使用大型隊列和小型池可以最大限度地降低CPU 使用率、操作系統資源和上下文切換開銷，但是可能導致人工降低吞吐量。如果任務頻繁阻塞（例如，如果它們是 I/O 邊界），則系統可能為超過您許可的更多線程安排時間。使用小型隊列通常要求較大的池大小，CPU 使用率較高，但是可能遇到不可接受的調度開銷，這樣也會降低吞吐量。
被拒絕的任務
當 Executor 已經關閉，並且 Executor 將有限邊界用於最大線程和工作隊列容量，且已經飽和時，在方法execute(java.lang.Runnable) 中提交的新任務將被拒絕。在以上兩種情況下，execute 方法都將調用其RejectedExecutionHandler 的 RejectedExecutionHandler.rejectedExecution(java.lang.Runnable, java.util.concurrent.ThreadPoolExecutor) 方法。下面提供了四種預定義的處理程序策略：
A. 在默認的 ThreadPoolExecutor.AbortPolicy 中，處理程序遭到拒絕將拋出運行時 RejectedExecutionException。
B. 在 ThreadPoolExecutor.CallerRunsPolicy 中，線程調用運行該任務的 execute 本身。此策略提供簡單的反饋控制機制，能夠減緩新任務的提交速度。
C. 在 ThreadPoolExecutor.DiscardPolicy 中，不能執行的任務將被刪除。
D. 在 ThreadPoolExecutor.DiscardOldestPolicy 中，如果執行程序尚未關閉，則位於工作隊列頭部的任務將被刪除，然後重試執行程序（如果再次失敗，則重復此過程）。
定義和使用其他種類的 RejectedExecutionHandler 類也是可能的，但這樣做需要非常小心，尤其是當策略僅用於特定容量或排隊策略時。
掛鉤方法
此類提供 protected 可重寫的 beforeExecute(java.lang.Thread, java.lang.Runnable) 和 afterExecute(java.lang.Runnable, java.lang.Throwable) 方法，這兩種方法分別在執行每個任務之前和之後調用。它們可用於操縱執行環境；例如，重新初始化ThreadLocal、搜集統計信息或添加日誌條目。此外，還可以重寫方法 terminated() 來執行 Executor 完全終止後需要完成的所有特殊處理。
如果掛鉤或回調方法拋出異常，則內部輔助線程將依次失敗並突然終止。
隊列維護
方法 getQueue() 允許出於監控和調試目的而訪問工作隊列。強烈反對出於其他任何目的而使用此方法。remove(java.lang.Runnable) 和 purge() 這兩種方法可用於在取消大量已排隊任務時幫助進行存儲回收。
一、例子
創建 TestThreadPool 類：
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class TestThreadPool {
private static int proceTaskSleepTime = 2;
private static int proceTaskMaxNumber = 10;
public static void main(String[] args) {
// 構造一個線程池
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4, 3,
TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(3),
new ThreadPoolExecutor.DiscardOldestPolicy());
for (int i = 1; i <= proceTaskMaxNumber; i++) {
try {
String task = "task@ " + i;
System.out.println("創建任務並提交到線程池中：" + task);
threadPool.execute(new ThreadPoolTask(task));
Thread.sleep(proceTaskSleepTime);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
view plain
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class TestThreadPool {
private static int proceTaskSleepTime = 2;
private static int proceTaskMaxNumber = 10;
public static void main(String[] args) {
// 構造一個線程池
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4, 3,
TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(3),
new ThreadPoolExecutor.DiscardOldestPolicy());
for (int i = 1; i <= proceTaskMaxNumber; i++) {
try {
String task = "task@ " + i;
System.out.println("創建任務並提交到線程池中：" + task);
threadPool.execute(new ThreadPoolTask(task));
Thread.sleep(proceTaskSleepTime);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
創建 ThreadPoolTask類：
view plain to clipboardprint?
import java.io.Serializable;
public class ThreadPoolTask implements Runnable, Serializable {
private Object attachData;
ThreadPoolTask(Object tasks) {
this.attachData = tasks;
}
public void run() {
System.out.println("開始執行任務：" + attachData);
attachData = null;
}
public Object getTask() {
return this.attachData;
}
}
view plain
import java.io.Serializable;
public class ThreadPoolTask implements Runnable, Serializable {
private Object attachData;
ThreadPoolTask(Object tasks) {
this.attachData = tasks;
}
public void run() {
System.out.println("開始執行任務：" + attachData);
attachData = null;
}
public Object getTask() {
return this.attachData;
}
}
執行結果：
創建任務並提交到線程池中：task@ 1
開始執行任務：task@ 1
創建任務並提交到線程池中：task@ 2
開始執行任務：task@ 2
創建任務並提交到線程池中：task@ 3
創建任務並提交到線程池中：task@ 4
開始執行任務：task@ 3
創建任務並提交到線程池中：task@ 5
開始執行任務：task@ 4
創建任務並提交到線程池中：task@ 6
創建任務並提交到線程池中：task@ 7
創建任務並提交到線程池中：task@ 8
開始執行任務：task@ 5
開始執行任務：task@ 6
創建任務並提交到線程池中：task@ 9
開始執行任務：task@ 7
創建任務並提交到線程池中：task@ 10
開始執行任務：task@ 8
開始執行任務：task@ 9
開始執行任務：task@ 10
ThreadPoolExecutor配置
一、ThreadPoolExcutor為一些Executor提供了基本的實現，這些Executor是由Executors中的工廠 newCahceThreadPool、newFixedThreadPool和newScheledThreadExecutor返回的。 ThreadPoolExecutor是一個靈活的健壯的池實現，允許各種各樣的用戶定製。
二、線程的創建與銷毀
1、核心池大小、最大池大小和存活時間共同管理著線程的創建與銷毀。
2、核心池的大小是目標的大小；線程池的實現試圖維護池的大小；即使沒有任務執行，池的大小也等於核心池的大小，並直到工作隊列充滿前，池都不會創建更多的線程。如果當前池的大小超過了核心池的大小，線程池就會終止它。
3、最大池的大小是可同時活動的線程數的上限。
4、如果一個線程已經閑置的時間超過了存活時間，它將成為一個被回收的候選者。
5、newFixedThreadPool工廠為請求的池設置了核心池的大小和最大池的大小，而且池永遠不會超時
6、newCacheThreadPool工廠將最大池的大小設置為Integer.MAX_VALUE，核心池的大小設置為0，超時設置為一分鍾。這樣創建了無限擴大的線程池，會在需求量減少的情況下減少線程數量。
三、管理
1、 ThreadPoolExecutor允許你提供一個BlockingQueue來持有等待執行的任務。任務排隊有3種基本方法：無限隊列、有限隊列和同步移交。
2、 newFixedThreadPool和newSingleThreadExectuor默認使用的是一個無限的 LinkedBlockingQueue。如果所有的工作者線程都處於忙碌狀態，任務會在隊列中等候。如果任務持續快速到達，超過了它們被執行的速度，隊列也會無限制地增加。穩妥的策略是使用有限隊列，比如ArrayBlockingQueue或有限的LinkedBlockingQueue以及 PriorityBlockingQueue。
3、對於龐大或無限的池，可以使用SynchronousQueue，完全繞開隊列，直接將任務由生產者交給工作者線程
4、可以使用PriorityBlockingQueue通過優先順序安排任務