1、Java创建多线程的方法一：(1)实现Runnable接口并实现其中的run()方法；(2)将Runable对象提交给一个Thread构造器，调用start()方法。
【程序实例】单线程
public class LiftOff implements Runnable {
protected int countDown = 10;
private static int taskCount = 0;
private final int id = taskCount++;
public LiftOff() {
}
public LiftOff(int countDown) {
this.countDown = countDown;
}
public String status() {
return "#" + id + "(" + (countDown > 0 ? countDown : "LiftOff!") + "),";
}
@Override
public void run() {
while (countDown-- > 0) {
System.out.print(status());
Thread.yield();
}
}
}
public class Main {
public static void main(String[] args){
Thread thread = new Thread(new LiftOff());
thread.start();
System.out.println("Waiting for LiftOff");
}
}
【运行结果】
aaarticlea/png;base64,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" alt="" />
【结果分析】
主函数中，主线程（main线程）只创建了一个线程，可以看到输出结果是有序的、可控。此外，可以看出main线程并不会等待创建的线程。
【程序实例2】多线程
public class Main {
public static void main(String[] args) {
for (int i = 0; i < 5; i++)
new Thread(new LiftOff()).start();
System.out.println("Waiting for LiftOff");
}
}
【运行结果】
aaarticlea/png;base64,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" alt="" />
【结果分析】
此时主线程main线程创建并执行了5个线程，各个线程间是独立运行，输出的结果不可控。
2、执行器Executor
Java SE5的java.util.concurrent包中的执行器（Executor）将为你管理Thread对象，从而简化了并发编程。Executor 在客户端和执行任务之间提供了一个间接层，Executor代替客户端执行任务。Executor允许你管理异步任务的执行，而无须显式地管理线程的生命周期。Executor在Java SE5/6中时启动任务的优选方法。Executor引入了一些功能类来管理和使用线程Thread，其中包括线程池，Executor，Executors，ExecutorService，CompletionService，Future，Callable等。
【程序实例3】不固定大小线程池
public class Main {
public static void main(String[] args) {
ExecutorService exec = Executors.newCachedThreadPool();
for(int i=0;i<5;i++)
exec.execute(new LiftOff());
exec.shutdown();
}
}
【程序实例4】固定大小线程池
public class Main {
public static void main(String[] args) {
ExecutorService exec = Executors.newFixedThreadPool(5);
for (int i = 0; i < 5; i++)
exec.execute(new LiftOff());
exec.shutdown();
}
}
【程序分析】
实例3中，会根据实际的需要（5个线程）在线程池中创建相应数目的线程；实例4中，在一开始就固定了线程池的大小（5个），如果线程池中的线程的数目小于需求，则需要等待其它线程执行完后，复用线程，如实例5所示。
【程序实例5】
public class Main {
public static void main(String[] args) {
ExecutorService exec = Executors.newFixedThreadPool(3);
for (int i = 0; i < 5; i++)
exec.execute(new LiftOff());
exec.shutdown();
}
}
【运行结果】
#1(9),#0(9),#2(9),#0(8),#2(8),#1(8),#2(7),#0(7),#0(6),#0(5),#0(4),#1(7),#2(6),#0(3),#2(5),#1(6),#1(5),#1(4),#2(4),#2(3),#0(2),#2(2),#2(1),#1(3),#1(2),#1(1),#2(LiftOff!),#0(1),#0(LiftOff!),#3(9),#3(8),#1(LiftOff!),#3(7),#3(6),#4(9),#4(8),#4(7),#3(5),#4(6),#4(5),#4(4),#3(4),#3(3),#3(2),#4(3),#4(2),#3(1),#3(LiftOff!),#4(1),#4(LiftOff!),
【结果分析】
可以看出，最新运行的有3个线程（#0,#1,#2），只有当3个线程都运行完毕之后，才开始运行线程#3和#4。
【程序实例6】单线程
public class Main {
public static void main(String[] args) {
ExecutorService exec = Executors.newSingleThreadExecutor();
for (int i = 0; i < 5; i++)
exec.execute(new LiftOff());
exec.shutdown();
}
}
【运行结果】
#0(9),#0(8),#0(7),#0(6),#0(5),#0(4),#0(3),#0(2),#0(1),#0(LiftOff!),#1(9),#1(8),#1(7),#1(6),#1(5),#1(4),#1(3),#1(2),#1(1),#1(LiftOff!),#2(9),#2(8),#2(7),#2(6),#2(5),#2(4),#2(3),#2(2),#2(1),#2(LiftOff!),#3(9),#3(8),#3(7),#3(6),#3(5),#3(4),#3(3),#3(2),#3(1),#3(LiftOff!),#4(9),#4(8),#4(7),#4(6),#4(5),#4(4),#4(3),#4(2),#4(1),#4(LiftOff!),
【结果分析】
此时，任务只能排队，顺序执行。