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

梦里梦外; 2022-08-20 06:09 158阅读 0赞

**继承Thread类,重写run方法**

**例如：**

/**
 * 实现线程方式一 继承Thread类
 * 
 * @author wbw
 * 
 */
 public class MyThread1 extends Thread {
 
 	@Override
 	public 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{
 
 	@Override
 	public 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()方法

**例子：**

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

启动：

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);
 }
 }

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

**FutureTask封装Future的实体类**

**Future的接口如下：**

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; 
 }

**Callable 与Future**

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();
 	}
 }
 }

**Callable 与FutureTask**

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 block
 			e.printStackTrace();
 		}

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