Juc01_多线程概述、四种实现方式、常用方法API、生命周期、买票案例、synchronized锁（二）

  /*
  创建线程的方式三: 实现callable接口 ---JDK 5.0 新增
  1.创建一个实现Callable接口的实现类
  2.实现call方法,将此线程需要执行的操作声明在call()中
  3.创建callable接口实现类的对象
  4.将此callable的对象作为参数传入到FutureTask构造器中,创建FutureTask的对象
  5.将FutureTask对象作为参数传递到Thread类的构造器中,创建Thread对象,并调用star
  6.获取callable接口中call方法的返回值
  * */
  public class ThreadNew {
      public static void main(String[] args) {
          //3.创建callable接口实现类的对象
          NumThead m=new NumThead();
          //4.将此callable的对象作为参数传入到FutureTask构造器中,创建FutureTask的对象
          FutureTask futureTask = new FutureTask(m);
          //5.将FutureTask对象作为参数传递到Thread类的构造器中,创建Thread对象,并调用start()方法
          //FutureTask类继承了Runnable接口
          //new Runnable = futrueTask;
          new Thread(futureTask).start();
          //6.获取callable接口中call方法的返回值
          try {
              //get()方法返回值即为FutureTask构造器参数callable实现类重写的call方法的返回值
              Object sum = futureTask.get();
              System.out.println("总和是:"+sum);
          } catch (Exception e) {
              e.printStackTrace();
          }
      }
  }
  //1.创建一个实现Callable接口的实现类
  class  NumThead implements Callable{
     // class  NumThead implements Callable<Integer>{
      //2.实现call方法,将此线程需要执行的操作声明在call()中
      @Override
      public Object call() throws Exception {
      //public Integer call() throws Exception {
          int sum=0;
          for(int i=1;i<=100;i++){
              System.out.println(i);
              sum+=i;
          }
          return sum;
      }
  }

    例子:
  (1). 老师上着课,口渴了,去买水不合适,讲课线程继续,我可以单起个线程找班长帮忙
  买水,水买回来了放桌上,我需要的时候再去get。
  (2). 4个同学,A算1+20,B算21+30,C算31*到40,D算41+50,是不是C的计算量有点大啊,
  FutureTask单起个线程给C计算,我先汇总ABD,最后等C计算完了再汇总C,拿到最终结果
  (3). 高考:会做的先做,不会的放在后面做

public class CallableDemo  {
    public static void main(String[] args) throws Exception{
        CallAble c=new CallAble();
        FutureTask<Integer> futureTask=new FutureTask<>(c);
        new Thread(futureTask,"线程A").start();
        new Thread(futureTask,"线程B").start();
        Integer integer = futureTask.get();
        System.out.println("integer = " + integer);
    }
}
class CallAble implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        System.out.println("欢迎你调用call方法");
        return 6;
    }
}

public class FutureTaskTest {
    public static void main(String[] args) throws Exception{
        FutureTask futureTask = new FutureTask(()->{
            try { TimeUnit.SECONDS.sleep(3);  } catch (InterruptedException e) {e.printStackTrace();}
            System.out.println(Thread.currentThread().getName()+"\t"+"coming......");
            return 1024;
        });
        new Thread(futureTask).start();
        //1.果futureTask.get()放到main线程前面,会导致main线程阻塞
        //Object o = futureTask.get();
        /*Object o = futureTask.get();//不见不散,只要出现了get()方法就会阻塞
        System.out.println("不见不散,只要出现了get()方法就会阻塞,获取到的值为:"+o);*/
        //2.过时不候
//        System.out.println(Thread.currentThread().getName()+"\t"+"线程来了.....");
//        Object o2 = futureTask.get(2L, TimeUnit.SECONDS);
        //3.使用轮询
        while(true){
            if(futureTask.isDone()){
                System.out.println("使用轮询来解决,值为:"+futureTask.get());
                break;
            }else{
                System.out.println("阻塞中**********");
            }
        }
    }
}