1. java多線程中，怎樣知道線程執行結束
在你的主線程中用一個join的方法，你要等待誰，就用誰調用，比如，你要等待線程a結束，就用a.join();這樣就可以了。記住哦，這條語句寫在哪個線程里，哪個線程就要等待調用這個方法的其他線程。就是說，你在主線程里寫了這條語句，那麼主線程就要等待線程a執行完後，主線程才會執行。
2. java中請問如何等待一個線程結束在運行其他的代碼
使用java的線程同步機制。
現在存在兩個線程a和b，偽代碼如下：
在a的代碼中：
b.start();//啟動b線程
synchronized(b) b.wait();//a線程中採用同步，並進行等待
c.execute();
在b線程結束時調用synchronized(this) notify();
這樣就可以達到b不結束，a線程就不會繼續執行c。
注釋：如果看不明白建議先學習一下java線程同步機制。
3. java如何等待方法內一個線程執行完畢
thread.Join把指定的線程加入到當前線程，可以將兩個交替執行的線程合並為順序執行的線程。比如在線程B中調用了線程A的Join()方法，直到線程A執行完畢後，才會繼續執行線程B。
4. 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後才會被輸出一次。
5. java 如何實現等待子線程結束
有多種實現方式，下面列出兩種。
第一種：實現Callable類，使用有返回值的線程，只有線程執行完成後才會返回結果。
importjava.util.ArrayList;
importjava.util.List;
importjava.util.Random;
importjava.util.concurrent.*;
publicclassMain{
//初始化一個容量為10的線程池
=Executors.newFixedThreadPool(10);
publicstaticvoidmain(String[]args)throwsExecutionException,InterruptedException{
List<Future<String>>futures=newArrayList<>();
for(inti=0;i<3;i++){
MyThreadthread=newMyThread("線程"+i);
futures.add(pool.submit(thread));
}
for(Future<String>future:futures){
Stringname=future.get();
System.out.println(name+"執行完成...");
}
System.out.println("所有線程執行完成!");
}
}
<String>{
privateStringname;
publicMyThread(Stringname){
this.name=name;
}
@Override
publicStringcall()throwsException{
//TODO執行業務
//隨機延遲，模擬線程耗時
Thread.sleep(1000+newRandom().nextInt(2000));
returnname;
}
}
第二種：使用CountDownLatch實現線程計數，代碼如下：
importjava.util.Random;
importjava.util.concurrent.CountDownLatch;
importjava.util.concurrent.ExecutionException;
importjava.util.concurrent.ExecutorService;
importjava.util.concurrent.Executors;
publicclassMain2{
//初始化一個容量為10的線程池
=Executors.newFixedThreadPool(10);
publicstaticvoidmain(String[]args)throwsInterruptedException{
intthreadCount=3;
//初始化CountDownLatch，用於線程計數
CountDownLatchlatch=newCountDownLatch(threadCount);
for(inti=0;i<threadCount;i++){
MyThreadthread=newMyThread("線程"+i,latch);
pool.execute(thread);
}
//阻塞當前線程，CountDownLatch計數減為0時表示所有線程都執行完畢，才會釋放主線程的阻塞
latch.await();
System.out.println("所有線程執行完成!");
}
}
{
privateStringname;
privateCountDownLatchlatch;
publicMyThread(Stringname,CountDownLatchlatch){
this.name=name;
this.latch=latch;
}
@Override
publicvoidrun(){
//TODO執行業務
//隨機延遲，模擬線程耗時
try{
Thread.sleep(1000+newRandom().nextInt(2000));
}catch(InterruptedExceptione){
}
//計數減一
latch.countDown();
System.out.println(name+"執行完畢...");
}
}
6. Java如何等待子線程執行結束
先調用
shutdown
在調用
isTerminated
例：
/*
* 採用線程池開啟多個子線程，主線程等待所有的子線程執行完畢
*/
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("主線程結束");
}
}
7. Java線程的幾種狀態
線程是一個動態執行的過程，它有一個從產生到死亡的過程，共五種狀態：
1、新建（new Thread）
當創建Thread類的一個實例（對象）時，此線程進入新建狀態（未被啟動）
例如：Thread t1=new Thread();
2、就緒（runnable）
線程已經被啟動，正在等待被分配給CPU時間片，也就是說此時線程正在就緒隊列中排隊等候得到CPU資源。例如：t1.start();
3、運行（running）
線程獲得CPU資源正在執行任務（run()方法），此時除非此線程自動放棄CPU資源或者有優先順序更高的線程進入，線程將一直運行到結束。
4、堵塞（blocked）
由於某種原因導致正在運行的線程讓出CPU並暫停自己的執行，即進入堵塞狀態。
正在睡眠：用sleep(long t) 方法可使線程進入睡眠方式。一個睡眠著的線程在指定的時間過去可進入就緒狀態。
正在等待：調用wait()方法。（調用notify()方法回到就緒狀態）
被另一個線程所阻塞：調用suspend()方法。（調用resume()方法恢復）
5、死亡（dead）
當線程執行完畢或被其它線程殺死，線程就進入死亡狀態，這時線程不可能再進入就緒狀態等待執行。
自然終止：正常運行run()方法後終止
異常終止：調用stop()方法讓一個線程終止運行
8. java 如何判斷一個線程結束
線程結束時等待也就結束了
------解決方案--------------------------------------------------------
waitforsingleobject當然可以。
或者設一全局變數，線程結束就將其置為某值。在別處讀取該值，就可以判斷線程是否結束了。
------解決方案--------------------------------------------------------
wait_object_0
表示這個線程已經退出了，wait_timeout是這個線程在此函數返回時候還沒退出，但是設置的等待時間已經到了，wait_abandoned是所等待的對象是mutex而非thread，
9. 如何在JAVA中讓一個線程死亡或結束
當線程執行完畢或被其它線程殺死，線程就進入死亡狀態，這時線程不可能再進入就緒狀態等待執行。
線程進入死亡狀態的方法有兩種：
1、自然終止：正常運行run()方法後終止；
2、異常終止：調用stop()方法讓一個線程終止運行。
如下代碼：
public class ThreadDemo implements Runnable{
public void run() {
}
}
當run方法執行結束，即線程死亡（結束）。
10. java 中怎樣實現主線程等待其他線程執行完畢！！
在你的主線程中用一個JOIN的方法，你要等待誰，就用誰調用，比如，你要等待線程A結束，就用A.JOIN();這樣就可以了。記住哦，這條語句寫在哪個線程里，哪個線程就要等待調用這個方法的其他線程。就是說，你在主線程里寫了這條語句，那麼主線程就要等待線程A執行完後，主線程才會執行。