多线程按顺序执行

目录

线程的join方法

主线程的join方法

线程池方法

线程的CountDownLatch（倒计数）方法

semaphore(信号量)实现线程按顺序运行

---

 

本文使用了5种方法实现在多线程中让线程按顺序运行的方法，涉及到多线程中许多常用的方法，不止为了知道如何让线程按顺序运行，更是让读者对多线程的使用有更深刻的了解。 使用的方法如下:

我们下面需要完成这样一个应用场景：

1.早上；2.测试人员、产品经理、开发人员陆续的来公司上班；3.产品经理规划新需求；4.开发人员开发新需求功能；5.测试人员测试新功能。

规划需求，开发需求新功能，测试新功能是一个有顺序的，我们把thread1看做产品经理，thread2看做开发人员，thread3看做测试人员。

1.使用线程的join方法

join(): 是Theard的方法，作用是当前线程需等待thread.join()的thread线程执行完成后，才能继续往下运行。

应用场景：当一个线程必须等待另一个线程执行完毕才能执行时可以使用join方法。

public class ThreadJoinDemo {

  private final Thread thread1 = new Thread(new Runnable() {
    @Override
    public void run() {
      System.out.println("产品经理规划新需求");
    }
  });

  private final Thread thread2 = new Thread(new Runnable() {
    @Override
    public void run() {
      try {
        // Waits for this thread to die
        thread1.join();
        System.out.println("开发人员开发新需求功能");
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  });

  private Thread thread3 = new Thread(new Runnable() {
    @Override
    public void run() {
      try {
        // Waits for this thread to die
        thread2.join();
        System.out.println("测试人员测试新功能");
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  });

  public void invoke() {
    System.out.println("早上：");
    System.out.println("产品经理来上班了...");
    thread1.start();
    System.out.println("开发人员来上班了...");
    thread2.start();
    System.out.println("测试人员来上班了...");
    thread3.start();
  }
}

运行结果:

早上：
产品经理来上班了...
开发人员来上班了...
产品经理规划新需求
测试人员来上班了...
开发人员开发新需求功能
测试人员测试新功能

2.使用主线程的join方法

这里是在主线程中使用join()来实现对线程的阻塞。

public class ThreadMainJoinDemo {

  private final Thread thread1 = new Thread(new Runnable() {
    @Override
    public void run() {
      System.out.println("产品经理正在规划新需求");
    }
  });

  private final Thread thread2 = new Thread(new Runnable() {
    @Override
    public void run() {
      System.out.println("开发人员开发新需求功能");
    }
  });

  private final Thread thread3 = new Thread(new Runnable() {
    @Override
    public void run() {
      System.out.println("测试人员测试新功能");
    }
  });

  public void invoke() throws InterruptedException {

    System.out.println("早上:");
    System.out.println("产品经理来上班了");
    System.out.println("测试人员来上班了");
    System.out.println("开发人员来上班了");
    thread1.start();
    //在当前线程调用子线程的join()方法后，当前线程需要等待子线程运行完后再继续运行。
    System.out.println("开发人员和测试人员休息会...");
    thread1.join();
    thread2.start();
    System.out.println("测试人员休息会...");
    thread2.join();
    thread3.start();
  }
}

运行结果:

早上:
产品经理来上班了
测试人员来上班了
开发人员来上班了
开发人员和测试人员休息会...
产品经理正在规划新需求
测试人员休息会...
开发人员开发新需求功能
测试人员测试新功能

3.使用线程池方法

JAVA通过Executors提供了四种线程池

• 单线程化线程池(newSingleThreadExecutor);
• 可控最大并发数线程池(newFixedThreadPool);
• 可回收缓存线程池(newCachedThreadPool);
• 支持定时与周期性任务的线程池(newScheduledThreadPool)。

单线程化线程池(newSingleThreadExecutor):优点，串行执行所有任务。

submit()：提交任务。

shutdown()：方法用来关闭线程池，拒绝新任务。

应用场景:串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

public class ThreadPoolDemo {

  static ExecutorService executorService = Executors.newSingleThreadExecutor();

  public static void invoke() throws Exception {

    final Thread thread1 = new Thread(new Runnable() {
      @Override
      public void run() {
        System.out.println("产品经理规划新需求");
      }
    });

    final Thread thread2 = new Thread(new Runnable() {
      @Override
      public void run() {
        System.out.println("开发人员开发新需求功能");
      }
    });

    Thread thread3 = new Thread(new Runnable() {
      @Override
      public void run() {
        System.out.println("测试人员测试新功能");
      }
    });

    System.out.println("早上：");
    System.out.println("产品经理来上班了");
    System.out.println("测试人员来上班了");
    System.out.println("开发人员来上班了");
    System.out.println("领导吩咐:");
    System.out.println("首先，产品经理规划新需求...");
    executorService.submit(thread1);
    System.out.println("然后，开发人员开发新需求功能...");
    executorService.submit(thread2);
    System.out.println("最后，测试人员测试新功能...");
    executorService.submit(thread3);
    executorService.shutdown();
  }
}

运行结果:

早上：
产品经理来上班了
测试人员来上班了
开发人员来上班了
领导吩咐:
首先，产品经理规划新需求...
然后，开发人员开发新需求功能...
最后，测试人员测试新功能...
产品经理规划新需求
开发人员开发新需求功能
测试人员测试新功能

4.使用线程的CountDownLatch（倒计数）方法

CountDownLatch:位于java.util.concurrent包下，利用它可以实现类似计数器的功能。

应用场景:比如有一个任务C，它要等待其他任务A、B执行完毕之后才能执行，此时就可以利用CountDownLatch来实现这种功能了。

此方法可以扩展为new CountDownLatch(n),每个线程执行完成后c.countDown(), 等n个线程执行完成后才执行主线程的方式来处理等待执行的需求.

public class ThreadCountDownLatchDemo {

  /** 用于判断线程一是否执行，倒计时设置为1，执行后减1 */
  private static CountDownLatch c1 = new CountDownLatch(1);

  /** 用于判断线程二是否执行，倒计时设置为1，执行后减1 */
  private static CountDownLatch c2 = new CountDownLatch(1);

  public static void invoke() {
    final Thread thread1 = new Thread(new Runnable() {
      @Override
      public void run() {
        System.out.println("产品经理规划新需求");
        // 对c1倒计时-1
        c1.countDown();
      }
    });

    final Thread thread2 = new Thread(new Runnable() {
      @Override
      public void run() {
        try {
          // 等待c1倒计时，计时为0则往下运行
          c1.await();
          System.out.println("开发人员开发新需求功能");
          // 对c2倒计时-1
          c2.countDown();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    });

    Thread thread3 = new Thread(new Runnable() {
      @Override
      public void run() {
        try {
          // 等待c2倒计时，计时为0则往下运行
          c2.await();
          System.out.println("测试人员测试新功能");
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    });

    System.out.println("早上：");
    System.out.println("测试人员来上班了...");
    thread3.start();
    System.out.println("产品经理来上班了...");
    thread1.start();
    System.out.println("开发人员来上班了...");
    thread2.start();
  }
}

运行结果:

早上：
测试人员来上班了...
产品经理来上班了...
开发人员来上班了...
产品经理规划新需求
开发人员开发新需求功能
测试人员测试新功能

5.使用semaphore(信号量)实现线程按顺序运行

semaphore(信号量): semaphore是一个计数信号量,从概念上讲，semaphore包含一组许可证, 如果有需要的话，每个acquire()方法都会阻塞，直到获取一个可用的许可证, 每个release()方法都会释放持有许可证的线程，并且归还semaphore一个可用的许可证。然而，实际上并没有真实的许可证对象供线程使用，semaphore只是对可用的数量进行管理维护。

acquire():当前线程尝试去阻塞的获取1个许可证, 此过程是阻塞的,当前线程获取了1个可用的许可证，则会停止等待，继续执行。 

release():当前线程释放1个可用的许可证。

应用场景:Semaphore可以用来做流量分流，特别是对公共资源有限的场景，比如数据库连接。假设有这个的需求，读取几万个文件的数据到数据库中，由于文件读取是IO密集型任务，可以启动几十个线程并发读取，但是数据库连接数只有10个，这时就必须控制最多只有10个线程能够拿到数据库连接进行操作。这个时候，就可以使用Semaphore做流量控制。

public class SemaphoreDemo {

  private static Semaphore semaphore1 = new Semaphore(1);
  private static Semaphore semaphore2 = new Semaphore(1);

  public static void invoke() {
    final Thread thread1 = new Thread(new Runnable() {
      @Override
      public void run() {
        System.out.println("产品经理规划新需求");
        semaphore1.release();
      }
    });

    final Thread thread2 = new Thread(new Runnable() {
      @Override
      public void run() {
        try {
          semaphore1.acquire();
          System.out.println("开发人员开发新需求功能");
          semaphore2.release();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    });

    Thread thread3 = new Thread(new Runnable() {
      @Override
      public void run() {
        try {
          semaphore2.acquire();
          thread2.join();
          System.out.println("测试人员测试新功能");
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    });

    System.out.println("早上：");
    System.out.println("产品经理来上班了...");
    thread1.start();
    System.out.println("开发人员来上班了...");
    thread2.start();
    System.out.println("测试人员来上班了...");
    thread3.start();
  }
}

运行结果:

早上：
产品经理来上班了...
开发人员来上班了...
产品经理规划新需求
测试人员来上班了...
开发人员开发新需求功能
测试人员测试新功能