1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

package com.gs.demo1;

public class ThreadTest1 {

    public static void main(String[] args) {

        Thread t1 = new Thread(new Work(null),"线程t1");

        Thread t2 = new Thread(new Work(t1),"线程t2");

        Thread t3 = new Thread(new Work(t2),"线程t3");

        t1.start();

        t2.start();

        t3.start();        

    }

    static class Work implements Runnable{

        private Thread beforeThread;

        public Work(Thread beforeThread) {

            this.beforeThread = beforeThread;

        }

        @Override

        public void run() {

            if(beforeThread!=null) {

                try {

                    //某线程调用该方法，会让其他线程处于等待状态，让其运行完毕，再执行其他线程.  

                    beforeThread.join();

                    System.out.println("Thread start:"+Thread.currentThread().getName());

                }catch(Exception e){

                    e.printStackTrace();

                }

            }else {

                System.out.println("Thread start:"+Thread.currentThread().getName());

            }

        }

    }

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

package com.gs.demo2;

import java.util.concurrent.CountDownLatch;

public class ThreadTest2 {

    public static void main(String[] args) {

        CountDownLatch c1 = new CountDownLatch(0);//计数器为0

        CountDownLatch c2 = new CountDownLatch(1);//计数器为1

        CountDownLatch c3 = new CountDownLatch(1);//计数器为1

        Thread t1 = new Thread(new Work(c1, c2),"线程t1");

        //c1为0，t1线程可以执行。t1线程的计数器 c2 减1

        Thread t2 = new Thread(new Work(c2, c3),"线程t2");

        //t1的计数器c2为0时，t2才能执行。t2的计数器c3减1

        Thread t3 = new Thread(new Work(c3, c3),"线程t3");

        //t3的计数器c3为0时，t3才能执行

        t1.start();

        t2.start();

        t3.start();

    }

    //定义Work线程类，需要传入开始和结束的CountDownLatch参数

    static class Work implements Runnable {

        private CountDownLatch c1;

        private CountDownLatch c2;

        public Work(CountDownLatch c1, CountDownLatch c2) {

            super();

            this.c1 = c1;

            this.c2 = c2;

        }

        @Override

        public void run() {

             try {

                //当某个线程调用CountDownLatch对象的await方法时，将会阻塞，直到计数器的值变成0才放行。

                c1.await();

                System.out.println("thread start:" + Thread.currentThread().getName());

                c2.countDown(); //本线程计数器减 1

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }

}