两个线程交替打印0~100

synchronized

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
public class JUCTest {

    private static final Object monitor = new Object();
    private static volatile int count = 0;
    private static final int MAX = 100;

    public static void main(String[] args) {
        Thread t1 = new Thread(new Print(), "thread-1");
        Thread t2 = new Thread(new Print(), "thread-2");
        t1.start();
        t2.start();
    }

    static class Print implements Runnable {

        @Override
        public void run() {
            while (count <= MAX) {
                synchronized (monitor) {
                    try {
                        if (count <= MAX) {
                            System.out.println(Thread.currentThread().getName() + ": " + count);
                            count++;
                        }
                        monitor.notifyAll();
                        monitor.wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }

        }
    }
}

ReentrantLock

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
public class JUCTest {

    private static volatile int count = 0;
    private static final int MAX = 100;
    
    private static final ReentrantLock lock = new ReentrantLock();
    private static final Condition condition = lock.newCondition();

    public static void main(String[] args) {
        Thread t1 = new Thread(new Print(), "thread-1");
        Thread t2 = new Thread(new Print(), "thread-2");
        t1.start();
        t2.start();
    }

    static class Print implements Runnable {

        @Override
        public void run() {
            while (count <= MAX) {
                lock.lock();
                try {
                    if (count <= MAX) {
                        System.out.println(Thread.currentThread().getName() + ": " + count);
                        count++;
                    }
                    condition.signalAll();
                    condition.await();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }

        }
    }
}

三个线程交替打印0~100

synchronized

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
48
49
// synchronized + Monitor
public class JUCTest {

    private static final Object monitor = new Object();
    private static volatile int count = 0;
    private static final int MAX = 100;

    public static void main(String[] args) {
        Thread t1 = new Thread(new Print(0));
        Thread t2 = new Thread(new Print(1));
        Thread t3 = new Thread(new Print(2));
        t1.start();
        t2.start();
        t3.start();
    }

    static class Print implements Runnable {

        private final int seq;

        public Print(int seq) {
            this.seq = seq;
        }

        @Override
        public void run() {
            while (count <= MAX){
                synchronized (monitor) {
                    // 注意这里是 while，不是 if
                    while (count % 3 != seq) {
                        try {
                            monitor.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                    if(count <= MAX){
                        System.out.println("thread-" + seq + ": " + count);
                        count++;
                    }
                    monitor.notifyAll();
                }
            }

        }
    }
}


ReentrantLock

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
48
49
// ReentrantLock + Condition
public class JUCTest {

    private static volatile int count = 0;
    private static final int MAX = 100;

    private static final ReentrantLock lock = new ReentrantLock();
    private static final Condition condition = lock.newCondition();


    public static void main(String[] args) {
        Thread t1 = new Thread(new Print(0));
        Thread t2 = new Thread(new Print(1));
        Thread t3 = new Thread(new Print(2));
        t1.start();
        t2.start();
        t3.start();
    }

    static class Print implements Runnable {

        private final int seq;

        public Print(int seq) {
            this.seq = seq;
        }

        @Override
        public void run() {
            while (count <= MAX) {
                lock.lock();
                // 注意这里是 while，不是 if
                while (count % 3 != seq) {
                    try {
                        condition.await();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
                if (count <= MAX) {
                    System.out.println("thread-" + seq + ": " + count);
                    count++;
                }
                condition.signalAll();
            }
        }

    }
}