更多技术文章请访问我的个人博客http://www.rain1024.com
线程和进程应该都听说过,Thread,Process,这里就不介绍概念了,基本的Java线程模型有Thread类,Runnable接口,Callable接口和Future接口等,这些线程模型都是面向对象的。
1. 继承Thread类
其中Thread类的run(),方法是线程中最重要的方法,用于执行线程要完成的任务,我们每次创建一个线程都要重写run方法,当然还有start()方法负责启动。
下面继承Thread类
package com.rain.demo;
public class ThreadDemo extends Thread {//继承Thread类
public void run(){ //重写run方法
setName("子线程"); //定义子线程的name
for (int i=0;i<5;i++){
System.out.println(this.getName()+":"+i);//打印子线程的name和i值
}
}
public static void main(String[] arge){
ThreadDemo td = new ThreadDemo(); //创建线程对象
td.start(); //启动线程
for(int i=10;i<15;i++){
System.out.println(Thread.currentThread().getName()+":"+i);//打印主线程的name和i值
}
}
}
执行结果:
main:10
main:11
main:12
子线程:0
main:13
子线程:1
main:14
子线程:2
子线程:3
子线程:4
2. 实现Runable接口
Runnable接口用于标识某个Java类可否作为线程类,该接口只有一个抽象方法run,用于执行线程中的任务。一个尅实现Runnable接口后,并不代表该类是个“线程”类,不能直接启动线程,必须通过Thread类的实例来创建并启动线程。
通过Runnable接口创建并启动线程的步骤:
- (1)、定义一个雷实现Runnable接口,并实现该接口中的run方法;
- (2)、创建一个Thread类的实例,并将Runnable接口的实现类所创建的对象作为参数传入Thread类的构造方法中;
- (3)、调用Thread对象的start方法启动该线程。
代码实现:
package com.rain.demo;
//实现Runnable接口
class ThreadTask implements Runnable {
@Override
public void run() {//重写run方法
// TODO Auto-generated method stub
for(int i=0;i<5;i++){
//打印当前线程的name和i值
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
//实现类
public class RunnableDemo{
public static void main(String[] args) {
//实例化Thread类,参数为ThreadTask对象
Thread td = new Thread(new ThreadTask());
td.start();//启动线程
for(int i=10;i<=15;i++){
//打印主线程name和i值
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
结果
main:10
Thread-0:0
main:11
Thread-0:1
main:12
Thread-0:2
Thread-0:3
Thread-0:4
main:13
main:14
main:15
3. 使用Callable和Future接口
Callable接口提供一个call方法作为线程的执行体,call方法比run方法功能更强大,call方法可以有返回值,也可以声明抛出异常,Future接口用来接收Callable接口中call方法的返回值,Future接口提供一个FutureTask实现类,该类同时实现了Future和Runnable两个接口,因此可以作为Thread类的target参数,使用Callable和Future接口的最大优势在于可以在线程执行完任务之后获取执行结果。
使用Callable和Future接口创建并启动线程的步骤:
- (1)、创建Callable接口的实现类,并实现call方法,该方法将作为线程的执行体,并具有返回值,然后创建Callable实现类的实例。
- (2)实现FutureTask类来包装Callable对象,在FutureTask对象中封装了Callable对象的call方法的返回值
- (3)使用FutureTask对象作为Thread对象的target创建并启动新线程
- (4)调用FutureTaks对象的get方法来获得子线程执行结束后的返回值
实例代码
package com.rain.demo;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
//创建Callable接口实现类
class Task implements Callable<Integer>{
@Override
//实现call方法
public Integer call() throws Exception {
// TODO Auto-generated method stub
int i = 0;
for(i=0;i<5;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
//返回call的返回值
return i;
}
}
//主类
public class CallableFutureDemo{
public static void main(String[] args) {
//使用Future类包装Callable实现类的实例
FutureTask<Integer> task = new FutureTask<Integer>(new Task());
//创建线程,使用futureTask对象的task作为Thread对象的targer,启动线程
new Thread(task,"子线程").start();
try {
System.out.println("子线程返回值:"+task.get());
}catch(InterruptedException e){
e.printStackTrace();
} catch (ExecutionException e) {
// TODO: handle exception
e.printStackTrace();
}
for(int i=10;i<15;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
结果
子线程:0
子线程:1
子线程:2
子线程:3
子线程:4
子线程返回值:5
main:10
main:11
main:12
main:13
main:14