Package java.util.concurrent

Examples of java.util.concurrent.Phaser$QNode

36
37
38
39
40
41
42
43
44
  }
 
  @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
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
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
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
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
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
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
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
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
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
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
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
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
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
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
TOP

Related Classes of java.util.concurrent.Phaser$QNode

  • com.caucho.xpath.pattern.NodeListIterator
  • 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
    • Copyright © 2018 www.massapicom. All rights reserved.
    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.