- 继承Thread类创建线程
- 实现Runnable接口创建线程
- Callable接口创建线程
要学习创建线程，我们要通过代码来演示，这里我们可以通过实现以下参赛者跑步的场景来展开。
模拟以下场景
模拟10秒短跑程序
假设，这里有三名参赛者，十秒钟时间内同时向前奔跑，我们要统计这三名参赛者分别跑了多少米，如果通过Java语言来模拟，我们是会有四个线程（main主线程 参赛者A 参赛者B 参赛者C ）
1.通过继承Thread类的方式模拟10秒短跑程序
- 第一步：继承Thread类
- 第二步：重写run()方法
- 第三步：调用start( )方法启动线程
首先我们在ThreadSample类中新建内部类并继承父类Thread来创建线程，并重写Thread类中run方法
//记录参赛者在十秒之内的跑步距离
public class ThreadSample {
class Runner extends Thread { //内部类
public void run() {
Integer speed = new Random().nextInt(10); //利用随机数生成速度
for (int i = 1; i <= 10; i++) {
System.out.println("第" + i + "秒" + this.getName() + "已跑到" + (i * speed) + "米(" + speed + "每秒）");
}
}
}class Runner extends Thread {
定义了Runner类继承Thread类创建线程
Integer speed = new Random().nextInt(10); ：
这段代码在run方法中调用了Random用于生成随机数的类，然后使用nextInt（10）方法，生成0 — 9的随机数，这个生成随机数将作为速度的数组
然后我们再建立start方法体，用于记录参赛者跑的动作
public void start() {
Runner threadA = new Runner(); //实例化类 //实例化并不会决定程序的运行，只有调用start方法时，这个线程才会被创建和开始运行
threadA.setName("参赛者A"); //调用setName，给当前线程赋名字
Runner threadB = new Runner();
threadB.setName("参赛者B");
Runner threadC = new Runner();
threadC.setName("参赛者C");
threadA.start(); //调用start()方法 开始新进程的创建和运行
threadB.start();
threadC.start();
}最后在main主函数实例化ThreadSample类并调用start方法体
public static void main(String[] args) {
new ThreadSample().start();
}运行结果：
实现Runnable接口模拟10秒短跑程序
第一步：实现接口Runnable
第二步：实现自带的run方法体
第三步：实例化Runner后，将对象作为参数传入Thread线程类中
第三步：调用start( )方法启动线程
创建一个ThreadSample2类，再定义内部类Runner ，这里不再像上面方法继承Thread类，而是实现一个Runnable接口，Runnable接口它提供了一种定义可执行任务的方式，用来实现多线程处理程序，在Runnable接口中必须要实现一个方法（run方法），此run方法与以上run方法体类似，这里只需注意在打印语句中对于当前线程名字的描述
class Runner implements Runnable { //Runnable是Java。lang包下所提供的接口，用来实现多线程处理程序
@Override
public void run() {
Integer speed = new Random().nextInt(10); //利用随机数生成速度
for (int i = 1; i <= 10; i++) {
System.out.println("第" + i + "秒" + Thread.currentThread().getName() + "已跑到" + (i * speed) + "米(" + speed + "每秒）");
} //Thread是线程类 提供了一个静态方法currentThread
}
}Thread.currentThread().getName() ：
Runnable无法像使用Thread类在打印语句中获取到getName线程名字，它没有getName这个方法，这里我们可以用Thread.currentThread().getName(),Thread是线程类，在线程类中他提供了一个静态方法，获取到当前线程然后调用getName，得到当前线程的名称
在当前类中增加start方法
public void start(){
Runner runner =new Runner();
Thread threadA= new Thread(runner);//将runner对象作为线程参数传入其中，在调用线程中的start方法
threadA.setName("参赛者A");
Thread threadB =new Thread(runner);
threadB.setName("参赛者B");
Thread threadC =new Thread(runner);
threadC.setName("参赛者C");
threadA.start();
threadB.start();
threadC.start();
}在主函数main中调用
public static void main(String[] args) {
new ThreadSample2().start();
}运行结果：
通过Callable接口模拟10秒短跑程序
新建内部类Runner，并连接Callable接口，这里Callable接口需要定义一个泛型，利用Callable接口我们实现多线程程序，每一个线程在执行完以后，它会有一个返回值
public class ThreadSample3 { //涉及线程池
class Runner implements Callable<Integer>{ //内部类
public String name;
@Override
public Integer call() throws Exception { //实现Runner中的方法call()
Integer speed =new Random().nextInt(10);
Integer result =0;
for(int i=1;i<=10;i++){
Thread.sleep(1000);
result=i*speed;
System.out.println("第" + i + "秒" + this.name + "已跑到" + (i * speed) + "米(" + speed + "每秒）");
}
return result;
}
再模拟参赛者开始跑的方法start()
public void start() throws ExecutionException, InterruptedException {
ExecutorService executorService = Executors.newFixedThreadPool(3);
Runner threadA=new Runner();
threadA.name ="参赛者A";
Runner threadB=new Runner();
threadB.name ="参赛者B";
Runner threadC=new Runner();
threadC.name ="参赛者C";
Future<Integer> r1= executorService.submit(threadA);
Future<Integer> r2= executorService.submit(threadB);
Future<Integer> r3= executorService.submit(threadC);
executorService.shutdown(); //等待所有线程执行完毕后，关闭线程池
System.out.println(threadA.name+"累计跑了"+r1.get()+"米");
System.out.println(threadB.name+"累计跑了"+r2.get()+"米");
System.out.println(threadC.name+"累计跑了"+r3.get()+"米");
}
ExecutorService executorService = Executors.newFixedThreadPool(3);:
创建了一个固定大小线程池的
ExecutorService，newFixedThreadPool(3)方法创建一个固定大小的线程池，其中参数3指定了线程池中的线程数量。Future<Integer> r1= executorService.submit(threadA);：
这行代码的作用是将一个任务提交给前面创建的线程池
executorService执行，并返回一个Future<Integer>对象来表示这个任务的结果。
在主函数main中调用
public static void main(String[] args) throws ExecutionException, InterruptedException {
new ThreadSample3().start();
}运行结果
通过这种方式，通过实现Callable接口进行开发，有着较好的功能，除了实现线程本身功能以外，还可以允许出现返回值。
这种带有返回值的线程处理，可以用于一些科学运算，比如用于计算量很大的任务，为了让计算机发挥充分的性能，我们把它拆分成多个线程，分到不同的CPU内核上来进行处理，这里每个线程计算的结果都可以通过Future对象接受到，当所有线程处理完成，将每一个线程进行汇总或再进行其他运算。
总之，利用Callable接口它的优势是允许线程执行后将值进行返回。
三种创建方式进行对比
- 继承Thread，java只支持单继承，对这种方法不太友好，不推荐使用
- 实现Runnable接口，Java编程友好，但无法返回执行后的数据
- 实现Callable接口，可以返回多线程执行结果，编程稍显复杂
