㈠ 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，