Leetcode 1115.交替打印FooBar

  1. public class FooBar {
  2.   private int n;
  3.   private  volatile boolean flag;
  4.     public FooBar(int n) {
  5.         this.n = n;
  6.     }
  9.     public static void main(String[] args) {
  10.         FooBar main=new FooBar(10);
  11.         //用匿名内部类创建一个线程打印foo
  12.         new Thread(()->{
  13.             try {
  14.                 main.foo(()->System.out.println("foo"));
  15.             } catch (InterruptedException e) {
  16.                 // TODO Auto-generated catch block
  17.                 e.printStackTrace();
  18.             }
  19.         }).start();
  21.         //用匿名内部类创建一个线程打印bar
  22.         new Thread(()->{
  23.             try {
  24.                 main.bar(()->System.out.println("bar"));
  25.             } catch (InterruptedException e) {
  26.                 // TODO Auto-generated catch block
  27.                 e.printStackTrace();
  28.             }
  29.         }).start();
  31.     }
  35.     //手太阴肺经 BLOCKING Queue
  37.         private BlockingQueue<Integer> bar = new ArrayBlockingQueue<>(1);
  38.         private BlockingQueue<Integer> foo = new ArrayBlockingQueue<>(1);
  40.         public void foo(Runnable printFoo) throws InterruptedException {
  41.             for (int i = 0; i < n; i++) {
  42.                 foo.put(i);
  43.                 printFoo.run();
  44.                 bar.put(i);
  45.             }
  46.         }
  48.         public void bar(Runnable printBar) throws InterruptedException {
  49.             for (int i = 0; i < n; i++) {
  50.                 bar.take();
  51.                 printBar.run();
  52.                 foo.take();
  53.             }
  54.         }
  57.     //手阳明大肠经CyclicBarrier 控制先后
  58.     class FooBar6 {
  59.         private int n;
  61.         public FooBar6(int n) {
  62.             this.n = n;
  63.         }
  65.         CyclicBarrier cb = new CyclicBarrier(2);
  66.         volatile boolean fin = true;
  68.         public void foo(Runnable printFoo) throws InterruptedException {
  69.             for (int i = 0; i < n; i++) {
  70.                 while(!fin);
  71.                 printFoo.run();
  72.                 fin = false;
  73.                 try {
  74.                     cb.await();
  75.                 } catch (BrokenBarrierException e) {}
  76.             }
  77.         }
  79.         public void bar(Runnable printBar) throws InterruptedException {
  80.             for (int i = 0; i < n; i++) {
  81.                 try {
  82.                     cb.await();
  83.                 } catch (BrokenBarrierException e) {}
  84.                 printBar.run();
  85.                 fin = true;
  86.             }
  87.         }
  88.     }
  90.     //手少阴心经 自旋 + 让出CPU
  91.     class FooBar5 {
  92.         private int n;
  94.         public FooBar5(int n) {
  95.             this.n = n;
  96.         }
  98.         volatile boolean permitFoo = true;
  100.         public void foo(Runnable printFoo) throws InterruptedException {
  101.             for (int i = 0; i < n; ) {
  102.                 if(permitFoo) {
  103.                     printFoo.run();
  104.                     i++;
  105.                     permitFoo = false;
  106.                 }else{
  107.                     Thread.yield();
  108.                 }
  109.             }
  110.         }
  112.         public void bar(Runnable printBar) throws InterruptedException {
  113.             for (int i = 0; i < n; ) {
  114.                 if(!permitFoo) {
  115.                     printBar.run();
  116.                     i++;
  117.                     permitFoo = true;
  118.                 }else{
  119.                     Thread.yield();
  120.                 }
  121.             }
  122.         }
  123.     }
  127.     //手少阳三焦经 可重入锁 + Condition
  128.     class FooBar4 {
  129.         private int n;
  131.         public FooBar4(int n) {
  132.             this.n = n;
  133.         }
  134.         Lock lock = new ReentrantLock(true);
  135.         private final Condition foo = lock.newCondition();
  136.         volatile boolean flag = true;
  137.         public void foo(Runnable printFoo) throws InterruptedException {
  138.             for (int i = 0; i < n; i++) {
  139.                 lock.lock();
  140.                 try {
  141.                     while(!flag) {
  142.                         foo.await();
  143.                     }
  144.                     printFoo.run();
  145.                     flag = false;
  146.                     foo.signal();
  147.                 }finally {
  148.                     lock.unlock();
  149.                 }
  150.             }
  151.         }
  153.         public void bar(Runnable printBar) throws InterruptedException {
  154.             for (int i = 0; i < n;i++) {
  155.                 lock.lock();
  156.                 try {
  157.                     while(flag) {
  158.                         foo.await();
  159.                     }
  160.                     printBar.run();
  161.                     flag = true;
  162.                     foo.signal();
  163.                 }finally {
  164.                     lock.unlock();
  165.                 }
  166.             }
  167.         }
  168.     }
  170.     //手厥阴心包经 synchronized + 标志位 + 唤醒
  171.     class FooBar3 {
  172.         private int n;
  173.         // 标志位，控制执行顺序，true执行printFoo，false执行printBar
  174.         private volatile boolean type = true;
  175.         private final Object foo=  new Object(); // 锁标志
  177.         public FooBar3(int n) {
  178.             this.n = n;
  179.         }
  180.         public void foo(Runnable printFoo) throws InterruptedException {
  181.             for (int i = 0; i < n; i++) {
  182.                 synchronized (foo) {
  183.                     while(!type){
  184.                         foo.wait();
  185.                     }
  186.                     printFoo.run();
  187.                     type = false;
  188.                     foo.notifyAll();
  189.                 }
  190.             }
  191.         }
  193.         public void bar(Runnable printBar) throws InterruptedException {
  194.             for (int i = 0; i < n; i++) {
  195.                 synchronized (foo) {
  196.                     while(type){
  197.                         foo.wait();
  198.                     }
  199.                     printBar.run();
  200.                     type = true;
  201.                     foo.notifyAll();
  202.                 }
  203.             }
  204.         }
  205.     }
  208.     //手太阳小肠经 信号量 适合控制顺序
  209.     class FooBar2 {
  210.         private int n;
  211.         private Semaphore foo = new Semaphore(1);
  212.         private Semaphore bar = new Semaphore(0);
  213.         public FooBar2(int n) {
  214.             this.n = n;
  215.         }
  217.         public void foo(Runnable printFoo) throws InterruptedException {
  218.             for (int i = 0; i < n; i++) {
  219.                 foo.acquire();
  220.                 printFoo.run();
  221.                 bar.release();
  222.             }
  223.         }
  224.         public void bar(Runnable printBar) throws InterruptedException {
  225.             for (int i = 0; i < n; i++) {
  226.                 bar.acquire();
  227.                 printBar.run();
  228.                 foo.release();
  229.             }
  230.         }
  231.     }
  234. }