学习笔记14 - 给线程传参和处理线程的返回值

传参

class MyThread1 extends Thread{
  /** 2.通过变量和方法传递数据 */
  @Setter
  private String name;

  /** 1.通过构造方法传递数据 */
  public MyThread1(String name) {
      this.name = name;
  }

  /** 3.使用回调函数 */
  public void process(String name){
      this.name = name;
  }

  @Override
  public void run() {
      System.out.println(name);
  }
}

处理返回值

/**
 * 线程
 */
class CycleWait implements Runnable{
    public String value;
    @Override
    public void run() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        value = "we have date now";
    }
}

主线程等待法

 CycleWait cw = new CycleWait();
 Thread t = new Thread(cw);
 t.start();
 while (cw.value == null){
     Thread.sleep(100);
 }
 System.out.println("value :" + cw.value);

• 缺点：如果代码多，代码会臃肿，控制不精准

使用Thread类的join()阻塞当前线程以等待子线程处理完毕

CycleWait cw = new CycleWait();
Thread t = new Thread(cw);
t.start();
t.join();
System.out.println("value :" + cw.value);

• 缺点：力度不够

通过Callable接口实现：通过FutureTask Or 线程池获取

class MyCallable implements Callable<String>{
    @Override
    public String call() throws Exception {
        String value = "test";
        System.out.println("Ready to word");
        Thread.sleep(5000);
        System.out.println("task dene");
        return value;
    }
}

Future方式

FutureTask<String> task = new FutureTask<>(new MyCallable());
new Thread(task).start();
if (!task.isDone()){
    System.out.println("正在等待。。。");
  }
System.out.println(task.get());

线程池

 ExecutorService newCachedThreadPoll = Executors.newCachedThreadPool();
 Future<String> future = newCachedThreadPoll.submit(new MyCallable());
 if (!future.isDone()){
     System.out.println("正在等待。。。");
 }
 try {
     System.out.println(future.get());
 } catch (InterruptedException e) {
     e.printStackTrace();
 } catch (ExecutionException e) {
     e.printStackTrace();
 }finally {
     newCachedThreadPoll.shutdown();
 }