创建线程
JDK1.5之前创建线程方式:
- 继承Thread类的方式
- 实现Runnable接口的方式
JDK5.0新增线程创建方式
- 实现Callable接口
- 使用线程池
继承Thread类的方式
- 定义子类继承Thread类。
- 子类中重写Thread类中的run方法。
- 创建Thread子类对象,即创建了线程对象。
- 调用线程对象start方法:启动线程,调用run方法。
代码实现
/**
* 创建一个子线程,完成1-100之间自然数的输出。同样地,主线程执行同样的操作
* 创建多线程的第一种方式:继承java.lang.Thread类
* 1.创建一个继承于Thread的子类
*/
class SubThread extends Thread {
/**
* 2.重写Thread类的run()方法.方法内实现此子线程要完成的功能
*/
@Override
public void run() {
for (int i = 1; i <= 100; i++) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
public class TestThread1 {
public static void main(String[] args) {
//3.创建子类的对象
SubThread st1 = new SubThread();
SubThread st2 = new SubThread();
//4.调用线程的start():启动此线程;调用相应的run()方法
//一个线程只能够执行一次start()
//不能通过Thread实现类对象的run()去启动一个线程
st1.start();
st2.start();
for (int i = 1; i <= 100; i++) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
注意事项:
- 如果自己手动调用run()方法,那么就只是普通方法,没有启动多线程模式。
- run()方法由JVM调用,什么时候调用,执行的过程控制都有操作系统的CPU调度决定。
- 想要启动多线程,必须调用start方法。
- 一个线程对象只能调用一次start()方法启动,如果重复调用了,则将抛出以上的异常“IllegalThreadStateException”。
实现Runnable接口的方式
- 定义子类,实现Runnable接口。
- 子类中重写Runnable接口中的run方法。
- 通过Thread类含参构造器创建线程对象。
- 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。
- 调用Thread类的start方法:开启线程,调用Runnable子类接口的run方法。
代码实现
/**
* 创建多线程的方式二:通过实现的方式
* 1.创建一个实现了Runnable接口的类
*/
class PrintNum1 implements Runnable {
//2.实现接口的抽象方法
@Override
public void run() {
// 子线程执行的代码
for (int i = 1; i <= 100; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}
public class TestThread2 {
public static void main(String[] args) {
// 3.创建一个Runnable接口实现类的对象
PrintNum1 p = new PrintNum1();
// 要想启动一个多线程,必须调用start()
// 4.将此对象作为形参传递给Thread类的构造器中,创建Thread类的对象,此对象即为一个线程
Thread t1 = new Thread(p);
// 5.调用start()方法:启动线程并执行run()
// 启动线程;执行Thread对象生成时构造器形参的对象的run()方法。
t1.start();
//再创建一个线程
Thread t2 = new Thread(p);
t2.start();
}
}
介绍了两种创建线程的方式,我们来对下继承方式和实现方式的联系与区别
区别:
- 继承Thread:线程代码存放Thread子类run方法中。
- 实现Runnable:线程代码存在接口的子类的run方法。
实现方式的好处
- 避免了单继承的局限性
- 多个线程可以共享同一个接口实现类的对象,非常适合多个相同线程来处理同一份资源。
实现Callable接口的方式
与使用Runnable相比, Callable功能更强大些
- 相比run()方法,可以有返回值
- 方法可以抛出异常
- 支持泛型的返回值
- 需要借助FutureTask类,比如获取返回结果
Future接口
- 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等;
- FutrueTask是Futrue接口的唯一的实现类;
- FutureTask 同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行,又可以作为Future得到Callable的返回值。
测试代码
/**
* 一、创建执行线程的方式三:实现 Callable 接口。 相较于实现 Runnable 接口的方式,支持泛型,方法可以有返回值,并且可以抛出异常。
*
* 二、执行 Callable 方式,需要 FutureTask 实现类的支持,用于接收运算结果。 FutureTask 是 Future 接口的实现类
*/
public class TestCallable {
public static void main(String[] args) {
ThreadDemo td = new ThreadDemo();
//1.执行 Callable 方式,需要 FutureTask 实现类的支持,用于接收运算结果。
FutureTask<Integer> result = new FutureTask<>(td);
new Thread(result).start();
//2.接收线程运算后的结果
try {
Integer sum = result.get(); //FutureTask 可用于 闭锁
System.out.println(sum);
System.out.println("------------------------------------");
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
}
class ThreadDemo implements Callable<Integer>{
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 0; i <= 100000; i++) {
sum += i;
}
return sum;
}
}
使用线程池方式
为啥要使用线程池的方式创建线程?
- 经常创建和销毁、使用量特别大的资源,比如并发情况下的线程,对性能影响很大。
- 提前创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中。可以避免频繁创建销毁、实现重复利用。
- 提高响应速度(减少了创建新线程的时间)
- 降低资源消耗(重复利用线程池中线程,不需要每次都创建)
- 便于线程管理
corePoolSize:核心池的大小
maximumPoolSize:最大线程数
keepAliveTime:线程没有任务时最多保持多长时间后会终止
等等
线程池相关API
JDK 5.0起提供了线程池相关API:ExecutorService 和 Executors
- ExecutorService:真正的线程池接口。常见子类ThreadPoolExecutor
void execute(Runnable command)
:执行任务/命令,没有返回值,一般用来执行Runnable
<T> Future<T> submit(Callable<T> task)
:执行任务,有返回值,一般又来执行Callable
void shutdown()
:关闭连接池 - Executors:工具类、线程池的工厂类,用于创建并返回不同类型的线程池
Executors.newCachedThreadPool()
:创建一个可根据需要创建新线程的线程池
Executors.newFixedThreadPool(n)
:创建一个可重用固定线程数的线程池
Executors.newSingleThreadExecutor()
:创建一个只有一个线程的线程池
Executors.newScheduledThreadPool(n)
:创建一个线程池,它可安排在给定延迟后运行命令或者定期地执行
代码示例:
/**
* 创建线程的方式四:使用线程池
* <p>
* 好处:
* 1.提高响应速度(减少了创建新线程的时间)
* 2.降低资源消耗(重复利用线程池中线程,不需要每次都创建)
* 3.便于线程管理
* corePoolSize:核心池的大小
* maximumPoolSize:最大线程数
* keepAliveTime:线程没有任务时最多保持多长时间后会终止
* <p>
* <p>
* 面试题:创建多线程有几种方式?四种!
*/
class NumberThread1 implements Runnable {
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
}
class NumberThread2 implements Callable {
//2.实现call方法,将此线程需要执行的操作声明在call()中
@Override
public Object call() {
int sum = 0;
for (int i = 1; i <= 100; i++) {
if(i % 2 != 0){
System.out.println(Thread.currentThread().getName() + ": " + i);
sum += i;
}
}
return sum;
}
}
public class ThreadPool {
public static void main(String[] args) {
//1. 提供指定线程数量的线程池
ExecutorService service = Executors.newFixedThreadPool(10);
ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
// ThreadPoolExecutor 实现类可以设置线程池的属性
// System.out.println(service.getClass());
// service1.setCorePoolSize(15);
// service1.setKeepAliveTime();
//2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
service.execute(new NumberThread1());//适合适用于Runnable
service.submit(new NumberThread2());//适合适用于Callable
//3.关闭连接池
service.shutdown();
}
}