线程和进程应该都听说过，Thread，Process，这里就不介绍概念了，基本的Java线程模型有Thread类，Runnable接口，Callable接口和Future接口等，这些线程模型都是面向对象的。
1. 继承Thread类
其中Thread类的run(),方法是线程中最重要的方法，用于执行线程要完成的任务，我们每次创建一个线程都要重写run方法，当然还有start()方法负责启动。
下面继承Thread类
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
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值 } } } |
执行结果：
|
1 2 3 4 5 6 7 8 9 10 11 |
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方法启动该线程。
代码实现：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
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); } } } |
结果
|
1 2 3 4 5 6 7 8 9 10 11 12 |
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方法来获得子线程执行结束后的返回值
实例代码
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
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); } } } |
结果
|
1 2 3 4 5 6 7 8 9 10 11 12 |
子线程:0 子线程:1 子线程:2 子线程:3 子线程:4 子线程返回值：5 main:10 main:11 main:12 main:13 main:14 |