㈠ java線程執行完後自己結束嗎
線程一啟用成功,就會自動關閉線程句柄.
但是,如果線程中有死循環.線程是不會運行完就結束的.
因為未跳出子程序.所以結束不了線程.反之,跳出子程序了就說明自動結束了線程.
死循環子程序的解決方法.可以用強制結束線程 ()或用變數來結束線程.
㈡ java並發編程學習：如何等待多個線程執行完成
實現方式多種多樣，下面列兩種供參考：
importjava.util.ArrayList;
importjava.util.List;
importjava.util.concurrent.*;
publicclassMain{
publicstaticvoidmain(String[]args)throwsInterruptedException,ExecutionException{
System.out.println("方式1");
System.out.println("================================================");
//方式1
//創建一個線程池，並創建10個線程放入線程池執行
ExecutorServicepool=Executors.newCachedThreadPool();
for(inti=0;i<10;i++){
pool.execute(newMyThread("線程"+i));
}
//線程池不再接收新任務
pool.shutdown();
//線程池中的所有線程都執行完pool.isTerminated()才返回true
while(!pool.isTerminated()){
Thread.sleep(100);
}
System.out.println("所有線程執行完成");
System.out.println(" 方式2");
System.out.println("================================================");
//方式2
ExecutorServicepool2=Executors.newCachedThreadPool();
List<Future>futures=newArrayList<>();
for(inti=0;i<10;i++){
//使用實現Callable介面的方式創建線程，通過Future可以獲取線程中返回的結果
Futurefuture=pool2.submit(newMyThread2("線程"+i));
futures.add(future);
}
for(Futurefuture:futures){
//該方法會阻塞主線程，直到線程執行完成
future.get();
}
System.out.println("所有線程執行完成");
}
}
classMyThreadextendsThread{
privateStringname;
publicMyThread(Stringname){
this.name=name;
}
@Override
publicvoidrun(){
try{
Thread.sleep(3000);
}catch(InterruptedExceptione){
e.printStackTrace();
}
System.out.println(name+"執行完成");
}
}
{
privateStringname;
publicMyThread2(Stringname){
this.name=name;
}
@Override
publicObjectcall()throwsException{
try{
Thread.sleep(3000);
}catch(InterruptedExceptione){
e.printStackTrace();
}
System.out.println(name+"執行完成");
returnnull;
}
}
㈢ 怎麼知道java多線程都已經運行結束
一、使用java.util.concurrent.CountDownLatch
Java的util.concurrent包裡面的CountDownLatch其實可以把它看作一個計數器，只不過這個計數器的操作是原子操作，同時只能有一個線程去操作這個計數器，也就是同時只能有一個線程去減這個計數器裡面的值。
你可以向CountDownLatch對象設置一個初始的數字作為計數值，任何調用這個對象上的await()方法都會阻塞，直到這個計數器的計數值被其他的線程減為0為止。
CountDownLatch的一個非常典型的應用場景是：有一個任務想要往下執行，但必須要等到其他的任務執行完畢後才可以繼續往下執行。假如我們這
個想要繼續往下執行的任務調用一個CountDownLatch對象的await()方法，其他的任務執行完自己的任務後調用同一個
CountDownLatch對象上的countDown()方法，這個調用await()方法的任務將一直阻塞等待，直到這個
CountDownLatch對象的計數值減到0為止。
舉個例子，有三個工人在為老闆幹活，這個老闆有一個習慣，就是當三個工人把一天的活都
幹完了的時候，他就來檢查所有工人所乾的活。記住這個條件：三個工人先全部幹完活，老闆才檢查。所以在這里用Java代碼設計兩個類，Worker代表工
人，Boss代表老闆，具體的代碼實現如下：
Worker類（單獨的線程）：
package cn.e.bupt.thread.threadnotify;
import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
public class Worker implements Runnable
{
private CountDownLatch downLatch;
private String name;
public Worker(CountDownLatch downLatch, String name)
{
this.downLatch = downLatch;
this.name = name;
}
@Override
public void run()
{
this.doWork();
try
{
TimeUnit.SECONDS.sleep(new Random().nextInt(10));
}
catch (InterruptedException ie)
{
}
System.out.println(this.name + "活幹完了！");
this.downLatch.countDown();
}
private void doWork()
{
System.out.println(this.name + "正在幹活...");
}
}
Boss類（單獨的線程）：
package cn.e.bupt.thread.threadnotify;
import java.util.concurrent.CountDownLatch;
public class Boss implements Runnable
{
private CountDownLatch downLatch;
public Boss(CountDownLatch downLatch)
{
this.downLatch = downLatch;
}
@Override
public void run()
{
System.out.println("老闆正在等所有的工人幹完活......");
try
{
this.downLatch.await();
}
catch (InterruptedException e)
{
}
System.out.println("工人活都幹完了，老闆開始檢查了！");
}
}
Main：
package cn.e.bupt.thread.threadnotify;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class CountDownLatchDemo
{
public static void main(String[] args)
{
ExecutorService executor = Executors.newCachedThreadPool();
CountDownLatch latch = new CountDownLatch(3);
Worker w1 = new Worker(latch, "張三");
Worker w2 = new Worker(latch, "李四");
Worker w3 = new Worker(latch, "王二");
Boss boss = new Boss(latch);
executor.execute(boss);
executor.execute(w3);
executor.execute(w2);
executor.execute(w1);
executor.shutdown();
}
}
上例中的的ExecutorService介面和Executors類的作用類似於new Thread(Runnable r).start()的作用，就是啟動一個新的線程。
㈣ java線程執行完後自己結束嗎
其實最佳答案的說法是有問題的，如果題主指的結束，是指方法塊語句的執行結束的話，熱心網友的說法是對的。但是對於線程本身，所有線程（包括主線程）在啟動後都被CPU參照優先順序交替調用，運行的順序是無法預測的，但最後結束的一定是主線程。
網上有部分說法，展示的代碼運行結果，「主線程先於其他線程結束，並不影響其他線程的運行」只有後半部分是對的。因為方法體（不管是自定義線程的run()還是主線程的main()）中全部語句的執行完畢不代表所在線程的結束，可以用activeCount()返回當前運行的匯流排程數來驗證這一點。另外，如果將自定義的線程對象設定為守護線程（setDeamon()）,也可以很清楚看到即便main()方法中最後一句輸出語句執行完畢，控制台仍會根據該自定義線程run()方法體的內容繼續輸出，這證明主線程還沒結束——因為當線程組中只剩下守護線程時，JVM虛擬機會自動退出，如果主線程已經結束，唯一活動的線程在被設置成守護線程的情況下，程序會直接結束運行，不可能繼續輸出。
㈤ Java如何判斷線程池中所有任務執行完畢
Java 如何判斷線程池所有任務是否執行完
shutdown
void shutdown()
啟動一次順序關閉，執行以前提交的任務，但不接受新任務。如果已經關閉，則調用沒有其他作用。
拋出：
SecurityException - 如果安全管理器存在並且關閉，此 ExecutorService 可能操作某些不允許調用者修改的線程（因為它沒有保持RuntimePermission("modifyThread")），或者安全管理器的 checkAccess 方法拒絕訪問。
isTerminated
boolean isTerminated()
如果關閉後所有任務都已完成，則返回 true。注意，除非首先調用 shutdown 或 shutdownNow，否則 isTerminated 永不為 true。
返回：
如果關閉後所有任務都已完成，則返回 true
/**
[java] view plain
* 採用線程池開啟多個子線程，主線程等待所有的子線程執行完畢
*/
public static void moreThread() {
try {
int threadNum = 0;
for (int i = 0; i < 10; i++) {
threadNum++;
final int currentThreadNum = threadNum;
exe.execute(new Runnable() {
@Override
public void run() {
try {
System.out.println("子線程[" + currentThreadNum + "]開啟");
Thread.sleep(1000*10);
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
System.out.println("子線程[" + currentThreadNum + "]結束");
}
}
});
}
System.out.println("已經開啟所有的子線程");
exe.shutdown();
System.out.println("shutdown()：啟動一次順序關閉，執行以前提交的任務，但不接受新任務。");
while(true){
if(exe.isTerminated()){
System.out.println("所有的子線程都結束了！");
break;
}
Thread.sleep(1000);
}
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
System.out.println("主線程結束");
}
}
[java] view plain
子線程[1]開啟
子線程[6]開啟
子線程[2]開啟
子線程[5]開啟
子線程[9]開啟
已經開啟所有的子線程
子線程[3]開啟
子線程[7]開啟
子線程[10]開啟
shutdown()：啟動一次順序關閉，執行以前提交的任務，但不接受新任務。
子線程[4]開啟
子線程[8]開啟
子線程[6]結束
子線程[3]結束
子線程[7]結束
子線程[2]結束
子線程[1]結束
子線程[5]結束
子線程[9]結束
子線程[4]結束
子線程[10]結束
子線程[8]結束
所有的子線程都結束了！
主線程結束
㈥ java,線程問題，怎麼判斷線程是否結束啊
通過Thread類中的isAlive()方法判斷線程是否處於活動狀態；
線程啟動後，只要沒有運行完畢，都會返回true；
㈦ java線程執行完後自己結束嗎
其實最佳答案的說法是有問題的，如果題主指的結束，是指方法塊語句的執行結束的話，熱心網友的說法是對的。但是對於線程本身，所有線程（包括主線程）在啟動後都被CPU參照優先順序交替調用，運行的順序是無法預測的，但最後結束的一定是主線程。
網上有部分說法，展示的代碼運行結果，「主線程先於其他線程結束，並不影響其他線程的運行」只有後半部分是對的。因為方法體（不管是自定義線程的run()還是主線程的main()）中全部語句的執行完畢不代表所在線程的結束，可以用activeCount()返回當前運行的匯流排程數來驗證這一點。另外，如果將自定義的線程對象設定為守護線程（setDeamon()）,也可以很清楚看到即便main()方法中最後一句輸出語句執行完畢，控制台仍會根據該自定義線程run()方法體的內容繼續輸出，這證明主線程還沒結束——因為當線程組中只剩下守護線程時，JVM虛擬機會自動退出，如果主線程已經結束，唯一活動的線程在被設置成守護線程的情況下，程序會直接結束運行，不可能繼續輸出。
㈧ Java 如何判斷線程池所有任務是否執行完畢
可以在線程池類中定義 存儲空閑 線程的集合（初始化時所有線程默認都為空閑），每新起一個線程就對這個集合操作一次 減少一個空閑線程。匯流排程數-空閑線程數=0 即所有線程池任務都執行完成了。（記住 每次線程任務執行完了 回收的時候 記得把線程加入到空閑 線程集合中，避免統計數量的時候 不準確）。或者在開始定義一個 工作中的 線程集合，每新增一個 線程就往集合中加一個，每釋放一個 就減一個，意思相同。
㈨ java如何在多線程執行完成後再執行某個方法
java.util.concurrent.CountDownLatch 這個類可以實現你所要的功能
例如：CountDownLatch latch = new CountDownLatch(5) //聲明計數器為5個
Thread t = new Thread() {
public void run() {
try {
//TODO 你的應用
} catch (Exception e) {
//TODO 異常處理
}
finally {
latch.countDown(); //這句是關鍵
System.out.println("ok"); //5個線程都跑完後輸出
}
}
};
t.start();
然後讓以上操作循環五次(就是說同時開5個線程)，那麼這個"ok"就會在等到這5個線程都ok後才會被輸出一次。
㈩ java 如何判斷一個線程結束
線程結束時等待也就結束了
------解決方案--------------------------------------------------------
waitforsingleobject當然可以。
或者設一全局變數，線程結束就將其置為某值。在別處讀取該值，就可以判斷線程是否結束了。
------解決方案--------------------------------------------------------
wait_object_0
表示這個線程已經退出了，wait_timeout是這個線程在此函數返回時候還沒退出，但是設置的等待時間已經到了，wait_abandoned是所等待的對象是mutex而非thread，