多线程是java中很重要的知识点，在此小编给大家总结Java Thread多线程，非常有用，希望大家可以掌握哦。
方法一 thread.sleep
方法二 ExecutorService
方法三 thread.join
方法四 Thread.yield and Thread.activeCount
写代码过程中遇到了这样的场景, 需要观察各个子线程运行的情况, 如果不进行任何处理当main 方法运行完毕后其他子线程都会关闭, 无法观察到所有子线程的详细的运行情况, 于是需要让主线程等待所有子线程运行完毕后才关闭, 以前比较马虎的做法就是在main 函数里面添加Thread.sleep(time) 但是这种方法始终不完美, 因为需要人为的设置等待时间, 不是最佳的实践, 于是查阅了一些资料以及博客, 此处总结一下实现这个目的的四种方法.
方法一 thread.sleep
这应该是最常见的方法, 虽然不是最佳的实践, 但是可以勉强满足需求.
public static void main(String[] args) throws InterruptedException{ for(int i=0; i<10; i++){ new Thread("subthread" + i){
@Override public void run() { try {
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + "finished");
}catch(InterruptedException e){
e.printStackTrace();
}
}
}.start();
}
Thread.sleep(2000);
System.out.println("main thread finished");
}运行结果:
subthread0finished subthread1finished subthread2finished subthread6finished subthread4finished subthread5finished subthread3finished subthread9finished subthread8finished subthread7finished main thread finished
方法二 ExecutorService
可以使用线程池实现, 常用的线程池对象都是ExecutorService 接口的实现, 其中提供了shutdown 等方法可以保证当前提交的任务在子线程上运行完毕后 Java进程正常退出.
public static void main(String[] args) { // 创建一个ExecutorService
ExecutorService ex = Executors.newCachedThreadPool(); for(int i=0; i<10; i++){ // 添加 task
ex.submit(new Thread("subthread" + i){
@Override public void run() { try{
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + "finished");
}catch(InterruptedException e){
e.printStackTrace();
}
}
});
} // 使用shutdown 会通知executorservice 停止添加其它task 它会等待所有子线程运行结束才退出Java进程
ex.shutdown();
System.out.println("main thread finished");
}运行结果为:
main thread finished pool-1-thread-3finished pool-1-thread-4finished pool-1-thread-2finished pool-1-thread-1finished pool-1-thread-5finished pool-1-thread-7finished pool-1-thread-8finished pool-1-thread-6finished pool-1-thread-9finished pool-1-thread-10finished
此种方法有一些小的瑕疵, 我们从输出的信息可以看到主线程其实先于子线程运行完毕, 所以这种方法只能够保证子线程在程序退出之前可以运行完, 但是不能够保证主线程在子线程运行完毕之后再执行.所以代码还需要更改, 添加一个awaitTermination(time, timeunit) 设置一个较为合理的等待的时间, 等待子线程运行完毕.
public static void main(String[] args) { // 创建一个ExecutorService
ExecutorService ex = Executors.newCachedThreadPool(); for(int i=0; i<10; i++){ // 添加 task
ex.submit(new Thread("subthread" + i){
@Override public void run() { try{
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + "finished");
}catch(InterruptedException e){
e.printStackTrace();
}
}
});
} // 使用shutdown 会通知executorservice 停止添加其它task 它会等待所有子线程运行结束才退出Java进程
ex.shutdown(); try { // 设置等待时间等待子线程运行完毕
if(!ex.awaitTermination(2000, TimeUnit.MILLISECONDS)){ // 等待时间内子线程并未全部运行完毕就直接关闭
ex.shutdownNow();
}
}catch(InterruptedException e){
ex.shutdownNow();
}
System.out.println("main thread finished");
}运行结果:
pool-1-thread-1finished pool-1-thread-5finished pool-1-thread-4finished pool-1-thread-9finished pool-1-thread-8finished pool-1-thread-3finished pool-1-thread-2finished pool-1-thread-7finished pool-1-thread-6finished pool-1-thread-10finished main thread finished
可以看到主线程执行的内容在最后输出的. 这个方法与方法一一样都需要设置等待时间, 不是很完美的方法.
方法三 thread.join
thread.join 表示运行这段代码的线程会处于挂起状态, 等待调用这个方法的线程(此处就是这个thread) 运行完毕后才继续运行. 下面的例子中子线程都是在main 线程上面创建的, 所以在main 线程里面运行某一个子线程.join 时会等待子线程运行完毕才继续运行main 线程, 代码如下:
public static void main(String[] args) throws InterruptedException{
List<Thread> list = new ArrayList<>(); for(int i=0; i<10; i++){
Thread t = new Thread("subthread" + i){
@Override public void run() { try{
Thread.sleep(3000);
System.out.println(Thread.currentThread().getName() + "finished");
}catch(InterruptedException e){
e.printStackTrace();
}
}
};
list.add(t);
t.start();
} for(Thread item : list){
item.join();
}
System.out.println("main thread finished");
}运行结果:
subthread1finished subthread2finished subthread0finished subthread3finished subthread6finished subthread5finished subthread4finished subthread9finished subthread7finished subthread8finished main thread finished
使用这个方法相比去上面两种方法优点在于不用设置等待时间.
方法四 Thread.yield and Thread.activeCount
首先说明一下这两个方法的作用, Thread.yield 通俗讲就是让步, 调用这个方法的当前线程放弃 自己占用CPU 的权利. 但是并不表示当前线程一定不再执行. Thread.activeCount 方法返回的是当前调用这个线程对应的线程组中所有的活跃线程数量. 在创建线程的时候(new Thread) 其中这个ThreadGroup 参数指的就是创建线程对应的线程组, 如果这个参数没有指定, 那么创建的线程与创建这个线程的线程是同一个线程组. 代码如下:
public static void main(String[] args) { // 关键参数
int defaultThreadNum = 2; for(int i=0; i<10 ;i++){ new Thread("subthread" + i){
@Override public void run() { try {
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + "finished");
}catch(InterruptedException e){
e.printStackTrace();
}
}
}.start();
} while(Thread.activeCount() > defaultThreadNum){ // 当活跃线程数大于设定的默认线程数的时候 主线程让步
Thread.yield();
}
System.out.println("main thread finished");
}运行结果:
subthread0finished subthread4finished subthread1finished subthread8finished subthread9finished subthread5finished subthread2finished subthread3finished subthread6finished subthread7finished main thread finished
有一个很关键的地方就是这个defaultthreadnum 设置的是2. 有一些blog中设置的是1, 但是1会导致无限循环, 主线程无法退出, 原因在于大家都认为主线程所在的线程组中排除子线程后只剩主线程一个线程了, 其实不然, 比如我们运行如下的代码:
public static void main(String[] args) {
Thread.currentThread().getThreadGroup().list();
}输出:
java.lang.ThreadGroup[name=main,maxpri=10] Thread[main,5,main] Thread[Monitor Ctrl-Break,5,main]
可以看到主线程所在的线程组中还有一个叫Monitor Ctrl-Break 的线程, 因此排除所有子线程后还剩余2个线程, 所以循环判断的门限(defaultThreadNum) 需要设置为2.
此方法也是不需要设置等待时间的.
综上所述, 如果需要实现主线程在所有子线程运行结束后再运行可以使用方法三和方法四.
相关推荐：
