多线程交替打印奇偶数

发表于 | 分类于 | | 阅读量
字数统计: 340 字 | 阅读时长 ≈ 1 分钟

题目

实现两个线程分别打印奇数和偶数，中间停顿1秒。

案例：

1
2
3
4
5
6
7
8
输出：
偶数：0
奇数：1
偶数：2
奇数：3
偶数：4
奇数：5
偶数：6

解法1

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
50
51
import java.util.concurrent.Semaphore;

// 使用Semaphore实现
public class PrintOddEven1 {
    private static volatile int num = 0;
    private static Semaphore semaphore = new Semaphore(1);

    public static void main(String[] args) {
        new Odd().start();
        new Even().start();
    }

    static class Odd extends Thread {
        @Override
        public void run() {
            while (true) {
                if (num % 2 != 0) {
                    try {
                        semaphore.acquire();
                        Thread.sleep(1000);
                        System.out.println("奇数：" + num++);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        semaphore.release();
                    }
                }

            }
        }
    }

    static class Even extends Thread {
        @Override
        public void run() {
            while (true) {
                if (num % 2 == 0) {
                    try {
                        semaphore.acquire();
                        Thread.sleep(1000);
                        System.out.println("偶数：" + num++);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        semaphore.release();
                    }
                }
            }
        }
    }
}

解法2

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
50
51
52
//使用锁对象实现
public class PrintOddEven2 {
    private static Object lock = new Object();
    private static int num = 0;

    public static void main(String[] args) {
        new OddThread().start();
        new EvenThread().start();
    }

    static class OddThread extends Thread {
        @Override
        public void run() {
            while (true) {
                synchronized (lock) {
                    if (num % 2 == 1) {
                        System.out.println("奇数线程:" + num++);
                    } else {
                        try {
                            Thread.sleep(1000);
                            lock.notify();
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }

    static class EvenThread extends Thread {
        @Override
        public void run() {
            while (true) {
                synchronized (lock) {
                    if (num % 2 == 0) {
                        System.out.println("偶数线程:" + num++);
                    } else {
                        try {
                            Thread.sleep(1000);
                            lock.notify();
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}