Examples of Phaser

co.paralleluniverse.strands.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
hj.lang.phaser
@author bchase
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
jsr166y.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

Examples of java.util.concurrent.Phaser


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

Examples of java.util.concurrent.Phaser

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

Examples of java.util.concurrent.Phaser

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

Examples of java.util.concurrent.Phaser

import pt.ul.jarmus.JArmus;


public class PhaserPhaserPhaser {


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

View Full Code Here

Examples of java.util.concurrent.Phaser

import pt.ul.jarmus.JArmus;


public class PhaserPhaser {


  public static void main(String[] args) throws InterruptedException {
    final Phaser barrier1 = new Phaser(2);
    final Phaser barrier2 = new Phaser(2);
    Thread t1 = new Thread(new Runnable() {
      @Override
      public void run() {
        try {
          JArmus.register(barrier1);
          JArmus.register(barrier2);
          barrier1.arriveAndAwaitAdvance();
          barrier2.arriveAndAwaitAdvance();
        } 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.arriveAndAwaitAdvance();
          barrier1.arriveAndAwaitAdvance();
        } catch (Exception e) {
          throw new RuntimeException(e);
        }
      }

View Full Code Here

Examples of java.util.concurrent.Phaser

public class IterativeAveraging1D {
  private static final int I = 20;
  protected static final int J = 100;
  static final int[] a = new int[I + 2];
  public static void main(String[] args) {
    final Phaser c = new Phaser(1); // "Cyclic barrier" phaser
    final Phaser b = new Phaser(1); // "Join barrier" phaser
    JArmus.register(c);
    JArmus.register(b);
    for (int _i = 1; _i <= I; _i++) {
      final int i = _i;
      c.register();
      b.register();
      new Thread() { // Spawn task i
        public void run() {
          JArmus.register(c);
          JArmus.register(b);
          for (int j = 1; j <= J; j++) {
            final int l = a[i - 1];
            final int r = a[i + 1];
            c.arriveAndAwaitAdvance();
            a[i] = (l + r) / 2;
            c.arriveAndAwaitAdvance();
          }
          c.arriveAndDeregister();
          b.arriveAndDeregister();
        }
      }.start();
    }
    b.arriveAndAwaitAdvance();
    handle(a);
  }

View Full Code Here

Examples of java.util.concurrent.Phaser

  public void setUp() {
    ctl = mock(JArmusController.class);
    JArmus.getSetup().setController(ctl);
    inOrder = inOrder(ctl);
    checker = new PhaserChecker();
    b = new Phaser(1);
    inOrder.verify(ctl).start();
  }

View Full Code Here

Examples of java.util.concurrent.Phaser

        taskExecutor.start();


        try {
            TaskHandle taskHandle = taskExecutor.addTask(new TaskId("test", "test", "test"));


            final Phaser beginPhase = new Phaser();
            beginPhase.register();
            final Phaser verificationComplete = new Phaser();
            verificationComplete.register();


            // add two jobs
            TestingJob driver1 = new TestingJob(beginPhase, verificationComplete, 10);
            ListenableFuture<?> future1 = getOnlyElement(taskExecutor.enqueueSplits(taskHandle, true, ImmutableList.of(driver1)));
            TestingJob driver2 = new TestingJob(beginPhase, verificationComplete, 10);
            ListenableFuture<?> future2 = getOnlyElement(taskExecutor.enqueueSplits(taskHandle, true, ImmutableList.of(driver2)));
            assertEquals(driver1.getCompletedPhases(), 0);
            assertEquals(driver2.getCompletedPhases(), 0);


            // verify worker have arrived but haven't processed yet
            beginPhase.arriveAndAwaitAdvance();
            assertEquals(driver1.getCompletedPhases(), 0);
            assertEquals(driver2.getCompletedPhases(), 0);
            verificationComplete.arriveAndAwaitAdvance();


            // advance one phase and verify
            beginPhase.arriveAndAwaitAdvance();
            assertEquals(driver1.getCompletedPhases(), 1);
            assertEquals(driver2.getCompletedPhases(), 1);


            verificationComplete.arriveAndAwaitAdvance();


            // add one more job
            TestingJob driver3 = new TestingJob(beginPhase, verificationComplete, 10);
            ListenableFuture<?> future3 = getOnlyElement(taskExecutor.enqueueSplits(taskHandle, false, ImmutableList.of(driver3)));


            // advance one phase and verify
            beginPhase.arriveAndAwaitAdvance();
            assertEquals(driver1.getCompletedPhases(), 2);
            assertEquals(driver2.getCompletedPhases(), 2);
            assertEquals(driver3.getCompletedPhases(), 0);
            verificationComplete.arriveAndAwaitAdvance();


            // advance to the end of the first two task and verify
            beginPhase.arriveAndAwaitAdvance();
            for (int i = 0; i < 7; i++) {
                verificationComplete.arriveAndAwaitAdvance();
                beginPhase.arriveAndAwaitAdvance();
                assertEquals(beginPhase.getPhase(), verificationComplete.getPhase() + 1);
            }
            assertEquals(driver1.getCompletedPhases(), 10);
            assertEquals(driver2.getCompletedPhases(), 10);
            assertEquals(driver3.getCompletedPhases(), 8);
            future1.get(1, TimeUnit.SECONDS);
            future2.get(1, TimeUnit.SECONDS);
            verificationComplete.arriveAndAwaitAdvance();


            // advance two more times and verify
            beginPhase.arriveAndAwaitAdvance();
            verificationComplete.arriveAndAwaitAdvance();
            beginPhase.arriveAndAwaitAdvance();
            assertEquals(driver1.getCompletedPhases(), 10);
            assertEquals(driver2.getCompletedPhases(), 10);
            assertEquals(driver3.getCompletedPhases(), 10);
            future3.get(1, TimeUnit.SECONDS);
            verificationComplete.arriveAndAwaitAdvance();


            assertEquals(driver1.getFirstPhase(), 0);
            assertEquals(driver2.getFirstPhase(), 0);
            assertEquals(driver3.getFirstPhase(), 2);

View Full Code Here

Examples of java.util.concurrent.Phaser

        taskExecutor.start();


        try {
            TaskHandle taskHandle = taskExecutor.addTask(new TaskId("test", "test", "test"));


            final Phaser beginPhase = new Phaser();
            beginPhase.register();
            final Phaser verificationComplete = new Phaser();
            verificationComplete.register();


            // add two jobs
            TestingJob driver1 = new TestingJob(beginPhase, verificationComplete, 10);
            ListenableFuture<?> future1 = getOnlyElement(taskExecutor.enqueueSplits(taskHandle, true, ImmutableList.of(driver1)));
            TestingJob driver2 = new TestingJob(beginPhase, verificationComplete, 10);
            ListenableFuture<?> future2 = getOnlyElement(taskExecutor.enqueueSplits(taskHandle, true, ImmutableList.of(driver2)));
            assertEquals(driver1.getCompletedPhases(), 0);
            assertEquals(driver2.getCompletedPhases(), 0);


            // verify worker have arrived but haven't processed yet
            beginPhase.arriveAndAwaitAdvance();
            assertEquals(driver1.getCompletedPhases(), 0);
            assertEquals(driver2.getCompletedPhases(), 0);
            verificationComplete.arriveAndAwaitAdvance();


            // advance one phase and verify
            beginPhase.arriveAndAwaitAdvance();
            assertEquals(driver1.getCompletedPhases(), 1);
            assertEquals(driver2.getCompletedPhases(), 1);


            verificationComplete.arriveAndAwaitAdvance();


            // add one more job
            TestingJob driver3 = new TestingJob(beginPhase, verificationComplete, 10);
            ListenableFuture<?> future3 = getOnlyElement(taskExecutor.enqueueSplits(taskHandle, false, ImmutableList.of(driver3)));


            // advance one phase and verify
            beginPhase.arriveAndAwaitAdvance();
            assertEquals(driver1.getCompletedPhases(), 2);
            assertEquals(driver2.getCompletedPhases(), 2);
            assertEquals(driver3.getCompletedPhases(), 0);
            verificationComplete.arriveAndAwaitAdvance();


            // advance to the end of the first two task and verify
            beginPhase.arriveAndAwaitAdvance();
            for (int i = 0; i < 7; i++) {
                verificationComplete.arriveAndAwaitAdvance();
                beginPhase.arriveAndAwaitAdvance();
                assertEquals(beginPhase.getPhase(), verificationComplete.getPhase() + 1);
            }
            assertEquals(driver1.getCompletedPhases(), 10);
            assertEquals(driver2.getCompletedPhases(), 10);
            assertEquals(driver3.getCompletedPhases(), 8);
            future1.get(1, TimeUnit.SECONDS);
            future2.get(1, TimeUnit.SECONDS);
            verificationComplete.arriveAndAwaitAdvance();


            // advance two more times and verify
            beginPhase.arriveAndAwaitAdvance();
            verificationComplete.arriveAndAwaitAdvance();
            beginPhase.arriveAndAwaitAdvance();
            assertEquals(driver1.getCompletedPhases(), 10);
            assertEquals(driver2.getCompletedPhases(), 10);
            assertEquals(driver3.getCompletedPhases(), 10);
            future3.get(1, TimeUnit.SECONDS);
            verificationComplete.arriveAndAwaitAdvance();


            assertEquals(driver1.getFirstPhase(), 0);
            assertEquals(driver2.getFirstPhase(), 0);
            assertEquals(driver3.getFirstPhase(), 2);

View Full Code Here

Examples of java.util.concurrent.Phaser

   * @param args
   */
  public static void main(String[] args) {
    
    // Creates a Phaser with three participants
    Phaser phaser=new Phaser(3);
    
    // Creates 3 FileSearch objects. Each of them search in different directory
    FileSearch system=new FileSearch("C:\\Windows", "log", phaser);
    FileSearch apps=new FileSearch("C:\\Program Files","log",phaser);
    FileSearch documents=new FileSearch("C:\\Documents And Settings","log",phaser);
    
    // Creates a thread to run the system FileSearch and starts it
    Thread systemThread=new Thread(system,"System");
    systemThread.start();
    
    // Creates a thread to run the apps FileSearch and starts it
    Thread appsThread=new Thread(apps,"Apps");
    appsThread.start();
    
    // Creates a thread to run the documents  FileSearch and starts it
    Thread documentsThread=new Thread(documents,"Documents");
    documentsThread.start();
    try {
      systemThread.join();
      appsThread.join();
      documentsThread.join();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    
    System.out.printf("Terminated: %s\n",phaser.isTerminated());


  }

View Full Code Here

0 1 2 3

TOP

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.