多线程按顺序执行

_ext

已于 2022-10-29 20:41:07 修改

阅读量4.2k

点赞数

分类专栏：面试题文章标签：多线程顺序执行

于 2019-05-18 16:39:05 首次发布

本文链接：https://blog.csdn.net/hard_working1/article/details/90316379

版权

面试题专栏收录该内容

14 篇文章 0 订阅

订阅专栏

多线程安全

多个线程读写访问同一个数据时而产生不可预料的后果。

同步

一个线程访问数据未结束的时候，其他线程不得对同一数据进行访问。

下面使用了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();
  }
}

运行结果:

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

6.使用对象的wait和notify

public class ThreadTest {

    volatile static Thread t0, t1, t2;
    static boolean t1Run = false, t2Run = false; //定义n-1个运行条件
    static final Object lock1 = new Object();
    static final Object lock2 = new Object(); //定义n-1个锁资源

    @Test
    public void test() {

        threadInit();
        t2.start();
        t1.start();
        t0.start();
    }

    private static void threadInit() {
        t0 = new Thread(() -> {
            //t0执行
            synchronized (lock1) {
                System.out.println(Thread.currentThread().getName() + "执行");
                //通知t1执行
                t1Run = true;
                //释放lock1
                lock1.notify();
                System.out.println(Thread.currentThread().getName() + "执行完成");
            }

        });
        t1 = new Thread(() -> {
            synchronized (lock1) {
                while (!t1Run) {
                    try {
                        // lock1等待
                        System.out.println(Thread.currentThread().getName() + " t1 开始执行等待");
                        lock1.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread().getName() + "执行");
                synchronized (lock2) {
                    //通知t2执行
                    t2Run = true;
                    //释放lock2
                    lock2.notify();
                }
                System.out.println(Thread.currentThread().getName() + "执行完成");
            }

        });
        t2 = new Thread(() -> {
            synchronized (lock2) {
                System.out.println("t2 t2Run: " + t2Run);
                while (!t2Run) {
                    //t2执行
                    try {
                        //lock2等待
                        System.out.println(Thread.currentThread().getName() + " t2 开始执行等待");
                        lock2.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread().getName() + "执行完成");
            }

        });
    }
}

_ext

关注

0
点赞
踩
20

收藏

觉得还不错? 一键收藏
0
评论
多线程按顺序执行

一.前言本文使用了5中方法实现在多线程中让线程按顺序运行的方法，涉及到多线程中许多常用的方法，不止为了知道如何让线程按顺序运行，更是让读者对多线程的使用有更深刻的了解。使用的方法如下:[1] 使用线程的join方法 [2] 使用主线程的join方法 [3] 使用线程的线程池方法 [4] 使用线程的CountDownLatch(倒计数)方法 [5]使用线程的Semaphore(信...
复制链接

扫一扫