交替打印-Interleaving

目录

• 交替打印奇偶数
  
• 交替打印ABC
  
• 交替打印数字
  
• 总结与思考
  

交替打印奇偶数

标题概述

创建两个线程，一个打印奇数，一个打印偶数。要求两个线程交替输出，顺序打印出 1 2 3 4 5 ... 100。
解法一：synchronized + wait/notify

1. public class Main {
2.     private static final Object lock = new Object();
3.     private static int count = 1;
5.     public static void main(String[] args) {
6.         Thread odd = new Thread(() -> {
7.             while (count <= 100) {
8.                 synchronized (lock) {
9.                     if ((count & 1) == 0) {
10.                         try {
11.                             lock.wait();
12.                         } catch (InterruptedException e) {
13.                             e.printStackTrace();
14.                         }
15.                     } else {
16.                         System.out.println(Thread.currentThread().getName() + ": " + count);
17.                         count++;
18.                         lock.notify();
19.                     }
20.                 }
21.             }
22.         }, "ODD");
24.         Thread even = new Thread(() -> {
25.            while (count <= 100) {
26.                synchronized (lock) {
27.                    if ((count & 1) == 1) {
28.                        try {
29.                            lock.wait();
30.                        } catch (InterruptedException e) {
31.                            e.printStackTrace();
32.                        }
33.                    } else {
34.                        System.out.println(Thread.currentThread().getName() + ": " + count);
35.                        count++;
36.                        lock.notify();
37.                    }
38.                }
39.            }
40.         }, "EVEN");
43.         odd.start();
44.         even.start();
45.     }
46. }

复制代码

交替打印ABC

标题概述

创建三个线程，分别打印 "A"、"B"、"C"，要求按顺序交替输出 ABCABC...，共打印 10 次。
解法一：synchronized + wait/notify

1. import java.util.concurrent.Semaphore;
3. public class Main {
4.     static int count = 1;
5.     static Semaphore oddSemaphore = new Semaphore(1);
6.     static Semaphore evenSemaphore = new Semaphore(0);
8.     public static void main(String[] args) {
9.         new Thread(() -> {
10.             while (count <= 100) {
11.                 try {
12.                     oddSemaphore.acquire();
13.                     if (count > 100) break;
14.                     System.out.println(("ODD : " + count++));
15.                     evenSemaphore.release();
16.                 } catch (InterruptedException e) {
17.                     e.printStackTrace();
18.                 }
19.             }
20.         }).start();
22.         new Thread(() -> {
23.             while (count <= 100) {
24.                 try {
25.                     evenSemaphore.acquire();
26.                     if (count > 100) break;
27.                     System.out.println(("EVEN : " + count++));
28.                     oddSemaphore.release();
29.                 } catch (InterruptedException e) {
30.                     e.printStackTrace();
31.                 }
32.             }
33.         }).start();
34.     }
35. }

复制代码

解法二：ReentrantLock + Condition

1. public class Main {
2.     private static int state = 0;
3.     private static final Object lock = new Object();
5.     public static void main(String[] args) {
6.         int loop = 10;
7.         new Thread(() -> printLetter('A', 0, 10)).start();
8.         new Thread(() -> printLetter('B', 1, 10)).start();
9.         new Thread(() -> printLetter('C', 2, 10)).start();
10.     }
12.     private static void printLetter(char ch, int target, int loop) {
13.         for (int i = 0; i < loop;) {
14.             synchronized (lock) {
15.                 if (state != target) {
16.                     try {
17.                         lock.wait();
18.                     } catch (InterruptedException e) {
19.                         e.printStackTrace();
20.                     }
21.                 } else {
22.                     System.out.println(ch);
23.                     state = (state + 1) % 3;
24.                     lock.notifyAll();
25.                     i++;
26.                 }
27.             }
28.         }
29.     }
30. }

复制代码

交替打印数字

标题概述

用3个线程打印 1~100 的整数，要求3个线程按顺序轮流打印
解法一：synchronized + wait/notify

1. import java.util.concurrent.locks.*;
3. public class Main {
4.     private static int state = 0;
5.     private static final Lock lock = new ReentrantLock();
6.     private static final Condition A = lock.newCondition();
7.     private static final Condition B = lock.newCondition();
8.     private static final Condition C = lock.newCondition();
10.     public static void main(String[] args) {
11.         int loop = 10;
12.         new Thread(() -> print('A', 0, A, B, loop)).start();
13.         new Thread(() -> print('B', 1, B, C, loop)).start();
14.         new Thread(() -> print('C', 2, C, A, loop)).start();
15.     }
17.     private static void print(char ch, int target, Condition curr, Condition next, int loop) {
18.         for (int i = 0; i < loop;) {
19.             lock.lock();
20.             try {
21.                 while (state != target) {
22.                     curr.await();
23.                 }
24.                 System.out.println(ch);
25.                 state = (state + 1) % 3;
26.                 i++;
27.                 next.signal();
28.             } catch (InterruptedException e) {
29.                 e.printStackTrace();
30.             } finally {
31.                 lock.unlock();
32.             }
33.         }
34.     }
35. }

复制代码

解法二：ReentrantLock + Condition

1. public class Main {
2.     private static int count = 1;
3.     private static final Object lock = new Object();
5.     public static void main(String[] args) {
6.         for (int i = 0; i < 3; i++) {
7.             int id = i;
8.             new Thread(() -> {
9.                 while (true) {
10.                     synchronized (lock) {
11.                         if (count > 100) break;
12.                         if (count % 3 != id) {
13.                             try {
14.                                 lock.wait();
15.                             } catch (InterruptedException e) {
16.                                 e.printStackTrace();
17.                             }
18.                         } else {
19.                             System.out.println(count++);
20.                             lock.notifyAll();
21.                         }
22.                     }
23.                 }
24.             }).start();
25.         }
26.     }
27. }

复制代码

总结与思考

• 用while (true)
  
• 及时开释锁制止死锁
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。