理解高并发(16).自己动手编写Future、Callable

最新推荐文章于 2021-10-02 17:37:46 发布

毛志荣

最新推荐文章于 2021-10-02 17:37:46 发布

阅读量289

点赞数

分类专栏：高并发

本文链接：https://blog.youkuaiyun.com/maozhr720/article/details/77608389

版权

19 篇文章

订阅专栏

  实现带返回值的线程调用方式有很多， 这里主要是借助LockSupport工具来实现。 

 
 MyFuture.java类： 

  功能职责： 

  1、实现runnable接口，使其具体线程的特质 

  2、 提供future的get方法，使调用者能够获取到返回值 

  package com.test.thread.demo13; 

  import java.util.concurrent.locks.LockSupport; 

  public class MyFuture<T> implements Runnable{ 

  MyTask task; 

  Result<T> result; 

  Thread current; 

  public MyFuture(MyTask task){ 

  this.task = task; 

  result = new Result<T>(); 

  current = Thread.currentThread(); 

  System.out.println("process thread is:" + Thread.currentThread().getName() + ", call thread is:" + current.getName()); 

}

  @SuppressWarnings("unchecked") 

  public void run(){ 

  Object value = task.call(); 

  result.setDone(true); 

  result.setResult((T)value); 

  LockSupport.unpark(current); 

  System.out.println("process thread is:" + Thread.currentThread().getName() + ", call thread is:" + current.getName()); 

}

  public T get(){ 

  for(;;){ 

  if(!result.isDone){ 

  LockSupport.park(current); 

  }else{ 

  break; 

}

}

  System.out.println("process thread is:" + Thread.currentThread().getName() + ", call thread is:" + current.getName()); 

  return result.getResult(); 

}

  @SuppressWarnings("hiding") 

  class Result<T>{ 

  boolean isDone = false; 

  T result; 

  public void setDone(boolean status){ 

  this.isDone = status; 

}

  public boolean getStatus(){ 

  return this.isDone; 

}

  public void setResult(T result){ 

  this.result = result; 

}

  public T getResult(){ 

  return result; 

}

}

}

 
 MyTask.java类： 

 
 功能职责： 具体业务实现 

  package com.test.thread.demo13; 

  public class MyTask { 

  public String call(){ 

  try { 

  Thread.sleep(5000L); 

  } catch (InterruptedException e) { 

  // TODO Auto-generated catch block 

  e.printStackTrace(); 

}

  return "hello"; 

}

}

 
 MyTaskTest.java类： 

  测试类 

  package com.test.thread.demo13; 

  public class MyTaskTest { 

  public static void main(String[] args) { 

  MyFuture<String> future = new MyFuture<String>(new MyTask()); 

  Thread thread = new Thread(future); 

  thread.start(); 

  System.out.println("============over 1"); 

  String result = future.get(); 

  System.out.println("result:" + result); 

  System.out.println("============over 2"); 

}

}

 
 运行效果： 

 
 process thread is:main, call thread is:main 

 
 ============over 1 

 
 process thread is:Thread-0, call thread is:main 

 
 process thread is:main, call thread is:main 

 
 result:hello //以下2行必定会在子线程运行完后才输出 

 
 ============over 2 