使用多线程交替打印123123123…

方法一：使用Lock lock = new ReentrantLock();

  1.     `lock.lock();`
  3.     `lock.unlock();`
  1. package junhaox.cn.interview;
  3. import java.io.File;
  4. import java.io.FileNotFoundException;
  5. import java.io.PrintStream;
  6. import java.io.PrintWriter;
  7. import java.util.concurrent.locks.Condition;
  8. import java.util.concurrent.locks.Lock;
  9. import java.util.concurrent.locks.ReentrantLock;
  11. /**
  12.  * 多线程交替打印123123123...
  13.  * 方法1
  14.  * @author wjh
  15.  *
  16.  */
  18. public class LoopPrint {
  20.     // 从1 开始打印
  21.     int num = 1;
  22.     Lock lock = new ReentrantLock();
  23.     // 三个线程的通知
  24.     Condition condition1 = lock.newCondition();
  25.     Condition condition2 = lock.newCondition();
  26.     Condition condition3 = lock.newCondition();
  29.     public void print1() {
  30.         // 加锁防止多个线程同时操作num
  31.         lock.lock();
  33.         try {
  34.             if (num != 1) {
  35.                 condition1.await();
  36.             }
  37.             System.out.println(Thread.currentThread().getName()+num);
  38. //            Thread.sleep(1000);
  39.             // 通知线程2
  40.             num = 2;
  41.             condition2.signal();
  43.         } catch (InterruptedException e) {
  44.             e.printStackTrace();
  45.         }finally {
  46.             // 使用完毕记得释放锁
  47.             lock.unlock();
  48.         }
  50.     }
  52.     public void print2() {
  53.         // 加锁防止多个线程同时操作num
  54.         lock.lock();
  56.         try {
  57.             if (num != 2) {
  58.                 condition2.await();
  59.             }
  60.             System.out.println(Thread.currentThread().getName()+num);
  61. //            Thread.sleep(1000);
  62.             // 通知线程3
  63.             num = 3;
  64.             condition3.signal();
  66.         } catch (InterruptedException e) {
  67.             e.printStackTrace();
  68.         }finally {
  69.             lock.unlock();
  70.         }
  72.     }
  74.     public void print3() {
  75.         // 加锁防止多个线程同时操作num
  76.         lock.lock();
  78.         try {
  79.             if (num != 3) {
  80.                 condition3.await();
  81.             }
  82.             System.out.println(Thread.currentThread().getName()+num);
  83. //            Thread.sleep(1000);
  84.             // 通知线程1
  85.             num = 1;
  86.             condition1.signal();
  88.         } catch (InterruptedException e) {
  89.             e.printStackTrace();
  90.         }finally {
  91.             lock.unlock();
  92.         }
  94.     }
  96.     public static void main(String[] args) {
  97.         LoopPrint print = new LoopPrint();
  98. //        System.out.println(111);
  99.         new Thread(()->{
  100.             while (true) {
  101.                 print.print1();
  102.             }
  103.         }).start();
  105.         new Thread(()->{
  106.             while (true) {
  107.                 print.print2();
  108.             }
  109.         }).start();
  111.         new Thread(()->{
  112.             while (true) {
  113.                 print.print3();
  114.             }
  115.         }).start();
  116.     }
  118. }

方法二：使用synchronized wait()和notify()

  1. package junhaox.cn.interview;
  3. import java.io.FileNotFoundException;
  4. import java.io.PrintStream;
  6. /**
  7.  * 多线程交替打印123123123...
  8.  * 方法1
  9.  * @author wjh
  10.  *
  11.  */
  13. public class SnyLoopPrint {
  14.     int num = 1;
  17.     synchronized public void print1() {
  20.         try {
  21.             if (num != 1) {
  22.                 System.out.println("线程1进入等待");
  23.                 this.wait();
  24.             }else {
  25.                 System.out.println(Thread.currentThread().getName()+num);
  26. //                Thread.sleep(1000);
  27.                 // 通知线程2
  28.                 num = 2;
  29.                 this.notifyAll();
  30.             }
  33.         } catch (InterruptedException e) {
  34.             e.printStackTrace();
  35.         }
  37.     }
  39.     synchronized public void print2() {
  42.             try {
  43.                 if (num != 2) {
  44.                     System.out.println("线程2进入等待");
  45.                     this.wait();
  46.                 }else {
  47.                     System.out.println(Thread.currentThread().getName()+num);
  48. //                    Thread.sleep(1000);
  49.                     // 通知线程3
  50.                     num = 3;
  51.                     this.notifyAll();
  52.                 }
  55.             } catch (InterruptedException e) {
  56.                 e.printStackTrace();
  57.             }
  59.         }
  61.     synchronized public void print3() {
  64.         try {
  65.             if (num != 3) {
  66.                 System.out.println("线程3进入等待");
  67.                 this.wait();
  68.             }else {
  69.                 System.out.println(Thread.currentThread().getName()+num);
  70. //                Thread.sleep(1000);
  71.                 // 通知线程1
  72.                 num = 1;
  73.                 this.notifyAll();
  74.             }
  77.         } catch (InterruptedException e) {
  78.             e.printStackTrace();
  79.         }
  81.     }
  84.     public static void main(String[] args) {
  85.         SnyLoopPrint print = new SnyLoopPrint(1);
  86. //        System.out.println(111);
  87.         new Thread(()->{
  88.             while (true) {
  89.                 print.print1();
  90.             }
  91.         }).start();
  93.         new Thread(()->{
  94.             while (true) {
  95.                 print.print2();
  96.             }
  97.         }).start();
  99.         new Thread(()->{
  100.             while (true) {
  101.                 print.print3();
  102.             }
  103.         }).start();
  104.     }
  106. }

注意：使用方法一和二时一定是先修改num的值在进行通知

方法三：使用信号量的方式Semaphore sm1 = new Semaphore(1);

  1. package junhaox.cn.interview;
  3. import java.util.concurrent.Semaphore;
  5. public class SemaphoreDemo {
  6.     // 
  7.     Semaphore sm1 = new Semaphore(1);
  8.     Semaphore sm2 = new Semaphore(0);
  9.     Semaphore sm3 = new Semaphore(0);
  11.     private void print(int value, Semaphore current, Semaphore next) {
  12.         try {
  13.             // 获取管道（总共只有1个），用完就停
  14.             current.acquire(1);
  15.             System.out.println(Thread.currentThread().getName()+"----"+value);
  16.             Thread.sleep(1000);
  17.             // 释放一个管道，谁释放谁拿
  18.             next.release(1);
  19.         } catch (InterruptedException e) {
  20.             e.printStackTrace();
  21.         }
  22.     }
  24.     public void print1() {
  25.         print(1, sm1, sm2);
  26.     }
  27.     public void print2() {
  28.         print(2, sm2, sm3);
  29.     }
  30.     public void print3() {
  31.         print(3, sm3, sm1);
  32.     }
  35.     public static void main(String[] args) {
  36.         SemaphoreDemo sd = new SemaphoreDemo();
  37.         new Thread(()->{
  38.             while (true) {
  39.                 sd.print1();
  40.             }
  41.         }).start();
  43.         new Thread(()->{
  44.             while (true) {
  45.                 sd.print2();
  46.             }
  47.         }).start();
  49.         new Thread(()->{
  50.             while (true) {
  51.                 sd.print3();
  52.             }
  53.         }).start();
  54.     }
  56. }