title: Phaser Synchronization Usage
body: <h1>General Question</h1>
  
  <p>It is well known that Phaser can be used to synchronize the start time of all tasks as mentioned in the <a href="https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Phaser.html" rel="nofollow">JavaDocs</a> and <a href="http://niklasschlimm.blogspot.hk/2011/12/java-7-understanding-phaser.html" rel="nofollow">this blog</a> by Niklas Schlimm.</p>
  
  <p>Niklas has drawn a pretty understandable image of the synchronization:</p>
  
  <pre><code>         |Phaser   |Phaser   |Phaser   |  
  Task 1   | ------&gt; | ------&gt; | ------&gt; | ...
  Task 2   | ------&gt; | ------&gt; | ------&gt; | ...
  ...
  </code></pre>
  
  <p>Now supposed there is a hierarchy of tasks:</p>
  
  <pre><code>         |Phaser   |Phaser   |Phaser   |Phaser   |Phaser   |Phaser   |Phaser   |   ...
  Master   |         |         | ------&gt; |         |         | ------&gt; |         |   ...
  Task 1.1 | ----------------&gt; |         | ----------------&gt; |         | ----------&gt; ...
  Task 1.2 | ----------------&gt; |         | ----------------&gt; |         | ----------&gt; ...
  ...      |         |         |         |         |         |         |         |   ...
  Task 2.1 | ------&gt; |         |         | ------&gt; |         |         | ------&gt; |   ...
  Task 2.2 | ------&gt; |         |         | ------&gt; |         |         | ------&gt; |   ...
  ...      |         |         |         |         |         |         |         |   ...
  Task 3.1 |         | ------&gt; |         |         | ------&gt; |         |         |   ...
  Task 3.2 |         | ------&gt; |         |         | ------&gt; |         |         |   ...
  ...      |         |         |         |         |         |         |         |   ...
  </code></pre>
  
  <p>So the tree of dependencies is like this:</p>
  
  <pre><code>                      Master
             /-----------/  \-----------\
             |                        Task 2 
           Task 1                       |
             |                        Task 3
             \-----------\  /-----------/
                        Master'
  </code></pre>
  
  <p>In a general case, there is a tree of dependencies to solve (let's say in a game pipeline, some are AI / game logic / render tasks). Luckily there is a "big" synchronization point and the tree is fixed (but not the number of parties). It is trivial to solve with several phasers. But is it possible to use only one phaser?</p>
  
  <h1>One Special Case</h1>
  
  <p>Specifically, I made a program to solve the following problem.</p>
  
  <pre><code>         |phasers[0]|phasers[1]|phasers[2]|phasers[0]|phasers[1]|phasers[2]| ...
  Task 1   | -------&gt; |          |          | -------&gt; |          |          | ...
  Task 2   | -------&gt; |          |          | -------&gt; |          |          | ...
  Task 3   |          |          | -------&gt; |          |          | -------&gt; | ...
  Task 4   |          | -------&gt; |          |          | -------&gt; |          | ...
  </code></pre>
  
  <p>Code here:</p>
  
  <pre><code>public class VolatileTester {
  
      private int a = 0, b = 0;       // change to volatile here
      private int c = 0;
  
      private final int TEST_COUNT = 100_000;
      private int[] testResult = new int[TEST_COUNT];
  
      private static void printResult(int[] result) {
          final Map&lt;Integer, Integer&gt; countMap = new HashMap&lt;&gt;();
          for (final int n : result) {
              countMap.put(n, countMap.getOrDefault(n, 0) + 1);
          }
  
          countMap.forEach((n, count) -&gt; {
              System.out.format("%d -&gt; %d%n", n, count);
          });
      }
  
      private void runTask1() {
          a = 5;
          b = 10;
      }
  
      private void runTask2() {
          if (b == 10) {
              if (a == 5) {
                  c = 1;
              } else {
                  c = 2;
              }
          } else {
              if (a == 5) {
                  c = 3;
              } else {
                  c = 4;
              }
          }
      }
  
      private void runTask3() {
          // "reset task"
          a = 0;
          b = 0;
          c = 0;
      }
  
      private static class PhaserRunner implements Runnable {
          private final Phaser loopStartPhaser;
          private final Phaser loopEndPhaser;
          private final Runnable runnable;
  
          public PhaserRunner(Phaser loopStartPhaser, Phaser loopEndPhaser, Runnable runnable) {
              this.loopStartPhaser = loopStartPhaser;
              this.loopEndPhaser = loopEndPhaser;
              this.runnable = runnable;
          }
  
          @Override
          public void run() {
              while (loopStartPhaser.arriveAndAwaitAdvance() &gt;= 0) {
                  runnable.run();
                  loopEndPhaser.arrive();
              }
          }
      }
  
      void runTest() throws InterruptedException {
          final Phaser[] phasers = new Phaser[]{new Phaser(3), new Phaser(3), new Phaser(2)};
  
          final Thread[] threads = new Thread[]{
                  // build tree of dependencies here
                  new Thread(new PhaserRunner(phasers[0], phasers[1], this::runTask1)),
                  new Thread(new PhaserRunner(phasers[0], phasers[1], this::runTask2)),
                  new Thread(new PhaserRunner(phasers[2], phasers[0], this::runTask3))
          };
  
          try {
              for (Thread thread : threads) {
                  thread.start();
              }
  
              phasers[0].arrive();        // phaser of last round
  
              for (int i = 0; i &lt; TEST_COUNT; i++) {
                  phasers[1].arriveAndAwaitAdvance();
  
                  // Task4 here
                  testResult[i] = c;
  
                  phasers[2].arrive();
              }
          } finally {
              for (Phaser phaser : phasers) {
                  phaser.forceTermination();
              }
          }
  
          for (Thread thread : threads) {
              thread.join();
          }
  
          printResult(testResult);
      }
  }
  </code></pre>
  
  <p>You can see that multiple <code>Phaser</code>s are used. Is it better to keep multiple phasers (like above), or just use one big phaser? Or any other synchronization methods in Java recommended?</p>