创建线程和启动
- 继承 Thread
- 实现 Runable
- 实现 Callable
继承Thread类创建线程类
通过继承Thread类创建线程类的具体步骤和具体代码如下:
- 定义一个继承Thread类的子类,并重写该类的run()方法;
- 创建Thread子类的实例,即创建了线程对象;
- 调用该线程对象的start()方法启动线程。
class MyThread extends Thread {
// 步骤1:继承Thread类重写run()方法
@Override
public void run() {
//do something here
}
}
public static void main(String[] args){
//步骤2:创建Thread子类,即创建了线程对象
MyThread myThread = new MyThread ();
// 步骤3:启动线程
myThread .start();
}
实现Runnable接口创建线程类
通过实现Runnable接口创建线程类的具体步骤和具体代码如下:
- 定义Runnable接口的实现类,并重写该接口的run()方法
- 创建Runnable实现类的实例,并以此实例作为Thread的target对象,即该Thread对象才是真正的线程对象
public class Main {
public static void main(String[] args) {
// 将Runnable实现类作为Thread的构造参数传递到Thread类中,然后启动Thread类
MyRunnable runnable = new MyRunnable();
new Thread(runnable).start();
}
}
class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "\t" + Thread.currentThread().getId());
}
}
两种方式在本质上没有明显的区别,在外观上有很大的区别,第一种方式是继承Thread类,因Java是单继承,如果一个类继承了Thread类,那么就没办法继承其它的类了,在继承上有一点受制,有一点不灵活,第二种方式就是为了解决第一种方式的单继承不灵活的问题,所以平常使用就使用第二种方。
通过Callable和Future创建线程
通过Callable和Future创建线程的具体步骤和具体代码如下:
- 创建Callable接口的实现类,并实现call()方法,该call()方法将作为线程执行体,并且有返回值
- 创建Callable实现类的实例,使用FutureTask类来包装Callable对象,该FutureTask对象封装了该Callable对象的call()方法的返回值
- 使用FutureTask对象作为Thread对象的target创建并启动新线程
- 调用FutureTask对象的get()方法来获得子线程执行结束后的返回值其中
public class Main {
public static void main(String[] args) throws Exception {
// 步骤2:将Callable包装成FutureTask,FutureTask也是一种Runnable
MyCallable callable = new MyCallable();
FutureTask<Integer> futureTask = new FutureTask<>(callable);
//步骤3:使用FutureTask对象作为Thread对象的target创建并启动新线程
new Thread(futureTask).start();
// 步骤4:调用FutureTask对象的get()方法来获得子线程执行结束后的返回值其中
Integer sum = futureTask.get();
System.out.println(Thread.currentThread().getName() + Thread.currentThread().getId() + "=" + sum);
}
}
class MyCallable implements Callable<Integer> {
// 步骤1:创建Callable接口的实现类,并实现call()方法,该call()方法将作为线程执行体,并且有返回值
@Override
public Integer call() throws Exception {
System.out.println(Thread.currentThread().getName() + "\t" + Thread.currentThread().getId() + "\t" + new Date() + " \tstarting...");
int sum = 0;
for (int i = 0; i <= 100000; i++) {
sum += i;
}
Thread.sleep(5000);
System.out.println(Thread.currentThread().getName() + "\t" + Thread.currentThread().getId() + "\t" + new Date() + " \tover...");
return sum;
}
}
三种方式比较
- Thread: 继承方式, 不建议使用, 因为Java是单继承的,继承了Thread就没办法继承其它类了,不够灵活
- Runnable: 实现接口,比Thread类更加灵活,没有单继承的限制
- Callable: Thread和Runnable都是重写的run()方法并且没有返回值,Callable是重写的call()方法并且有返回值并可以借助FutureTask类来判断线程是否已经执行完毕或者取消线程执行
- 当线程不需要返回值时使用Runnable,需要返回值时就使用Callable,一般情况下不直接把线程体代码放到Thread类中,一般通过Thread类来启动线程
- Thread类是实现Runnable,Callable封装成FutureTask,FutureTask实现RunnableFuture,RunnableFuture继承Runnable,所以Callable也算是一种Runnable,所以三种实现方式本质上都是Runnable实现