java 实现线程的三种方式 Thread 、Runnable、 Callable Future

本文主要是介绍java 实现线程的三种方式 Thread 、Runnable、 Callable Future，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

继承Thread类,重写run方法

例如：

/*** 实现线程方式一 继承Thread类* * @author wbw* */
public class MyThread1 extends Thread {@Overridepublic void run() {try {for (int i = 0; i < 10; i++) {System.out.println("Hello" + i);Thread.sleep(10000);}} catch (InterruptedException e) {e.printStackTrace();}}}

启动线程

package com.my.thread;public class Test {
public static void main(String[] args) {new MyThread1().start();
}
}

实现Runnable接口

package com.my.thread;
/*** 实现方式二： 实现抽象接口Runnable,在run方法中编写业务逻辑代码* @author wbw**/
public class MyThread2  implements Runnable{@Overridepublic void run() {try {for (int i = 0; i < 10; i++) {System.out.println("Hello" + i);Thread.sleep(10000);}} catch (InterruptedException e) {e.printStackTrace();}}}

在上面的两种实现方式，可以看出都能不能有返回值和不能抛出异常

在JDK1.5提供的新特性 Callable 和Fucture 可以允许线程有返回值

Callable的接口

public interface Callable<V> { V   call()   throws Exception; } 

Callable和Runnable的区别：

1. Callable定义的方法是call，而Runnable定义的方法是run。

2.  Callable的call方法可以有返回值，而Runnable的run方法不能有返回值。

3.  Callable的call方法可抛出异常，而Runnable的run方法不能抛出异常

4. Callable的启动可以通过创建ExecutorService对象调用sumbit（）方法执行,也可以通过Thread的start()方法,而Runnable通过Thread的start()方法 

例子：

<strong>package com.my.thread;import java.util.concurrent.Callable;
/*** 实现方式三：实现Callable接口* @author wbw**/
public class MyThread3 implements Callable<String> {@Overridepublic String call() throws Exception {return "hello world";}}</strong>

启动：

<strong>package com.my.thread;import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class Test {
public static void main(String[] args) {//Callable的启动方式MyThread3  task = new MyThread3();ExecutorService es =  Executors.newCachedThreadPool();es.submit(task);
}
}</strong>

Future用来保存Callable异步运算的结果

FutureTask封装Future的实体类

Future的接口如下：

<strong>public interface Future<V> {   boolean cancel(boolean mayInterruptIfRunning);   boolean isCancelled();   boolean isDone();   V get() throws InterruptedException, ExecutionException;   V get(long timeout, TimeUnit unit)   throws InterruptedException, ExecutionException, TimeoutException;   
}   </strong>

Callable 与Future

<strong>package com.my.thread;import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
/*** 测试Callable* @author wbw**/
public class Test {
public static void main(String[] args) {try {//创建callable任务Callable<String>  task = new MyThread3();// 创建一个执行任务的服务ExecutorService es =  Executors.newCachedThreadPool();// 提交并执行任务，任务启动时返回了一个Future对象，Future<String> future =  es.submit(task);// 获得第一个任务的结果，如果调用get方法，当前线程会等待任务执行完毕后才往下执行，形成阻塞的状态System.out.println("Callable线程的返回值:"+future.get());//停止任务执行服务es.shutdownNow();} catch (InterruptedException | ExecutionException e) {e.printStackTrace();}
}
}</strong>

Callable 与FutureTask

<strong>	    try {Callable<String>  task2 = new MyThread3();//创建FutureTask对象FutureTask<String> ft = new FutureTask<String>(task2);Thread thread = new Thread(ft);thread.start();//启动Thread.sleep(100);if(!ft.isDone()){//判断当前线程的执行状态System.out.println(ft.get());}if(!ft.isCancelled()){//判断当前线程是否已被取消ft.cancel(true);System.out.println("Cancelled");}} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();}</strong>

三种实现线程的方式,根据实际情况选用

这篇关于java 实现线程的三种方式 Thread 、Runnable、 Callable Future的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---