Offer来了：Java面试核心知识点精讲（原理篇）
上QQ阅读APP看本书，新人免费读10天
设备和账号都新为新人
上一章目录下一章

3.1 Java线程的创建方式

常见的Java线程的4种创建方式分别为：继承Thread类、实现Runnable接口、通过ExecutorService和Callable<Class>实现有返回值的线程、基于线程池，如图3-1所示。

图3-1

3.1.1 继承Thread类

Thread类实现了Runnable接口并定义了操作线程的一些方法，我们可以通过继承Thread类的方式创建一个线程。具体实现为创建一个类并继承Thread接口，然后实例化线程对象并调用start方法启动线程。start方法是一个native方法，通过在操作系统上启动一个新线程，并最终执行run方法来启动一个线程。run方法内的代码是线程类的具体实现逻辑。具体的实现代码如下：

//step 1：通过继承Thread类创建NewThread线程
public  class  NewThread  extends  Thread  {
    public  void  run()  {
    System.out.println("create  a  thread  by  extends  Thread");
    }
}
//step 2：实例化一个NewThread线程对象
NewThread   newThread  =  new  NewThread();
//step 3：调用start方法启动NewThread线程
newThread  .start();

以上代码定义了一个名为NewThread的线程类，该类继承了Thread, run方法内的代码为线程的具体执行逻辑，在使用该线程时只需新建一个该线程的对象并调用其start方法即可。

3.1.2 实现Runnable接口

基于Java编程语言的规范，如果子类已经继承（extends）了一个类，就无法再直接继承Thread类，此时可以通过实现Runnable接口创建线程。具体的实现过程为：通过实现Runnable接口创建ChildrenClassThread线程，实例化名称为childrenThread的线程实例，创建Thread类的实例并传入childrenThread线程实例，调用线程的start方法启动线程。具体的实现代码如下：

//step 1：通过实现Runnable接口方式创建ChildrenClassThread线程
public  class  ChildrenClassThread  extends  SuperClass  implements  Runnable  {
    public  void  run()  {
    System.out.println("create  a  thread  by  implements  Runnable  ");
    }
}
//step 2：实例化一个ChildrenClassThread对象
ChildrenClassThread  childrenThread  =  new  ChildrenClassThread();
//step 3：创建一个线程对象并将其传入已经实例化好的childrenThread实例
Thread  thread  =  new  Thread(childrenThread);
//step 4：调用start方法启动一个线程
thread.start();

事实上，在传入一个实现了Runnable的线程实例target给Thread后，Thread的run方法在执行时就会调用target.run方法并执行该线程具体的实现逻辑。在JDK源码中，run方法的实现代码如下：

@Override
 public  void  run()  {
      if  (target  ! =  null)  {
          target.run();
      }
  }

3.1.3 通过ExecutorService和Callable<Class>实现有返回值的线程

有时，我们需要在主线程中开启多个线程并发执行一个任务，然后收集各个线程执行返回的结果并将最终结果汇总起来，这时就要用到Callable接口。具体的实现方法为：创建一个类并实现Callable接口，在call方法中实现具体的运算逻辑并返回计算结果。具体的调用过程为：创建一个线程池、一个用于接收返回结果的Future List及Callable线程实例，使用线程池提交任务并将线程执行之后的结果保存在Future中，在线程执行结束后遍历Future List中的Future对象，在该对象上调用get方法就可以获取Callable线程任务返回的数据并汇总结果，实现代码如下：

//step 1：通过实现Callable接口创建MyCallable线程
public  class  MyCallable  implements  Callable<String>  {
  private  String  name;
  public MyCallable(String name){//通过构造函数为线程传递参数，以定义线程的名称
  this.name  =  name;
}
    @Override
    public String call() throws Exception {//call方法内为线程实现逻辑
      return  name;
    }
}
  //step 2：创建一个固定大小为5的线程池
  ExecutorService  pool  =  Executors.newFixedThreadPool(5);
  //step 3：创建多个有返回值的任务列表list
  List<Future>  list  =  new  ArrayList<Future>();
  for  (int  i  =  0;  i  <  5;  i++)  {
      //step 4：创建一个有返回值的线程实例
      Callable  c  =  new  MyCallable(i  +  "  ");
      //step 5：提交线程，获取Future对象并将其保存到Future List中
      Future  future  =  pool.submit(c);
      System.out.println("submit  a  callable  thread:"  +i);
      list.add(future);
  }
  //step 6：关闭线程池，等待线程执行结束
  pool.shutdown();
  //step 7：遍历所有线程的运行结果
  for  (Future  future  :list)  {
    //从Future对象上获取任务的返回值，并将结果输出到控制台
    System.out.println("get  the  result  from  callable  thread:"+
                            f.get().toString())
  }

3.1.4 基于线程池

线程是非常宝贵的计算资源，在每次需要时创建并在运行结束后销毁是非常浪费资源的。我们可以使用缓存策略并使用线程池来创建线程，具体过程为创建一个线程池并用该线程池提交线程任务，实现代码如下：

//step 1：创建大小为10的线程池
ExecutorService  threadPool  =  Executors.newFixedThreadPool(10);
 for(int  i  =0  ; i<10; i++){
//step 2：提交多个线程任务并执行
    threadPool.execute(new  Runnable()  {
      @Override
      public  void  run()  {
        System.out.println(Thread.currentThread().getName()  +  "is  running");
              }
          });
      }
}
上一章目录下一章