规定执行的子线程数
    只有满足所规定的子线程数都执行完毕后 主线程才能执行
    否则主线程会一直等待
    原理其实是通过-1操作来实现的 即使没有线程 直接执行-1操作也行
    直到将所规定的数减至0即可

    1.     public static void main(String[] args) throws Exception {
    3.         final CountDownLatch cdl = new CountDownLatch(4);
    4.         //这里定义四个子线程数
    5.         //每个线程执行完后 执行减一操作 直到减到0 主线程才能执行
    7.         new Thread(new Runnable() {
    8.             @Override
    9.             public void run() {
    10.                 try {
    11.                     Thread.sleep(3000);
    12.                 } catch (InterruptedException e) {
    13.                     e.printStackTrace();
    14.                 }
    15.                 System.out.println("购买海鲜");
    16.                 cdl.countDown();
    17.                 //执行-1操作
    18.             }
    19.         }).start();
    21.         new Thread(new Runnable() {
    22.             @Override
    23.             public void run() {
    24.                 System.out.println("购买牛羊肉");
    25.                 try {
    26.                     Thread.sleep(1000);
    27.                 } catch (InterruptedException e) {
    28.                     e.printStackTrace();
    29.                 }
    30.                 cdl.countDown();
    31.                 //执行-1操作
    32.             }
    33.         }).start();
    35.         new Thread(new Runnable() {
    36.             @Override
    37.             public void run() {
    38.                 System.out.println("购买火锅底料和蘸料");
    39.                 try {
    40.                     Thread.sleep(800);
    41.                 } catch (InterruptedException e) {
    42.                     e.printStackTrace();
    43.                 }
    44.                 cdl.countDown();
    45.                 //执行-1操作
    46.             }
    47.         }).start();
    49.         new Thread(new Runnable() {
    50.             @Override
    51.             public void run() {
    52.                 System.out.println("购买青菜");
    53.                 try {
    54.                     Thread.sleep(2000);
    55.                 } catch (InterruptedException e) {
    56.                     e.printStackTrace();
    57.                 }
    58.                 cdl.countDown();
    59.                 //执行-1操作
    60.             }
    61.         }).start();
    65.         // 等待食材购买完成
    66.         cdl.await();
    67.         //如果此时只有三个线程执行了减一操作 那么这个方法就会一直阻塞等待 直到执行了第四个减一操作
    68.         System.out.println("开始吃火锅！！");
    69.     }