文章目录
二、实现Callable接口相比实现Runnable接口或继承Thread类的好处
前言
本篇文章主要是记录Java线程的几种创建方式,以便需要的时候用来参考
一、创建方式说明
Java线程的创建方式有3种,分别是继承Thread,实现Runnable接口,通过Callable和Future接口创建(JDK1.5中开始增加)。还是有一种说法创建线程方式有4种,这4种除了前边提出的3种以外还有一种是通过线程池的方式创建线程(JDK1.5中开始增加)。
二、继承Thread方式
1.代码实现
class MyThread01 extends Thread {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"::通过继承Thread方式创建线程");
}
}
public class CreateThread {
public static void main(String[] args) {
Thread t =new MyThread01();
t.setName("t1");
t.start();
//结果:t1::通过继承Thread方式创建线程
}
}
2.过程说明
(1)、定义子类继承Thread类
(2)、子类中重写Thread类中的run方法
(3)、创建该子类对象,即创建了线程对象
(4)、调用线程对象的start方法,启动线程
三、实现Runnable接口方式
1、代码实现
class MyThread02 implements Runnable {
public void run() {
System.out.println(Thread.currentThread().getName()+"::通过实现Runnable方式创建线程");
}
}
public class CreateThread {
public static void main(String[] args) {
MyThread02 t1 = new MyThread02();
Thread t =new Thread(t1);
t.setName("t2");
t.start();
//结果:t2::通过实现Runnable方式创建线程
}
}
2、过程说明
(1)、定义子类,实现Runnable接口
(2)、子类重写Runable接口中的run方法
(3)、通过Thread类的含参数构造器创建线程对象
(4)、将子类的对象作为实际参数传给Thread类的构造器中
(5)、调用Thread类的start方法,开启线程(start方法会调用子类的run方法)
四、实现Callable方式 ,创建带返回值的线程
1、代码实现
public class NumThread implements Callable {
@Override
public Object call() throws Exception {
int sum = 0;
for (int i = 0; i <= 10 ; i++) {
if(i%2==0){
System.out.print(i+" ");
sum+=i;
}
}
return sum;
}
}
public class ThreadNew {
public static void main(String[] args) {
NumThread n = new NumThread();
FutureTask futureTask = new FutureTask (n);
new Thread(futureTask).start();
try {
Object o = futureTask.get();
System.out.println("计算总和:"+o);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
//结果:0 2 4 6 8 10 计算总和:30
}
2、过程说明
(1)、定义子类,实现Callable接口
(2)、子类重写Callable接口中的call方法
(3)、通过FutureTask 的有参构造函数创建FutureTask 对象
(4)、将子类的对象作为实际参数传给FutureTask 类的构造器中
(5)、通过Thread类的含参数构造器创建线程对象
(4)、将FutureTask 类的对象作为实际参数传给Thread类的构造器中
(5)、调用Thread类的start方法,开启线程
(6)、线程创建后,调用FutureTask 的get方法获取返回值
五、线程池方式创建线程
1、代码实现
public static void main(String[] args) {
// 创建一个固定数量的线程池
ExecutorService executor = Executors.newFixedThreadPool(5);
for (int i = 0; i < 10; i++) {
final int idx = i;
executor.execute(new Runnable() { // 创建线程并添加到线程池中, 并启动运行线程
@Override
public void run() {
System.out.println("当前线程名称:" + Thread.currentThread().getName() + ", 参数idx = " + idx);
}
});
}
executor.shutdown(); // 关闭线程池
}
/*结果:
当前线程名称:pool-1-thread-1, 参数idx = 0
当前线程名称:pool-1-thread-5, 参数idx = 4
当前线程名称:pool-1-thread-4, 参数idx = 3
当前线程名称:pool-1-thread-3, 参数idx = 2
当前线程名称:pool-1-thread-2, 参数idx = 1
当前线程名称:pool-1-thread-3, 参数idx = 8
当前线程名称:pool-1-thread-4, 参数idx = 7
当前线程名称:pool-1-thread-5, 参数idx = 6
当前线程名称:pool-1-thread-1, 参数idx = 5
当前线程名称:pool-1-thread-2, 参数idx = 9
*/
2、说明
(1)、通过Executors类中的不同静态方法,创建不同类型的线程池
Executors.newCachedThreadPool():创建一个可根据需要创建新线程的线程池
Executors.newFixedThreadPool(n);创建一个可重用固定线程数的线程池
Executors.newSingleThreadExecutor():创建一个只有一个线程的线程池
Executors.newScheduledThreadPool(n):创建一个线程池,它可安排在给定延迟后运行命令或者定期地执行。
(2)、调用ExecutorService接口中的execute方法执行线程
void execute(Runnable command):执行任务/命令,没有返回值,一般用来执行Runnable
<T> Future<T> submit(Callable<T> task):执行任务,有返回值,一般用来执行Callable
总结
一、 继承Thread与实现Runnable接口说明
Thread类其实就是实现了Runnable接口:public class Thread implements Runnable
区别:
继承Thread:线程代码存放Thread子类run方法中,这样线程和任务合并在一起了。
实现Runnable:线程代码存在接口的子类的run方法,这样线程和任务是分开的。
实现方式的好处:
避免了单继承的局限性更灵活
多个线程可以共享同一个接口实现类的对象,非常适合多个相同线程来处理同一份资源。
二、实现Callable接口相比实现Runnable接口或继承Thread类的好处
可以有返回值
方法可以抛出异常
支持泛型的返回值