2020年11月10日 面试蚂蚁金服时遇到的原题，可以用多种同步实现，适合拿出来热身。

自旋

  1. class FooBar {
  2.     private int n;
  4.     public FooBar(int n) {
  5.         this.n = n;
  6.     }
  8.     volatile boolean permitFoo = true;
  10.     public void foo(Runnable printFoo) throws InterruptedException {     
  11.         for (int i = 0; i < n; ) {
  12.             if(permitFoo) {
  13.                 printFoo.run();
  14.                 i++;
  15.                 permitFoo = false;
  16.             }else{
  17.                 Thread.yield();
  18.             }
  19.         }
  20.     }
  22.     public void bar(Runnable printBar) throws InterruptedException {       
  23.         for (int i = 0; i < n; ) {
  24.             if(!permitFoo) {
  25.             printBar.run();
  26.             i++;
  27.             permitFoo = true;
  28.             }else{
  29.                 Thread.yield();
  30.             }
  31.         }
  32.     }
  33. }

synchronized

  1. class FooBar {
  2.     private int n;
  4.     public FooBar(int n) {
  5.         this.n = n;
  6.     }
  8.     // 标志位，控制执行顺序，true执行printFoo，false执行printBar
  9.     private volatile boolean type = true;
  10.     private final Object foo=  new Object(); // 锁标志
  12.     public void foo(Runnable printFoo) throws InterruptedException {
  13.         for (int i = 0; i < n; i++) {
  14.             synchronized (foo) {
  15.                 while(!type){
  16.                     foo.wait();
  17.                 }
  18.                 printFoo.run();
  19.                 type = false;
  20.                 foo.notifyAll();
  21.             }
  22.         }
  23.     }
  25.     public void bar(Runnable printBar) throws InterruptedException {
  26.         for (int i = 0; i < n; i++) {
  27.             synchronized (foo) {
  28.                 while(type){
  29.                     foo.wait();
  30.                 }
  31.                 printBar.run();
  32.                 type = true;
  33.                 foo.notifyAll();
  34.             }
  35.         }
  36.     }
  37. }

可重入锁

  1. class FooBar {
  2.     private int n;
  4.     public FooBar(int n) {
  5.         this.n = n;
  6.     }
  8.     Lock lock = new ReentrantLock(true);
  9.     private final Condition foo = lock.newCondition();
  10.     volatile boolean flag = true;
  11.     public void foo(Runnable printFoo) throws InterruptedException {
  12.         for (int i = 0; i < n; i++) {
  13.             lock.lock();
  14.             try {
  15.               while(!flag) {
  16.                     foo.await();
  17.                 }
  18.                 printFoo.run();
  19.                 flag = false;
  20.                 foo.signal();
  21.             } finally {
  22.               lock.unlock();
  23.             }
  24.         }
  25.     }
  27.     public void bar(Runnable printBar) throws InterruptedException {
  28.         for (int i = 0; i < n;i++) {
  29.             lock.lock();
  30.             try {
  31.               while(flag) {
  32.                   foo.await();
  33.               }
  34.               printBar.run();
  35.               flag = true;
  36.               foo.signal();
  37.             } finally {
  38.               lock.unlock();
  39.             }
  40.         }
  41.     }
  42. }

循环栅栏

  1. class FooBar {
  2.     private int n;
  3.     public FooBar(int n) {
  4.         this.n = n;
  5.     }
  7.     CyclicBarrier cb = new CyclicBarrier(2);
  8.     volatile boolean fin = true;
  10.     public void foo(Runnable printFoo) throws InterruptedException {
  11.         for (int i = 0; i < n; i++) {
  12.             while(!fin);
  13.             printFoo.run();
  14.             fin = false;
  15.             try {
  16.                 cb.await();
  17.             } catch (BrokenBarrierException e) {}
  18.         }
  19.     }
  21.     public void bar(Runnable printBar) throws InterruptedException {
  22.         for (int i = 0; i < n; i++) {
  23.             try {
  24.                 cb.await();
  25.             } catch (BrokenBarrierException e) {}
  26.             printBar.run();
  27.             fin = true;
  28.         }
  29.     }
  30. }

信号量

  1. class FooBar {
  2.     private int n;
  4.     public FooBar(int n) {
  5.         this.n = n;
  6.     }
  7.     private Semaphore foo = new Semaphore(1);
  8.     private Semaphore bar = new Semaphore(0);
  9.     public void foo(Runnable printFoo) throws InterruptedException {
  10.         for (int i = 0; i < n; i++) {
  11.             foo.acquire();
  12.             printFoo.run();
  13.             bar.release();
  14.         }
  15.     }
  16.     public void bar(Runnable printBar) throws InterruptedException {
  17.         for (int i = 0; i < n; i++) {
  18.             bar.acquire();
  19.             printBar.run();
  20.             foo.release();
  21.         }
  22.     }
  23. }

阻塞队列

  1. public class FooBar {
  2.     private int n;
  3.     private BlockingQueue<Integer> bar = new LinkedBlockingQueue<>(1);
  4.     private BlockingQueue<Integer> foo = new LinkedBlockingQueue<>(1);
  5.     public FooBar(int n) {
  6.         this.n = n;
  7.     }
  8.     public void foo(Runnable printFoo) throws InterruptedException {
  9.         for (int i = 0; i < n; i++) {
  10.             foo.put(i);
  11.             printFoo.run();
  12.             bar.put(i);
  13.         }
  14.     }
  16.     public void bar(Runnable printBar) throws InterruptedException {
  17.         for (int i = 0; i < n; i++) {
  18.             bar.take();
  19.             printBar.run();
  20.             foo.take();
  21.         }
  22.     }
  23. }

参考文献