Examples of java.util.concurrent.Phaser

java.util.concurrent.Phaser
to register self // create and start threads for (final Runnable task : tasks) { phaser.register(); new Thread() { public void run() { phaser.arriveAndAwaitAdvance(); // await all creation task.run(); } }.start(); } // allow threads to start and deregister self phaser.arriveAndDeregister(); }}
One way to cause a set of threads to repeatedly perform actions for a given number of iterations is to override {@code onAdvance}:
```
  {@code}void startTasks(List tasks, final int iterations)  final Phaser phaser = new Phaser() { protected boolean onAdvance(int phase, int registeredParties) { return phase >= iterations || registeredParties == 0; } }; phaser.register(); for (final Runnable task : tasks) { phaser.register(); new Thread() { public void run() { do { task.run(); phaser.arriveAndAwaitAdvance(); } while (!phaser.isTerminated()); } }.start(); } phaser.arriveAndDeregister(); // deregister self, don't wait }}
```
If the main task must later await termination, it may re-register and then execute a similar loop:
```
  {@code // ... phaser.register(); while (!phaser.isTerminated()) phaser.arriveAndAwaitAdvance();}
```
Related constructions may be used to await particular phase numbers in contexts where you are sure that the phase will never wrap around {@code Integer.MAX_VALUE}. For example:
```
  {@code}void awaitPhase(Phaser phaser, int phase)  int p = phaser.register(); // assumes caller not already registered while (p < phase) { if (phaser.isTerminated()) // ... deal with unexpected termination else p = phaser.arriveAndAwaitAdvance(); } phaser.arriveAndDeregister(); }}
```
To create a set of {@code n} tasks using a tree of phasers, youcould use code of the following form, assuming a Task class with a constructor accepting a {@code Phaser} that it registers with uponconstruction. After invocation of {@code build(new Task[n], 0, n,new Phaser())}, these tasks could then be started, for example by submitting to a pool:
```
  {@code}void build(Task[] tasks, int lo, int hi, Phaser ph)  if (hi - lo > TASKS_PER_PHASER) { for (int i = lo; i < hi; i += TASKS_PER_PHASER) { int j = Math.min(i + TASKS_PER_PHASER, hi); build(tasks, i, j, new Phaser(ph)); } } else { for (int i = lo; i < hi; ++i) tasks[i] = new Task(ph); // assumes new Task(ph) performs ph.register() } }}
```
The best value of {@code TASKS_PER_PHASER} depends mainly onexpected synchronization rates. A value as low as four may be appropriate for extremely small per-phase task bodies (thus high rates), or up to hundreds for extremely large ones.
Implementation notes: This implementation restricts the maximum number of parties to 65535. Attempts to register additional parties result in {@code IllegalStateException}. However, you can and should create tiered phasers to accommodate arbitrarily large sets of participants. @since 1.7 @author Doug Lea

  }
  
  @Parameters
  public static Collection<Object[]> data() {
    List<Object[]> result = new ArrayList<>();
    result.add(new Object[]{new Phaser(1)});
    result.add(new Object[]{new pt.ul.jarmus.ext.Phaser(1)});
    return result;
  }

View Full Code Here


public class SplitPhase {
  protected static final boolean condition = false;


  public static void main(String[] args) throws InterruptedException {
    final Phaser a = new Phaser(2);
    final Phaser b = new Phaser(2);
    new Thread(new Runnable() {
      @Override
      public void run() {
        try {
          JArmus.register(a);
          JArmus.register(b);
          if (condition) {
            b.arrive();
          }
          a.arriveAndAwaitAdvance();
          if (condition) {
            b.awaitAdvance(0);
          } else {
            b.arriveAndAwaitAdvance();
          }
        } catch (Exception e) {
          throw new RuntimeException(e);
        }
      }
    }).start();
    JArmus.register(a);
    JArmus.register(b);
    b.arriveAndAwaitAdvance();
    a.arriveAndAwaitAdvance();
  }

View Full Code Here

public class ProducerConsumer3 {
  protected static final int nz = 1000;


  public static void main(String[] args) {
    final int num_threads = 3;
    final Phaser ph[] = new Phaser[num_threads];
    for (int i = 0; i < num_threads; i++) {
      ph[i] = new Phaser(2);
    }
    for (int i = 0; i < num_threads; i++) {
      final Phaser curr = ph[i];
      final Phaser neighbour = ph[(i - 1 + num_threads) % num_threads];
      @SuppressWarnings("unused")
      final int id = i;
      new Thread(new Runnable() {
        @Override
        public void run() {
          JArmus.register(curr);
          JArmus.register(neighbour);
          for (int k = 1; k <= nz - 2; k++) {
            step(k);
            /* we introduce the deadlock by commenting one of the 
               boundary conditions */
            //if (id > 0) {
              neighbour.arriveAndAwaitAdvance();
            //}
            step2(k);
            //if (id < num_threads - 1) {
              curr.arriveAndAwaitAdvance();
            //}

View Full Code Here

public class ProducerConsumer {
  protected static final int nz = 1000;


  public static void main(String[] args) {
    final int num_threads = 3;
    final Phaser ph[] = new Phaser[num_threads];
    for (int i = 0; i < num_threads; i++) {
      ph[i] = new Phaser(2);
    }
    for (int i = 0; i < num_threads; i++) {
      final Phaser curr = ph[i];
      final Phaser neighbour = ph[(i + num_threads - 1) % num_threads];
      final int id = i;
      new Thread(new Runnable() {
        @Override
        public void run() {
          JArmus.register(curr);
          JArmus.register(neighbour);
          for (int k = 1; k <= nz - 2; k++) {
            step(k);
            if (id > 0) {
              neighbour.arriveAndAwaitAdvance();
            }
            step2(k);
            if (id < num_threads - 1) {
              curr.arriveAndAwaitAdvance();
            }

View Full Code Here

public class ProducerConsumer2 {
  protected static final int nz = 1000;


  public static void main(String[] args) {
    final int num_threads = 3;
    final Phaser ph[] = new Phaser[num_threads];
    for (int i = 0; i < num_threads; i++) {
      ph[i] = new Phaser(2);
    }
    for (int i = 0; i < num_threads; i++) {
      final Phaser curr = ph[i];
      final Phaser neighbour = ph[(i - 1 + num_threads) % num_threads];
      final int id = i;
      new Thread(new Runnable() {
        @Override
        public void run() {
          JArmus.register(curr);
          JArmus.register(neighbour);
          for (int k = 1; k <= nz - 2; k++) {
            step(k);
            /* we introduce the deadlock by commenting one of the 
               boundary conditions */
            if (id > 0) {
              neighbour.arriveAndAwaitAdvance();
            }
            step2(k);
            //if (id < num_threads - 1) {
              curr.arriveAndAwaitAdvance();
            //}

View Full Code Here

public class ProducerConsumer1 {
  protected static final int nz = 1000;


  public static void main(String[] args) {
    final int num_threads = 3;
    final Phaser ph[] = new Phaser[num_threads];
    for (int i = 0; i < num_threads; i++) {
      ph[i] = new Phaser(2);
    }
    for (int i = 0; i < num_threads; i++) {
      final Phaser curr = ph[i];
      final Phaser neighbour = ph[(i - 1 + num_threads) % num_threads];
      final int id = i;
      new Thread(new Runnable() {
        @Override
        public void run() {
          JArmus.register(curr);
          JArmus.register(neighbour);
          for (int k = 1; k <= nz - 2; k++) {
            step(k);
            /* we introduce the deadlock by commenting one of the 
               boundary conditions */
            //if (id > 0) {
              neighbour.arriveAndAwaitAdvance();
            //}
            step2(k);
            if (id < num_threads - 1) {
              curr.arriveAndAwaitAdvance();
            }

View Full Code Here

import pt.ul.jarmus.JArmus;


public class FjPhaser {


  public static void main(String[] args) throws InterruptedException {
    final Phaser barrier = new Phaser(2);
    final ForkJoinPool pool = new ForkJoinPool();
    ForkJoinTask<?> t1 = pool.submit(ForkJoinTask.adapt(new Runnable() { // T1
      @Override
      public void run() {
        JArmus.register(barrier); // Is using the latch
        try {
          ForkJoinTask.adapt(new Runnable() { // T2
            @Override
            public void run() {
              JArmus.register(barrier); // Is using the latch
              barrier.arriveAndAwaitAdvance(); // wait for T1
            }
          }).invoke(); // wait for T2
          barrier.arriveAndAwaitAdvance();
        } catch (Exception e) {
          throw new RuntimeException(e);
        }
      }
    }));

View Full Code Here


import pt.ul.jarmus.JArmus;


public class DynamicMembership {
  public static void main(String[] args) {
    final Phaser a = new Phaser(2);
    final Phaser b = new Phaser(2);
    new Thread(new Runnable() {
      @Override
      public void run() {
        JArmus.register(a);
        JArmus.register(b);
        a.arriveAndAwaitAdvance();
      }
    }).start();
    JArmus.register(a);
    JArmus.register(b);
    b.arriveAndAwaitAdvance();
  }

View Full Code Here

import pt.ul.jarmus.JArmus;


public class PhaserSelf {


  public static void main(String[] args) throws InterruptedException {
    final Phaser barrier1 = new Phaser(1);
    Thread t1 = new Thread(new Runnable() {
      @Override
      public void run() {
        try {
          JArmus.register(barrier1);
          barrier1.awaitAdvance(0);
        } catch (Exception e) {
          throw new RuntimeException(e);
        }
      }
    });

View Full Code Here

import pt.ul.jarmus.JArmus;


public class LatchPhaser {


  public static void main(String[] args) throws InterruptedException {
    final Phaser barrier1 = new Phaser(2);
    final CountDownLatch barrier2 = new CountDownLatch(2);
    Thread t1 = new Thread(new Runnable() {
      @Override
      public void run() {
        try {
          JArmus.register(barrier1);
          JArmus.register(barrier2);
          barrier1.arriveAndAwaitAdvance();
          barrier2.countDown();
          barrier2.await();
        } catch (Exception e) {
          throw new RuntimeException(e);
        }
      }
    });
    Thread t2 = new Thread(new Runnable() {
      @Override
      public void run() {
        try {
          JArmus.register(barrier1);
          JArmus.register(barrier2);
          barrier2.countDown();
          barrier2.await();
          barrier1.arriveAndAwaitAdvance();
        } catch (Exception e) {
          throw new RuntimeException(e);
        }
      }
    });

View Full Code Here

0 1 2

TOP

Related Classes of java.util.concurrent.Phaser

com.facebook.presto.execution.TaskExecutorTest

com.packtpub.java7.concurrency.chapter3.recipe5.core.Main

com.packtpub.java7.concurrency.chapter8.recipe04.core.Main

pt.ul.jarmus.checkers.PhaserCheckerTest

pt.ul.jarmus.deadlocks.CyclicPhaser

pt.ul.jarmus.deadlocks.DynamicMembership

pt.ul.jarmus.deadlocks.IterativeAveraging1D

pt.ul.jarmus.deadlocks.LatchPhaser

pt.ul.jarmus.deadlocks.PhaserPhaser

pt.ul.jarmus.deadlocks.PhaserPhaserPhaser

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.