![C语言中cube[0][2]|=Z,是什么意思？](/aiimages/C%E8%AF%AD%E8%A8%80%E4%B8%ADcube%5B0%5D%5B2%5D%7C%3DZ%2C%E6%98%AF%E4%BB%80%E4%B9%88%E6%84%8F%E6%80%9D%EF%BC%9F.png)
shutdown
在调用
isTerminated
例：
/*
* 采用线程池开启多个子线程，主线程等待所有的子线程执行完毕
*/
public static void moreThread() {
try {
int threadNum = 0
for (int i = 0i <10i++) {
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("主线程结束")
}
}
有多种实现方式，下面列出两种。
第一种：实现Callable类，使用有返回值的线程，只有线程执行完成后才会返回结果。
import java.util.ArrayListimport java.util.List
import java.util.Random
import java.util.concurrent.*
public class Main {
// 初始化一个容量为10的线程池
static final ExecutorService pool = Executors.newFixedThreadPool(10)
public static void main(String[] args) throws ExecutionException, InterruptedException {
List<Future<String>> futures = new ArrayList<>()
for (int i = 0 i < 3 i++) {
MyThread thread = new MyThread("线程" + i)
futures.add(pool.submit(thread))
}
for (Future<String> future : futures) {
String name = future.get()
System.out.println(name + "执行完成...")
}
System.out.println("所有线程执行完成!")
}
}
class MyThread implements Callable<String> {
private String name
public MyThread(String name) {
this.name = name
}
@Override
public String call() throws Exception {
// TODO 执行业务
// 随机延迟，模拟线程耗时
Thread.sleep(1000 + new Random().nextInt(2000))
return name
}
}
第二种：使用CountDownLatch实现线程计数，代码如下：
import java.util.Randomimport java.util.concurrent.CountDownLatch
import java.util.concurrent.ExecutionException
import java.util.concurrent.ExecutorService
import java.util.concurrent.Executors
public class Main2 {
// 初始化一个容量为10的线程池
static final ExecutorService pool = Executors.newFixedThreadPool(10)
public static void main(String[] args) throws InterruptedException {
int threadCount = 3
// 初始化CountDownLatch，用于线程计数
CountDownLatch latch = new CountDownLatch(threadCount)
for (int i = 0 i < threadCount i++) {
MyThread thread = new MyThread("线程" + i, latch)
pool.execute(thread)
}
// 阻塞当前线程，CountDownLatch计数减为0时表示所有线程都执行完毕，才会释放主线程的阻塞
latch.await()
System.out.println("所有线程执行完成!")
}
}
class MyThread implements Runnable {
private String name
private CountDownLatch latch
public MyThread(String name, CountDownLatch latch) {
this.name = name
this.latch = latch
}
@Override
public void run() {
// TODO 执行业务
// 随机延迟，模拟线程耗时
try {
Thread.sleep(1000 + new Random().nextInt(2000))
} catch (InterruptedException e) {
}
// 计数减一
latch.countDown()
System.out.println(name + "执行完毕...")
}
}
