多线程的实现方式

多线程是指 一个程序运行时，产生或使用了不止一个线程。

线程的生命周期是怎么样的，下面这张图咱们能够看出些端倪：

这章咱们主要讨论多线程实现的方式，基础知识部分咱们能够下来再恶补。

方法一：Runnable 接口实现：

继承接口，实现业务逻辑：

public class WorkRunnable implements Runnable {
   private String taskName;
   public WorkRunnable(String taskName) {
      this.taskName = taskName;
   }
   @Override
   public void run() {
      System.out.println("开始执行任务" + taskName);
      try {
         Thread.sleep(2000);
      } catch (InterruptedException e) {
         e.printStackTrace();
      }
      System.out.println(taskName + "任务执行完成");

   }
}

初始化一个线程池，来调用任务：

public class ThreadPool {
   private static final int                CORE_SIZE       = 8;
   private static final int                MAX_SIZE        = 12;
   private static final long               KEEP_ALIVE_TIME = 30;
   private static final int                QUEUE_SIZE      = 50000;
   private static       ThreadPoolExecutor threadPool      = new ThreadPoolExecutor(CORE_SIZE, MAX_SIZE,
         KEEP_ALIVE_TIME, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(QUEUE_SIZE),
         new ThreadPoolExecutor.AbortPolicy());
   public static ThreadPoolExecutor getThreadPool() {
      return threadPool;
   }
}

实现多线程任务的调用：

public class RunnableClient {
   public static void main(String[] args) {
      WorkRunnable runnable1 = new WorkRunnable("taskName1");
      WorkRunnable runnable2 = new WorkRunnable("taskName2");
      ThreadPoolExecutor executor = ThreadPool.getThreadPool();
      executor.execute(runnable1);
      executor.execute(runnable2);
   }
}

方法二：继承Thread实现：

这种方式的实现，在我前一篇文章中已有提到，这里再也不单独讨论。

方法三： 实现Callable接口，这是一个带返回值的实现方式：

看任务定义：

public class WorkCallable implements Callable<String> {
   private String taskName;
   public WorkCallable(String taskName) {
      this.taskName = taskName;
   }
   @Override
   public String call() throws Exception {
      System.out.println(taskName + "开始执行");
      Thread.sleep(2000);
      System.out.println(taskName + "结束执行");
      return taskName;
   }
}

再来看主线程中如何调用：

public class CallableClient {
   public static void main(String[] args) throws ExecutionException, InterruptedException {
      WorkCallable task1 = new WorkCallable("task1");
      WorkCallable task2 = new WorkCallable("task2");
      FutureTask<String> task11 = new FutureTask<String>(task1);
      FutureTask<String> task22 = new FutureTask<String>(task2);
      Thread t1 =  new Thread(task11);
      Thread t2 =  new Thread(task22);
      t1.start();
      t2.start();
      System.out.println("task1的执行结果：" + task11.get());
      System.out.println("task2的执行结果：" + task22.get());
   }
}

 

执行代码，看下执行结果如何：

task1开始执行
task2开始执行
task2结束执行
task1结束执行
task1的执行结果：task1
task2的执行结果：task2

方法四：使用定时器，就是继承TimerTask 类：

翻看JDK的源码,能够看到，TimerTask 是一个实现了 Runnable 接口的抽象类，因此它跟Runnable接口的实现方式本质上是同样的。

任务实现类：

public class WorkTimer extends TimerTask {
   private String taskName;
   public WorkTimer(String taskName) {
      this.taskName = taskName;
   }
   @Override
   public void run() {
      System.out.println(taskName + "任务开始执行");
      try {
         Thread.sleep(3000);
      } catch (InterruptedException e) {
         e.printStackTrace();
      }
      System.out.println(taskName + "任务执行结束");
   }
}

主线程：

public class TimerClient {
   public static void main(String[] args) {
      WorkTimer task1 = new WorkTimer("task1");
      WorkTimer task2 = new WorkTimer("task2");
      Timer timer = new Timer();
      timer.schedule(task1,2000);
      timer.schedule(task2, 3000);
}
}