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执行完后，主线程才会执行。