大家好，我是爱编程的喵喵。双985硕士毕业，现担任全栈工程师一职，热衷于将数据思维应用到工作与生活中。从事机器学习以及相关的前后端开发工作。曾在阿里云、科大讯飞、CCF等比赛获得多次Top名次。现为CSDN博客专家、人工智能领域优质创作者。喜欢通过博客创作的方式对所学的知识进行总结与归纳，不仅形成深入且独到的理解，而且能够帮助新手快速入门。
本文主要介绍了创建线程并启动-创建线程的前三种方式，希望能对学习线程的同学有所帮助。
1. 创建线程并启动
java中主线程、垃圾回收线程、异常处理线程的创建、死亡等生命周期均由别人（可能是系统，也可能是java JDK）帮我们做了，因此不需要自己操心。这里我们关注的是在主线程中创建子线程以及子线程中创建孙线程…
// java伪代码
public class Thead1 {
public static void main(String[] args) {
System.out.println("我是主线程的第一行代码");
System.out.println("我是主线程的第一行代码");
......
创建子线程对象（可以创建多个子线程）;
子线程准备就绪;
运行子线程;
子线程结束;
"主线程的其他代码";
}
}
- java创建线程一共有四种方式：
- 继承
java.lang.Thread类 - 实现
Runnable接口 - jdk1.5新增：实现
Callable接口 - jdk1.5新增：使用线程池
- 继承
- 本章主要介绍前三种方式，第四种线程池的方法内容较多，且依赖于Runnable和Callable，单独一章介绍
2. 方式一：继承Thread类
- 步骤：
- 创建一个继承于Thread类的子类，并重写Thread类的run方法，该方法就是子线程具体要执行的内容（run方法是非静态方法）
- 新建一个上述类的对象，即线程对象（生命周期-新建）（如果有多个线程，需要创建多个Thread对象）
- 调用线程对象的start()方法，其作用为：①启动当前线程 (生命周期-准备就绪)② 调用当前线程的run()。因此run方法很重要，包含线程真正要做的实质内容。
- run方法执行完成，线程自动消亡（生命周期-死亡）
- 注意：
- 一定要调用start方法，不能手动调用run方法，如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式。run()方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU调度决定。
- 一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出异常“IllegalThreadStateException”
Thread.currentThread().getName()：获取当前线程的名称- 阅读源码，Thread类实现了Runnable接口（
public class Thread implements Runnable {xxx}） - 上述步骤没有看到准备就绪–>运行 过程的代码，是因为该过程"获取CPU执行权"是系统帮我们操作的，当start后，线程准备就绪，系统会根据CPU使用情况，调度线程（执行线程），线程执行完毕后，就会自动消亡。
package com.cn.created;
/**
* 1. 创建一个继承Thread类的子类，并重写run方法
*/
class SubThread extends Thread{
@Override
public void run(){
// 遍历5以内的数
for (int i = 0; i < 5; i++){
System.out.println(Thread.currentThread().getName() + ":" + i); // static Thread currentThread(): 返回当前线程 String getName(): 返回线程的名称
}
}
}
public class AThread {
public static void main(String[] args) {
// 主线程代码
String a1 = "我是主线程1";
System.out.println(a1);
// 2. 创建Thread子类对象
SubThread t1 = new SubThread();
// 3. 调用对象的start方法
t1.start();
// 一个线程对象只能调用一次start()方法，新建一个线程对象，遍历5以内数字
SubThread t2 = new SubThread();
t2.start();
// 以下是主线程
String a2 = "我是主线程2";
System.out.println(a2);
}
}
- 每次执行结果都是不一样的，可以发现上例子线程的执行不影响主线程（子线程还没执行完，a2已经打印出来了，t1、t2也没有必然的顺序）
3. 方式二：实现Runnable接口
- 步骤：
- 创建一个实现了Runnable接口的类，并实现Runnable中的抽象方法：run()，该方法就是子线程具体要执行的内容
- 创建实现类的对象（如果有多个线程，只需要创建一个Runnable实现类的对象）
- 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象，即线程对象（生命周期-新建）（如果有多个线程，需要创建多个Thread对象）
- 调用线程对象的start()方法，其作用为：①启动当前线程 (生命周期-准备就绪)② 调用当前线程的run()。因此run方法很重要，包含线程真正要做的实质内容。
- run方法执行完成，线程自动消亡（生命周期-死亡）
package com.cn.created;
/**
* 1. 实现Runnable接口,并实现run方法
*/
class ImlRunnalbe implements Runnable{
@Override
public void run(){
for (int i = 0; i < 5; i++){
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
public class BRunnable {
public static void main(String[] args) {
String a1 = "我是主线程1";
System.out.println(a1);
// 2. 新建实现类的对象
ImlRunnalbe imlRunnalbe = new ImlRunnalbe();
// 3. 将新建的类对象作为参数传到Thread类构造器中
Thread t1 = new Thread(imlRunnalbe);
// 4. 调用start方法
t1.start();
// 再起一个线程
Thread t2 = new Thread(imlRunnalbe);
t2.start();
String a2 = "我是主线程2";
System.out.println(a2);
}
}
4. 方式三：实现Callable接口
-
Callable接口实现多线程是java1.5以后新增的。
-
步骤：
- 创建一个实现了Callable接口的类，并实现Callable中的抽象方法：call，该方法就是子线程具体要执行的内容。且该call方法与继承Thread方式与实现Runnable方式的不同在于：
- call()可以有返回值的，一般使用Object类型（在最后一步通过get方法得到的是Object类型结果）
- Callable是支持泛型的
- call()可以抛出异常，被外面的操作捕获，获取异常的信息
- 创建实现callable接口的类对象（如果有多个线程，只需要创建一个Callable对象）
- 将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象（如果有多个线程，需要创建多个FutureTask对象）
- 将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread线程对象（如果有多个线程，需要创建多个Thread对象）
- 调用线程对象的start()方法
- 父线程调用FutureTask的get()方法，得到call的返回值，返回值类型为Object
- 创建一个实现了Callable接口的类，并实现Callable中的抽象方法：call，该方法就是子线程具体要执行的内容。且该call方法与继承Thread方式与实现Runnable方式的不同在于：
-
相较于继承Thread方式和实现Runnable方式，实现Callable接口有以下不同：
- 重写的是call方法，且该方法允许有返回值，可以使用泛型，可以抛出异常
- 在步骤上多了一个FutureTask对象
package com.cn.created;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
* 1.创建一个实现了Callable接口的类，并实现Callable中的抽象方法
* - 该call方法允许有返回值
* - 该call方法可以抛出异常
*/
class SubCall implements Callable {
@Override
public Object call() throws Exception {
int sum = 0;
for (int i = 0; i <= 10; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
sum += i;
}
// 强制等待5s，观察主线程是否会等待子线程结束才能获取返回值
Thread.sleep(5000);
return sum;
}
}
public class CCallable {
public static void main(String[] args) {
// 2. 创建实现callable接口的类对象
SubCall subCall = new SubCall();
// 3. 创建FutureTask对象，并将subCall传进去
FutureTask futureTask1 = new FutureTask(subCall);
FutureTask futureTask2 = new FutureTask(subCall);
// 4. 创建线程对象，并将futureTask对象传进去
Thread t1 = new Thread(futureTask1);
Thread t2 = new Thread(futureTask2);
t1.setName("线程1");
t2.setName("线程2");
// 5. 调用线程对象的start方法
t1.start();
t2.start();
// 6. 打印主线程
System.out.println("======================");
// 7. 获取子线程的返回值
try {
//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
Object mySum1 = futureTask1.get();
Object mySum2 = futureTask2.get();
System.out.println("子线程1总和为：" + mySum1);
System.out.println("子线程1总和为：" + mySum2);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
从上例的运行结果，可以看出，主线程的中打印===================并不受子线程的影响，即不需要等待子线程结束，主线程与子线程各运行各的。但是主线程中futureTask1和futureTask2对象的get方法（获取子线程返回的结果）需要等子线程结束才能得到（毕竟是要获得子线程返回的结果，所以必须得等子线程结束才行）
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
