『壹』 java創建線程池有哪些
ava通過Executors提供四種線程池，分別為：
newCachedThreadPool創建一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閑線程，若無可回收，則新建線程。
newFixedThreadPool
創建一個定長線程池，可控制線程最大並發數，超出的線程會在隊列中等待。
newScheledThreadPool
創建一個定長線程池，支持定時及周期性任務執行。
newSingleThreadExecutor
創建一個單線程化的線程池，它只會用唯一的工作線程來執行任務，保證所有任務按照指定順序(FIFO,
LIFO,
優先順序)執行。
『貳』 java開發中幾種常見的線程池
一：newCachedThreadPool
(1)緩存型池子，先查看池中有沒有以前建立的線程，如果有，就reuse，如果沒有，就建立一個新的線程加入池中；
(2)緩存型池子，通常用於執行一些生存周期很短的非同步型任務；因此一些面向連接的daemon型server中用得不多；
(3)能reuse的線程，必須是timeout
IDLE內的池中線程，預設timeout是60s,超過這個IDLE時長，線程實例將被終止及移出池。
(4)注意，放入CachedThreadPool的線程不必擔心其結束，超過TIMEOUT不活動，其會自動被終止
二：newFixedThreadPool
(1)newFixedThreadPool與cacheThreadPool差不多，也是能reuse就用，但不能隨時建新的線程
(2)其獨特之處:任意時間點，最多隻能有固定數目的活動線程存在，此時如果有新的線程要建立，只能放在另外的隊列中等待，直到當前的線程中某個線程終止直接被移出池子
(3)和cacheThreadPool不同，FixedThreadPool沒有IDLE機制（可能也有，但既然文檔沒提，肯定非常長，類似依賴上層的TCP或UDP
IDLE機制之類的），所以FixedThreadPool多數針對一些很穩定很固定的正規並發線程，多用於伺服器
(4)從方法的源代碼看，cache池和fixed
池調用的是同一個底層池，只不過參數不同:
fixed池線程數固定，並且是0秒IDLE（無IDLE）
cache池線程數支持0-Integer.MAX_VALUE(顯然完全沒考慮主機的資源承受能力），60秒IDLE
三：ScheledThreadPool
（1）調度型線程池
（2）這個池子里的線程可以按schele依次delay執行，或周期執行
四：SingleThreadExecutor
（1）單例線程，任意時間池中只能有一個線程
（2）用的是和cache池和fixed池相同的底層池，但線程數目是1-1,0秒IDLE（無IDLE）
『叄』 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而在處理請求時浪費時間，從而提高效率。
『肆』 我需要一個java線程池的例子，比如說我設置線程池最大線程數為20
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Test
{
public static void main(String[] args) throws InterruptedException
{
ExecutorService exe = Executors.newFixedThreadPool(5);
for (int i = 1; i <= 50; i++)
{
exe.execute(new SubThread(i));
}
System.out.println("shutdown");
exe.shutdown();
while (true)
{
if (exe.isTerminated())
{
System.out.println("結束了！");
break;
}
Thread.sleep(200);
}
}
}
public class SubThread extends Thread
{
private final int i;
public SubThread(int i)
{
this.i = i;
}
@Override
public void run()
{
System.out.println(i);
try
{
Thread.sleep(2000);
} catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
『伍』 詳談Java幾種線程池類型介紹及使用方法
線程池作用就是限制系統中執行線程的數量。
根據系統的環境情況，可以自動或手動設置線程數量，達到運行的最佳效果；少了浪費了系統資源，多了造成系統擁擠效率不高。用線程池控制線程數量，其他線程 排隊等候。一個任務執行完畢，再從隊列的中取最前面的任務開始執行。若隊列中沒有等待進程，線程池的這一資源處於等待。當一個新任務需要運行時，如果線程 池中有等待的工作線程，就可以開始運行了；否則進入等待隊列。
Java裡面線程池的頂級介面是Executor，但是嚴格意義上講Executor並不是一個線程池，而只是一個執行線程的工具。真正的線程池介面是ExecutorService。ThreadPoolExecutor是Executors類的底層實現。
『陸』 java如何寫一個線程池（線程池大小可定義為3），
packagecn.sdeit.servlet;
importjava.io.IOException;
importjava.io.PrintWriter;
importjava.sql.Connection;
importjava.sql.PreparedStatement;
importjava.sql.SQLException;
importjavax.servlet.ServletException;
importjavax.servlet.annotation.WebServlet;
importjavax.servlet.http.HttpServlet;
importjavax.servlet.http.HttpServletRequest;
importjavax.servlet.http.HttpServletResponse;
importcn.sdeit.beans.Team;
importcn.sdeit.beans.User;
importcn.sdeit.mysql.ConnectMySql;
/**
*
*/
@WebServlet(name="JoinTeam",urlPatterns={"/JoinTeam"})
{
=1L;
privateStringcaptainName=null;
privateStringteamName=null;
privatePrintWriterwriter=null;
/**
*@seeHttpServlet#HttpServlet()
*/
publicJoinTeam()
{
super();
}
protectedvoiddoGet(HttpServletRequestrequest,
HttpServletResponseresponse)throwsServletException,IOException
{
request.setCharacterEncoding("utf-8");
response.setCharacterEncoding("utf-8");
response.setContentType("text/html");
writer=response.getWriter();
captainName=request.getParameter("name");
teamName=request.getParameter("team");
if(teamName.equals((newTeam()).getTeamNameByCaptainName(captainName)))
{
intresult=joinTeam(((User)request.getSession().getAttribute("oldUser")).getEmail());
if(result==0)
{
showErrorMessage("抱歉！</br>伺服器內部錯誤，加入隊伍失敗！請及時反饋管理員！");
}
else
{
response.sendRedirect("mine.jsp");
}
}
else
{
showErrorMessage("抱歉！</br>沒有找到符合條件的團隊！請聯系您的隊長解決，若信息無誤，且問題一直出現，請聯系管理員！");
writer.flush();
writer.close();
}
}
privatevoidshowErrorMessage(Stringerror)
{
writer.write(error);
writer.flush();
writer.close();
}
privateintjoinTeam(Stringemail)
{
intposition=(newTeam()).getMinEmptyMemberPosition(teamName);
intresult=0;
if(position==-1)
{
showErrorMessage("抱歉！</br>此小組人數已達到上限，請更換隊伍或者協商隊長調整組員結構！");
}
else
{
Connectionconnection=ConnectMySql.createConnection();
Stringsql="updateteamsetmember"+position+""+"=?wherename=?";
PreparedStatementprepared=ConnectMySql.createPreparedStatement(connection,sql);
try
{
prepared.setString(1,email);
prepared.setString(2,teamName);
result=prepared.executeUpdate();
connection.close();
prepared.close();
}catch(SQLExceptione)
{
e.printStackTrace();
}
}
returnresult;
}
}
『柒』 什麼是java線程池
多線程是為了能夠讓計算機資源合理的分配，對於處理不同的任務創建不同的線程進行處理，但是計算機創建一個線程或者銷毀一個線程所花費的也是比較昂貴的，有時候需要同時處理的事情比較多，就需要我們頻繁的進行線程的創建和銷毀，這樣花費的時間也是比較多的。為了解決這一問題，我們就可以引用線程池的概念。
所謂線程池就是將線程集中管理起來，當需要線程的時候，可以從線程池中獲取空閑的線程，這樣可以減少線程的頻繁創建與銷毀，節省很大的時間和減少很多不必要的操作。
在java中提供了ThreadPoolExecutor類來進行線程的管理，這個類繼承於AbstractExecutorService，而AbstractExecutorService實現了ExecutorService介面，我們可以使用ThreadPoolExecutor來進行線程池的創建。
在ThreadPoolExecutor的構造方法中，有多個參數，可以配置不同的參數來進行優化。這個類的源碼構造方法為：
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)其中每個參數代表的意義分別為
corePoolSize : 線程池中的核心線程數量，當線程池中當前的線程數小於這個配置的時候，如果有一個新的任務到來，即使線程池中還存在空閑狀態的線程，程序也會繼續創建一個新的線程放進線程池當中
maximumPoolSize: 線程池中的線程最大數量
keepAliveTime：當線程池中的線程數量大於配置的核心線程數量(corePoolSize)的時候，如果當前有空閑的線程，則當這個空閑線程可以存在的時間，如果在keepAliveTime這個時間點內沒有新的任務使用這個線程，那麼這個線程將會結束,核心線程不會結束，但是如果配置了allowCoreThreadTimeOut = true，則當空閑時間超過keepAliveTime之後，線程也會被結束調，默認allowCoreThreadTimeOut = false，即表示默認情況下，核心線程會一直存在於線程池當中。
unit : 空閑線程保持連接時間(keepAliveTime)的時間單位
workQueue：阻塞的任務隊列，用來保存等待需要執行的任務。
threadFactory ：線程工廠，可以根據自己的需求去創建線程的對象，設置線程的名稱，優先順序等屬性信息。
handler：當線程池中存在的線程數超過設置的最大值之後，新的任務就會被拒絕，可以自己定義一個拒絕的策略，當新任務被拒絕之後，就會使用hander方法進行處理。
在java中也提供了Executors工具類，在這個工具類中提供了多個創建線程池的靜態方法，其中包含newCachedThreadPool、newFixedThreadPool、newScheledThreadPool、newSingleThreadExecutor等。但是他們每個方法都是創建了ThreadPoolExecutor對象，不同的是，每個對象的初始 參數值不一樣;
『捌』 java線程池（一） 簡述線程池的幾種使用方式
首先說明下java線程是如何實現線程重用的
1. 線程執行完一個Runnable的run()方法後，不會被殺死
2. 當線程被重用時，這個線程會進入新Runnable對象的run()方法12
java線程池由Executors提供的幾種靜態方法創建線程池。下面通過代碼片段簡單介紹下線程池的幾種實現方式。後續會針對每個實現方式做詳細的說明
newFixedThreadPool
創建一個固定大小的線程池
添加的任務達到線程池的容量之後開始加入任務隊列開始線程重用總共開啟線程個數跟指定容量相同。
@Test
public void newFixedThreadPool() throws Exception {
ExecutorService executorService = Executors.newFixedThreadPool(1);
executorService = Executors.newFixedThreadPool(1, new ThreadFactoryBuilder().build());
RunThread run1 = new RunThread("run 1");
executorService.execute(run1);
executorService.shutdown();
}12345678
newSingleThreadExecutor
僅支持單線程順序處理任務
@Test
public void newSingleThreadExecutor() throws Exception {
ExecutorService executorService = Executors.newSingleThreadExecutor();
executorService = Executors.newSingleThreadExecutor(new ThreadFactoryBuilder().build());
executorService.execute(new RunThread("run 1"));
executorService.execute(new RunThread("run 2"));
executorService.shutdown();
}123456789
newCachedThreadPool
這種情況跟第一種的方式類似，不同的是這種情況線程池容量上線是Integer.MAX_VALUE 並且線程池開啟緩存60s
@Test
public void newCachedThreadPool() throws Exception {
ExecutorService executorService = Executors.newCachedThreadPool();
executorService = Executors.newCachedThreadPool(new ThreadFactoryBuilder().build());
executorService.execute(new RunThread("run 1"));
executorService.execute(new RunThread("run 2"));
executorService.shutdown();
}123456789
newWorkStealingPool
支持給定的並行級別，並且可以使用多個隊列來減少爭用。
@Test
public void newWorkStealingPool() throws Exception {
ExecutorService executorService = Executors.newWorkStealingPool();
executorService = Executors.newWorkStealingPool(1);
RunThread run1 = new RunThread("run 1");
executorService.execute(run1);
executorService.shutdown();
}123456789
newScheledThreadPool
看到的現象和第一種相同，也是在線程池滿之前是新建線程，然後開始進入任務隊列，進行線程重用
支持定時周期執行任務(還沒有看完)
@Test
public void newScheledThreadPool() throws Exception {
ExecutorService executorService = Executors.newScheledThreadPool(1);
executorService = Executors.newScheledThreadPool(1, new ThreadFactoryBuilder().build());
executorService.execute(new RunThread("run 1"));
executorService.execute(new RunThread("run 2"));
executorService.shutdown();
}
『玖』 請教線程池解決方案： JAVA寫的線程池，及使用已有的線程池案例。
我這里也有一個相同的業務，想跟你說思路吧，首先controller類中創建一個線程池是必須的，我用的是ExecutorService es = Executors.newCachedThreadPool();當然你也可以創建一個固定量的線城池，然後創建上傳線程類，個人意見實現runnable介面(可以處理多繼承)，該線程類處理上傳流實例化；controller類中獲取提交的上傳的文件流傳給線程類，最後別忘記es.invokeAll(*);
如果不太明白，我可以把我的代碼貼上來你看看……
『拾』 Java線程池
線程池是一種多線程處理形式，處理過程中將任務添加隊列，然後在創建線程後自動啟動這些任務，每個線程都使用默認的堆棧大小，以默認的優先順序運行，並處在多線程單元中，如果某個線程在託管代碼中空閑，則線程池將插入另一個輔助線程來使所有處理器保持繁忙。如果所有線程池都始終保持繁忙，但隊列中包含掛起的工作，則線程池將在一段時間後輔助線程的數目永遠不會超過最大值。超過最大值的線程可以排隊，但他們要等到其他線程完成後才能啟動。
java裡面的線程池的頂級介面是Executor，Executor並不是一個線程池，而只是一個執行線程的工具，而真正的線程池是ExecutorService。
java中的有哪些線程池？
1.newCachedThreadPool創建一個可緩存線程池程
2.newFixedThreadPool 創建一個定長線程池
3.newScheledThreadPool 創建一個定長線程池
4.newSingleThreadExecutor 創建一個單線程化的線程池
————————————————