02 多线程

1. Callable的实现和接收

  1. public class CallDemo implements Callable<String> {
  2.     @Override
  3.     public String call() throws Exception {
  4.         Thread.sleep(2000);
  5.         return "线程回调方法的返回值";
  6.     }
  7. }
  1. public class ThreadTest {
  2.     public static void main(String[] args) {
  3.         /*使用call回调方法有两种方式
  4.         * 1.用线程接收
  5.         * 2.用线程池接收*/
  6.         //1.用线程接收
  7.         CallDemo call = new CallDemo(); //1.创建call对象实例
  8.         /*
  9.         *FutureTask是一个类,该类提供了一个Future的基本实现,具有启动和取消计算的方法,查询计算是否完整,并检索计算结果
  10.         * 结果只能在计算完成后才能检索;如果计算尚未完成,则get方法将其阻止,
  11.         * 一旦计算完成,则无法重新启动或者取消计算(除非使用runAndReset()调用计算)
  12.         * 该接口实现的接口:Runnable,Future<V>,RunnableFuture<V> */
  13.         FutureTask<String> ft = new FutureTask<>(call);//2.创建FutureTask
  14.         Thread t1 = new Thread(ft);//3.创建线程
  15.         t1.start();//4.使用线程
  16.         String str = "";//5.创建变量接收
  17.         try {
  18.             str = ft.get();
  19.         } catch (InterruptedException |ExecutionException e) {
  20.             e.printStackTrace();
  21.         }
  22.         System.out.println(str);
  24.         //2.线程池
  25.         ExecutorService es = Executors.newFixedThreadPool(10);
  26.         Future<String> ft2 = es.submit(call);
  27.         String str2 = "";
  28.         try {
  29.             str2 = ft2.get();
  30.         } catch (InterruptedException |ExecutionException e) {
  31.             e.printStackTrace();
  32.         }
  33.         System.out.println(str2);
  34.         es.shutdown();//销毁线程池
  35.     }
  36. }

2.newFixedThreadPool的静态方法返回值详情

  1. public static ExecutorService newFixedThreadPool(int nThreads) {
  2.         return new ThreadPoolExecutor(nThreads, nThreads,
  3.                                       0L, TimeUnit.MILLISECONDS,
  4.                                       new LinkedBlockingQueue<Runnable>());
  5.     }
  1. public class Test {
  2.   public static void main(String[] args) {
  3.     ExecutorService es = Executors.newFixedThreadPool(10);
  4.     /*ThreadPoolExecutor(
  5.       (int corePoolSize => 线程池数量,
  6.       int maximumPoolSize=> 线程池最大数量,
  7.        long keepAliveTime=> 就是如果还有没有运行的空闲线程,那么空闲的线程就不能一直开着,所以就设置了一个存活时间,
  8.        TimeUnit unit=> 时间单位:纳秒,
  9.        BlockingQueue<Runnable> workQueue => 中文称其为工作队列，是一个用于创建内核线程的接口，
  10.        通过它创建的内核线程来执行内核其他模块排列到队列里的工作，创建的内核线程被称为工作者线程。
  11.        ))
  12.     */
  13.   }
  14. }