溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
這篇文章主要介紹“Java怎么用線程工廠來監控線程池”，在日常操作中，相信很多人在Java怎么用線程工廠來監控線程池問題上存在疑惑，小編查閱了各式資料，整理出簡單好用的操作方法，希望對大家解答”Java怎么用線程工廠來監控線程池”的疑惑有所幫助！接下來，請跟著小編一起來學習吧！
線程池中的線程從哪里來呢？就是ThreadFoctory
public interface ThreadFactory {
Thread newThread(Runnable r);
}Threadfactory里面有個接口，當線程池中需要創建線程就會調用該方法，也可以自定義線程工廠
public class ThreadfactoryText {
public static void main(String[] args) {
Runnable runnable=new Runnable() {
@Override
public void run() {
int num=new Random().nextInt(10);
System.out.println(Thread.currentThread().getId()+"--"+System.currentTimeMillis()+"--睡眠"+num);
try {
TimeUnit.SECONDS.sleep(num);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
//創建線程池 使用自定義線程工廠 采用默認的拒絕策略
ExecutorService executorService=new ThreadPoolExecutor(5, 5, 0, TimeUnit.SECONDS, new SynchronousQueue<>(), new ThreadFactory() {
@Override
public Thread newThread(Runnable r) {
Thread t=new Thread(r);
t.setDaemon(true);//設置為守護線程，當主線程運行結束，線程池中線程也會被釋放
System.out.println("創建了線程"+t);
return t;
}
});
//提交五個任務
for (int i = 0; i < 5; i++) {
executorService.submit(runnable);
}
}
}
當線程提交超過五個任務時，線程池會默認拋出異常
ThreadPoolExcutor提供了一組方法用于監控線程池
int getActiveCount()//獲得線程池只當前的獲得線程數量
long getCompletedTaskCount()//返回線程池完成任務數量
int getCorePoolSize()//線程池中核心任務數量
int getLargestPoolSize() //返回線程池中曾經達到線程的最大數
int getMaximumPoolSize()//返回線程池的最大容量
int getPoolSize()//返回線程大小
BlockingQueue<Runnable> getQueue()//返回阻塞隊列
long getTaskCount()//返回線程池收到任務總數public class Text {
public static void main(String[] args) throws InterruptedException {
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getId() + "線程開始執行--" + System.currentTimeMillis());
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
//創建線程池 使用默認線程工廠 有界隊列 采用DiscardPolicy策略
ThreadPoolExecutor executorService = new ThreadPoolExecutor(2, 5, 0, TimeUnit.SECONDS, new ArrayBlockingQueue<>(5),Executors.defaultThreadFactory(),new ThreadPoolExecutor.DiscardPolicy());
//提交五個任務
for (int i = 0; i < 30; i++) {
executorService.submit(runnable);
System.out.println("當前線程核心線程數"+executorService.getCorePoolSize()+",最大線程數："+executorService.getMaximumPoolSize()+",當前線程池大小："+executorService.getPoolSize()+"活動線程數："+executorService.getActiveCount()+",收到任務："+executorService.getTaskCount()+"完成任務數："+executorService.getCompletedTaskCount()+"等待任務數："+executorService.getQueue().size());
TimeUnit.MILLISECONDS.sleep(500);
}
System.out.println("-------------------");
while (executorService.getActiveCount()>=0)//繼續對線程池進行檢測
{
System.out.println("當前線程核心線程數"+executorService.getCorePoolSize()+",最大線程數："+executorService.getMaximumPoolSize()+",當前線程池大小："+executorService.getPoolSize()+"活動線程數："+executorService.getActiveCount()+",收到任務："+executorService.getTaskCount()+"完成任務數："+executorService.getCompletedTaskCount()+"等待任務數："+executorService.getQueue().size());
Thread.sleep(1000);//每1秒檢測一次
}
}
}當線程池大小達到了核心線程數，線程會被放在等待隊列。當線程池等待隊列已滿會開啟新的線程。當當前線程大小達到最大線程數，等待隊列也滿了，再提交的話會執行DiscardPolicy策略，直接丟棄這個無法處理的任務，最后30個任務只剩下15個了。
原理如圖：
有時候需要對線程池進行擴展，如在監控每個任務開始和結束時間，或者自定義其他增強功能。
ThreadPoolExecutor線程池提供了兩個方法：
protected void beforeExecute(Thread t, Runnable r) { }
protected void afterExecute(Runnable r, Throwable t) { }線程池執行某個任務前會執行beforeExecute()方法，執行后會調用afterExecute()方法
查看ThreadPoolExecutor源碼，在該類中定義了一個內部類Worker，ThreadPoolExecutor線程池的工作線程就是Worker類的實例，Worker實例在執行時會調用beforeExecute與afterExecute方法。
public void run() {
runWorker(this);
}
final void runWorker(Worker w) {
try {
beforeExecute(wt, task);
try {
task.run();
afterExecute(task, null);
} catch (Throwable ex) {
afterExecute(task, ex);
throw ex;
}
} finally {
task = null;
w.completedTasks++;
w.unlock();
}
}
}部分代碼已省略，線程執行前會調用beforeExecute，執行后會調用afterExecute方法。
package com;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class Text07 {
public static void main(String[] args) {
//定義擴展線程池 定義線程池類繼承ThreadPoolExecutor，然后重寫其他方法
ExecutorService threadPoolExecutor=
new ThreadPoolExecutor(5,5,0, TimeUnit.SECONDS,new LinkedBlockingDeque<>()){
//在內部類重寫開始方法
@Override
protected void beforeExecute(Thread t, Runnable r) {
System.out.println(t.getId()+"線程準備執行任務"+((Mytask)r).name);
}
//在內部類重寫結束方法
@Override
protected void afterExecute(Runnable r, Throwable t) {
System.out.println(((Mytask)r).name+"執行完成");
}
//線程池退出
@Override
protected void terminated() {
System.out.println("線程池退出");
}
};
for (int i = 0; i < 5; i++) {
Mytask mytask=new Mytask("Thread"+i);
threadPoolExecutor.execute(mytask);
}
}
private static class Mytask implements Runnable
{
private String name;
public Mytask(String name)
{
this.name=name;
}
@Override
public void run() {
System.out.println(name+"正在被執行"+Thread.currentThread().getId());
try {
Thread.sleep(1000);//模擬任務時長
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
線程池大小對系統性能有一定影響，過大或者過小都無法方法發揮系統最佳性能，不需要非常精確，只要避免極大或者極小就可以了，一般來說線程池大小大姚考慮CPU數量
線程池大小=CPU數量 * 目標CPU使用率*（1+等待時間與計算時間的比）
如果線程池執行中，任務A在執行過程中提交了任務B，任務B添加到線程池中的等待隊列，如果A的結束需要B的執行結果，而B線程需要等待A線程執行完畢，就可能會使其他所有工作線程都處于等待狀態，待這些任務在阻塞隊列中執行。線程池中沒有可以對阻塞隊列進行處理的線程，就會一直等待下去照成死鎖。
適合給線程池提交相互獨立的任務，而不是彼此依賴的任務，對于彼此依賴的任務，可以考慮分別提交給不同的線程池來處理。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class Text09 {
public static void main(String[] args) {
//創建線程池
ExecutorService executorService=new ThreadPoolExecutor(5,5,0, TimeUnit.SECONDS,new SynchronousQueue<>());
//向線程池中添加兩個數相處計算的任務
for (int i = 0; i <5 ; i++) {
executorService.submit(new Text(10,i));
}
}
private static class Text implements Runnable
{
private int x;
private int y;
public Text(int x,int y)
{
this.x=x;
this.y=y;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"線程x/y結果的為"+x+"/"+y+"="+(x/y));
}
}
}
可以看到只有四條結果，實際向線程池提交了五個任務，但是當i==0時，產生了算術異常，線程池把該異常吃掉了，導致我們對該異常一無所知
解決辦法：
1.把submit改為execute
2.對線程池進行擴展，對submit進行包裝
package com;
import java.util.concurrent.*;
public class Text09 {
public static void main(String[] args) {
//創建線程池 使用自定義的線程池
ExecutorService executorService=new TranceThreadPoorExcuter(5,5,0, TimeUnit.SECONDS,new SynchronousQueue<>());
//向線程池中添加兩個數相處計算的任務
for (int i = 0; i <5 ; i++) {
executorService.submit(new Text(10,i));
}
}
public static class Text implements Runnable
{
public int x;
public int y;
public Text(int x,int y)
{
this.x=x;
this.y=y;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"線程x/y結果的為"+x+"/"+y+"="+(x/y));
}
}
//自定義線程池類 對TranceThreadPoorExcuter進行擴展
private static class TranceThreadPoorExcuter extends ThreadPoolExecutor
{
public TranceThreadPoorExcuter(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
}
//定義一個方法用于傳入兩個參數 第一個是要接受的任務 第二個是Exception
public Runnable warp(Runnable r,Exception e)
{
return new Runnable() {
@Override
public void run() {
try {
r.run();
}
catch (Exception e1)
{
e.printStackTrace();
throw e1;
}
}
};
}
//重寫submit方法
@Override
public Future<?> submit(Runnable task) {
return super.submit(warp(task,new Exception("客戶跟蹤異常")));
}
//還可以重寫excute方法
}
}此方法使用了自定義的線程池，重寫線程池中的submit方法，在submit方法中，把要傳入的任務參數帶一個捕獲異常信息的功能就可以捕獲線程池異常。
到此，關于“Java怎么用線程工廠來監控線程池”的學習就結束了，希望能夠解決大家的疑惑。理論與實踐的搭配能更好的幫助大家學習，快去試試吧！若想繼續學習更多相關知識，請繼續關注億速云網站，小編會繼續努力為大家帶來更多實用的文章！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
