Java多线程 - 线程的创建与启动
一、继承Thread
类创建线程类
1.创建步奏:
- 定义
Thread
类的子类,重写该类的run()方法,该方法就代表线程需要完成的任务,所以,run方法又被称为线程执行体。 - 创建
Thread
的实例,即是创建了线程对象。 - 调用线程对象中的start()方法来启动该线程。
实例代码:
class demo{
public static void main(String[] args) {
AThread first = new AThread();
AThread second = new AThread();
first.start();
second.start();
}
}
class AThread extends Thread{
private int i = 0;
//重写run方法,其中run方法就是线程执行体
@Override
public void run(){
for(; i < 100; i++){
//getName是返回当前线程的名字
System.out.println(getName() + " " + i);
}
}
}
二、实现Runnable
接口创建线程类
1.创建步奏:
- 定义
Runnable
接口的实现类,并且重写该接口的run()
方法,与上面所述一样,该run()
方法是该线程的线程执行体。 - 创建
Runnable
实现类的实例,并且以此实例作为Thread
的target
来创建Thread
对象,其中该Thread
对象才是真正的线程对象。
//创建 Runnable 实现类的对象
var st = new SecondThread();
//将 Runnable 实现类的对象作为 Thread 的 target 来创建 Thread 对象,即线程对象
new Thread(st);
//或者在创建 Thread 对象的时候为该 Thread 重新命名
new Thread(st, "新线程0");
- 调用线程对象的start() 方法来启动该线程
注意:Runnable
对象仅仅作为Thread
对象的target
,Runnable
实现类里包含的run()
方法仅仅是作为线程执行体,而实际的线程对象依然是Thread
对象的实例,只是该Thread
线程负责执行target
的run()
方法
示例代码:
class demo{
public static void main(String[] args) {
MyThread myThread1 = new MyThread();
MyThread myThread2 = new MyThread();
Thread thread1 = new Thread(myThread1, "第一线程");
Thread thread2 = new Thread(myThread2, "第二线程");
thread1.start();
thread2.start();
}
}
class MyThread implements Runnable{
private int i = 1;
@Override
public void run(){
for (; i < 100; ++i){
System.out.println(Thread.currentThread().getName() + " " + i);
}
}
}
三、使用Callable
和Future
来创建线程
上面一个是通过继承Thread
类来实现创建线程,一个是通过实现Runnable
接口来创建多线程。其中通过实现Runnable
接口创建多线程的时候,Thread
类的作用是将run()
方法包装成为线程执行体,那么是否可以直接把任意方法都包装成为线程执行体?在C#可以实现任意方法包装成线程执行体,包括有返回值的方法。Java 5开始,Java提供了Callable
接口,该接口怎么看都像是Runnable
接口的增强版。其中Callable
接口提供了一个call()
方法可以作为线程执行体,call()
方法的功能比run()
方法的功能更加强大。
run()
方法与call()
方法:
call()
方法可以有返回值call()
方法可以声明抛出异常
因此完全可以提供一个Callable
对象作为Thread
的target
,该线程的线程执行体就是该Callable
对象的call()
方法,但是这里会出现一个问题:即 Callable
接口是Java 5新增的接口,且不是Runnable
接口的子接口,所以说Callable
对象不能够直接作为Thread
的target
,并且call()
方法还有一个返回值,call()
方法并非是直接进行调用,而是作为线程执行体进行调用。
获取call()
方法的返回值:Java 5中提供了Future
接口来代表Callable
接口里call()
方法的返回值,并且Future
接口提供了FutureTask
实现类,该实现类实现了Future
接口,并实现了Runnable
接口,可以作为Thread
类的target
。
注:Callable
接口有泛型限制,Callable接口里的泛型形参类型与call()
方法返回值类型相同,而且Callable
接口是函数式接口,因此可使用Lambda
表达式创建Callable
对象。
创建步奏:
- 创建
Callable
接口的实现类,并且实现call()
方法,该call()
方法将作为线程执行体,且该方法有返回值,再创建Callable
实现类的实例,从Java 8开始,可以直接使用Lambda
表达式创建Callable
对象。 - 使用
FutureTask
类来包装Callable
对象,该FutureTask
对象封装了该Callable
对象的call()
方法的返回值。 - 使用
FutureTask
对象作为Thread
对象的target
创建并且启动线程、 - 调用
FutureTask
对象的get()
方法来获得子线程执行结束后的返回值。
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
class demo{
public static void main(String[] args) {
FutureTask<Integer> task = new FutureTask<>((Callable<Integer>)() -> {
int i = 0;
for(; i < 100; ++i){
System.out.println(Thread.currentThread().getName() + " " + i);
}
//可以有返回值
return i;
});
new Thread(task, "有返回值的线程").start();
try {
System.out.println("返回值:" + task.get());
}catch(Exception e){
e.printStackTrace();
}
}
}
以上采用Lambda
表达式直接创建的,无需先创建Callable
实现类了。
以下采用创建类的方式
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
class demo{
public static void main(String[] args) throws Exception {
Cal cal = new Cal();
FutureTask<Integer> res = new FutureTask<>(cal);
Thread thread = new Thread(res);
thread.start();
System.out.println(res.get());
}
}
class Cal implements Callable<Integer> {
private int i = 0;
@Override
public Integer call() throws Exception {
for(; i < 100; i++){
System.out.println(Thread.currentThread().getName() + " " + i);
}
return i;
}
}
四、创建线程的三种方式对比
通过三个接口,都可以实现多线程,只是Callable
接口的定义方法可以有返回值,可以声明跑出异常而已,所以,Runnable
接口和实现Callable
接口贵为一种方式。
采用Runnable
、Callable
接口的方式创建多线程的优缺点:
- 线程类只是实现了
Runnable
接口或者Callable
接口,还可以继承其他类 - 在该方式下,多个线程可以共享同一
target
对象,所以非常适合多个相同线程来处理同一份资源的情况,从而将CPU,代码和数据分开,形成清洗模型,体现面向对象思想、 - 编程稍复杂。
采用Thread
类的方式创建多线程的优缺点: - 线程类已经继承
Thread
类,所以不能在继承其他的父类。 - 优势:编写简单
一般来说,我们使用Runnable
和Callable
接口的方式创建多线程。