java.util.concurrent.Phaser Java Examples

static Writer interruptibleWriter(final StampedLock sl,
                                  final long timeout,
                                  final TimeUnit unit,
                                  final Phaser gate) {
    return new Writer("InterruptibleWriter") { public void run() {
        if (gate != null ) toTheStartingGate(gate);
        try {
            if (timeout < 0)
                stamp(sl.writeLockInterruptibly());
            else
                stamp(sl.tryWriteLock(timeout, unit));
            check(sl.validate(stamp()));
            check(!sl.isReadLocked());
            check(sl.isWriteLocked());
        } catch (Throwable x) { thrown(x);
        } finally { if (stamp() != 0L) sl.unlockWrite(stamp()); } }};
}
 

private static void realMain(String[] args) throws Throwable {
    final Phaser phaser = new Phaser(3);
    Runnable trivialRunnable = new Runnable() {
        public void run() {
            phaser.arriveAndAwaitAdvance();
        }
    };
    int count0 = Thread.activeCount();
    Executor e1 = newSingleThreadExecutor();
    Executor e2 = newSingleThreadExecutor(defaultThreadFactory());
    e1.execute(trivialRunnable);
    e2.execute(trivialRunnable);
    phaser.arriveAndAwaitAdvance();
    equal(Thread.activeCount(), count0 + 2);
    e1 = e2 = null;
    for (int i = 0; i < 10 && Thread.activeCount() > count0; i++)
        tryWaitForFinalizersToRun();
    for (int i = 0; i < 10; ++i) { // give JVM a chance to settle.
        if (Thread.activeCount() == count0)
            return;
        Thread.sleep(1000);
    }
    equal(Thread.activeCount(), count0);
}
 

static Iterator<Writer> writerIterator(final StampedLock sl,
                                       final Phaser gate) {
    return new Iterator<Writer>() {
        int i = 0;
        boolean view = false;
        public boolean hasNext() { return true; }
        public Writer next() {
            switch ((i++)&7) {
                case 1: case 4: case 7:
                    return writer(sl, gate, view ^= true);
                case 2: case 5:
                    return interruptibleWriter(sl, -1, SECONDS, gate, view ^= true);
                default:
                    return interruptibleWriter(sl, LONG_DELAY_MS, MILLISECONDS, gate, view ^= true); }}
        public void remove() {throw new UnsupportedOperationException();}};
}
 

static Reader interruptibleReader(final StampedLock sl,
                                  final long timeout,
                                  final TimeUnit unit,
                                  final Phaser gate) {
    return new Reader("InterruptibleReader") { public void run() {
        if (gate != null ) toTheStartingGate(gate);
        try {
            if (timeout < 0)
                stamp(sl.readLockInterruptibly());
            else
                stamp(sl.tryReadLock(timeout, unit));
            check(sl.validate(stamp()));
            check(sl.isReadLocked());
            check(!sl.isWriteLocked());
        } catch (Throwable x) { thrown(x);
        } finally { if (stamp() != 0L) sl.unlockRead(stamp()); } }};
}
 

private static void realMain(String[] args) throws Throwable {
    final Phaser phaser = new Phaser(3);
    Runnable trivialRunnable = new Runnable() {
        public void run() {
            phaser.arriveAndAwaitAdvance();
        }
    };
    int count0 = Thread.activeCount();
    Executor e1 = newSingleThreadExecutor();
    Executor e2 = newSingleThreadExecutor(defaultThreadFactory());
    e1.execute(trivialRunnable);
    e2.execute(trivialRunnable);
    phaser.arriveAndAwaitAdvance();
    equal(Thread.activeCount(), count0 + 2);
    e1 = e2 = null;
    for (int i = 0; i < 10 && Thread.activeCount() > count0; i++)
        tryWaitForFinalizersToRun();
    for (int i = 0; i < 10; ++i) { // give JVM a chance to settle.
        if (Thread.activeCount() == count0)
            return;
        Thread.sleep(1000);
    }
    equal(Thread.activeCount(), count0);
}
 

static Iterator<Reader> readerIterator(final StampedLock sl,
                                       final Phaser gate) {
    return new Iterator<Reader>() {
        int i = 0;
        boolean view = false;
        public boolean hasNext() { return true; }
        public Reader next() {
            switch ((i++)&7) {
                case 1: case 4: case 7:
                    return reader(sl, gate, view ^= true);
                case 2: case 5:
                    return interruptibleReader(sl, -1, SECONDS, gate, view ^= true);
                default:
                    return interruptibleReader(sl, 30, SECONDS, gate, view ^= true); }}
        public void remove() {throw new UnsupportedOperationException();}};
}
 

static Writer interruptibleWriterView(final StampedLock sl,
                                      final long timeout,
                                      final TimeUnit unit,
                                      final Phaser gate) {
    return new Writer("InterruptibleWriterView") { public void run() {
        if (gate != null ) toTheStartingGate(gate);
        Lock wl = sl.asWriteLock();
        try {
            if (timeout < 0)
                wl.lockInterruptibly();
            else
                wl.tryLock(timeout, unit);
            stamp(1L);  // got the lock
            check(!sl.isReadLocked());
            check(sl.isWriteLocked());
        } catch (Throwable x) { thrown(x);
        } finally { if (stamp() != 0L) wl.unlock(); } }};
}
 

static Iterator<Writer> writerIterator(final StampedLock sl,
                                       final Phaser gate) {
    return new Iterator<Writer>() {
        int i = 0;
        boolean view = false;
        public boolean hasNext() { return true; }
        public Writer next() {
            switch ((i++)&7) {
                case 1: case 4: case 7:
                    return writer(sl, gate, view ^= true);
                case 2: case 5:
                    return interruptibleWriter(sl, -1, SECONDS, gate, view ^= true);
                default:
                    return interruptibleWriter(sl, 30, SECONDS, gate, view ^= true); }}
        public void remove() {throw new UnsupportedOperationException();}};
}
 

static Reader interruptibleReader(final StampedLock sl,
                                  final long timeout,
                                  final TimeUnit unit,
                                  final Phaser gate) {
    return new Reader("InterruptibleReader") { public void run() {
        if (gate != null ) toTheStartingGate(gate);
        try {
            if (timeout < 0)
                stamp(sl.readLockInterruptibly());
            else
                stamp(sl.tryReadLock(timeout, unit));
            check(sl.validate(stamp()));
            check(sl.isReadLocked());
            check(!sl.isWriteLocked());
        } catch (Throwable x) { thrown(x);
        } finally { if (stamp() != 0L) sl.unlockRead(stamp()); } }};
}
 

static Writer interruptibleWriter(final StampedLock sl,
                                  final long timeout,
                                  final TimeUnit unit,
                                  final Phaser gate) {
    return new Writer("InterruptibleWriter") { public void run() {
        if (gate != null ) toTheStartingGate(gate);
        try {
            if (timeout < 0)
                stamp(sl.writeLockInterruptibly());
            else
                stamp(sl.tryWriteLock(timeout, unit));
            check(sl.validate(stamp()));
            check(!sl.isReadLocked());
            check(sl.isWriteLocked());
        } catch (Throwable x) { thrown(x);
        } finally { if (stamp() != 0L) sl.unlockWrite(stamp()); } }};
}
 

private static void checkTerminated(final Phaser phaser) {
    check(phaser.isTerminated());
    int unarriverParties = phaser.getUnarrivedParties();
    int registeredParties = phaser.getRegisteredParties();
    int phase = phaser.getPhase();
    check(phase < 0);
    equal(phase, phaser.arrive());
    equal(phase, phaser.arriveAndDeregister());
    equal(phase, phaser.arriveAndAwaitAdvance());
    equal(phase, phaser.bulkRegister(10));
    equal(phase, phaser.register());
    try {
        equal(phase, phaser.awaitAdvanceInterruptibly(0));
        equal(phase, phaser.awaitAdvanceInterruptibly(0, 10, SECONDS));
    } catch (Exception ie) {
        unexpected(ie);
    }
    equal(phaser.getUnarrivedParties(), unarriverParties);
    equal(phaser.getRegisteredParties(), registeredParties);
}
 

static Writer interruptibleWriter(final StampedLock sl,
                                  final long timeout,
                                  final TimeUnit unit,
                                  final Phaser gate) {
    return new Writer("InterruptibleWriter") { public void run() {
        if (gate != null ) toTheStartingGate(gate);
        try {
            if (timeout < 0)
                stamp(sl.writeLockInterruptibly());
            else
                stamp(sl.tryWriteLock(timeout, unit));
            check(sl.validate(stamp()));
            check(!sl.isReadLocked());
            check(sl.isWriteLocked());
        } catch (Throwable x) { thrown(x);
        } finally { if (stamp() != 0L) sl.unlockWrite(stamp()); } }};
}
 

static Iterator<Writer> writerIterator(final StampedLock sl,
                                       final Phaser gate) {
    return new Iterator<Writer>() {
        int i = 0;
        boolean view = false;
        public boolean hasNext() { return true; }
        public Writer next() {
            switch ((i++)&7) {
                case 1: case 4: case 7:
                    return writer(sl, gate, view ^= true);
                case 2: case 5:
                    return interruptibleWriter(sl, -1, SECONDS, gate, view ^= true);
                default:
                    return interruptibleWriter(sl, 30, SECONDS, gate, view ^= true); }}
        public void remove() {throw new UnsupportedOperationException();}};
}
 

/**
 * arriveAndAwaitAdvance continues waiting if interrupted before waiting
 */
public void testArriveAndAwaitAdvanceAfterInterrupt() {
    final Phaser phaser = new Phaser();
    assertEquals(0, phaser.register());
    final CountDownLatch pleaseArrive = new CountDownLatch(1);

    Thread t = newStartedThread(new CheckedRunnable() {
        public void realRun() {
            Thread.currentThread().interrupt();
            assertEquals(0, phaser.register());
            pleaseArrive.countDown();
            assertTrue(Thread.currentThread().isInterrupted());
            assertEquals(1, phaser.arriveAndAwaitAdvance());
            assertTrue(Thread.interrupted());
        }});

    await(pleaseArrive);
    waitForThreadToEnterWaitState(t);
    Thread.currentThread().interrupt();
    assertEquals(1, phaser.arriveAndAwaitAdvance());
    assertTrue(Thread.interrupted());
    awaitTermination(t);
}
 

/**
 * arriveAndAwaitAdvance continues waiting if interrupted before waiting
 */
public void testArriveAndAwaitAdvanceAfterInterrupt() {
    final Phaser phaser = new Phaser();
    assertEquals(0, phaser.register());
    final CountDownLatch pleaseArrive = new CountDownLatch(1);

    Thread t = newStartedThread(new CheckedRunnable() {
        public void realRun() {
            Thread.currentThread().interrupt();
            assertEquals(0, phaser.register());
            pleaseArrive.countDown();
            assertTrue(Thread.currentThread().isInterrupted());
            assertEquals(1, phaser.arriveAndAwaitAdvance());
            assertTrue(Thread.interrupted());
        }});

    await(pleaseArrive);
    waitForThreadToEnterWaitState(t);
    Thread.currentThread().interrupt();
    assertEquals(1, phaser.arriveAndAwaitAdvance());
    assertTrue(Thread.interrupted());
    awaitTermination(t);
}
 

static Iterator<Reader> readerIterator(final StampedLock sl,
                                       final Phaser gate) {
    return new Iterator<Reader>() {
        int i = 0;
        boolean view = false;
        public boolean hasNext() { return true; }
        public Reader next() {
            switch ((i++)&7) {
                case 1: case 4: case 7:
                    return reader(sl, gate, view ^= true);
                case 2: case 5:
                    return interruptibleReader(sl, -1, SECONDS, gate, view ^= true);
                default:
                    return interruptibleReader(sl, 30, SECONDS, gate, view ^= true); }}
        public void remove() {throw new UnsupportedOperationException();}};
}
 

static Writer interruptibleWriter(final StampedLock sl,
                                  final long timeout,
                                  final TimeUnit unit,
                                  final Phaser gate) {
    return new Writer("InterruptibleWriter") { public void run() {
        if (gate != null ) toTheStartingGate(gate);
        try {
            if (timeout < 0)
                stamp(sl.writeLockInterruptibly());
            else
                stamp(sl.tryWriteLock(timeout, unit));
            check(sl.validate(stamp()));
            check(!sl.isReadLocked());
            check(sl.isWriteLocked());
        } catch (Throwable x) { thrown(x);
        } finally { if (stamp() != 0L) sl.unlockWrite(stamp()); } }};
}
 

public static void main(String[] args) throws Exception {
    try (ServerSocket ss = new ServerSocket(0)) {
        final int port = ss.getLocalPort();
        final Phaser phaser = new Phaser(THREADS + 1);
        for (int i=0; i<100; i++) {
            final Socket s = new Socket("localhost", port);
            s.setSoLinger(false, 0);
            try (Socket sa = ss.accept()) {
                sa.setSoLinger(false, 0);
                final InputStream is = s.getInputStream();
                Thread[] threads = new Thread[THREADS];
                for (int j=0; j<THREADS; j++) {
                    threads[j] = new Thread() {
                    public void run() {
                        try {
                            phaser.arriveAndAwaitAdvance();
                            while (is.read() != -1)
                                Thread.sleep(50);
                        } catch (Exception x) {
                            if (!(x instanceof SocketException
                                  && x.getMessage().equalsIgnoreCase("socket closed")))
                                x.printStackTrace();
                            // ok, expect Socket closed
                        }
                    }};
                }
                for (int j=0; j<100; j++)
                    threads[j].start();
                phaser.arriveAndAwaitAdvance();
                s.close();
                for (int j=0; j<100; j++)
                    threads[j].join();
            }
        }
    }
}
 

/**
 * awaitAdvance returns the current phase
 */
public void testAwaitAdvance5() {
    final Phaser phaser = new Phaser(1);
    assertEquals(1, phaser.awaitAdvance(phaser.arrive()));
    assertEquals(1, phaser.getPhase());
    assertEquals(1, phaser.register());
    List<Thread> threads = new ArrayList<Thread>();
    for (int i = 0; i < 8; i++) {
        final CountDownLatch latch = new CountDownLatch(1);
        final boolean goesFirst = ((i & 1) == 0);
        threads.add(newStartedThread(new CheckedRunnable() {
            public void realRun() {
                if (goesFirst)
                    latch.countDown();
                else
                    await(latch);
                phaser.arrive();
            }}));
        if (goesFirst)
            await(latch);
        else
            latch.countDown();
        assertEquals(i + 2, phaser.awaitAdvance(phaser.arrive()));
        assertEquals(i + 2, phaser.getPhase());
    }
    for (Thread thread : threads)
        awaitTermination(thread);
}
 

/**
 * Tests that waiting on a single monitor properly increases the waited
 * count by 1 and the waited time by a positive number.
 */
private static void testWaitingOnSimpleMonitor() throws Exception {
    System.out.println("testWaitingOnSimpleMonitor");
    final Object lock1 = new Object();
    final Phaser p = new Phaser(2);
    LockerThread lt = newLockerThread(new Runnable() {
        @Override
        public void run() {
            p.arriveAndAwaitAdvance(); // phase[1]
            synchronized(lock1) {
                System.out.println("[LockerThread obtained Lock1]");
                try {
                    lock1.wait(300);
                } catch (InterruptedException ex) {
                    // ignore
                }
                p.arriveAndAwaitAdvance(); // phase[2]
            }
            p.arriveAndAwaitAdvance(); // phase[3]
        }
    });

    lt.start();
    ThreadInfo ti1 = mbean.getThreadInfo(lt.getId());
    synchronized(lock1) {
        p.arriveAndAwaitAdvance(); // phase[1]
        waitForThreadState(lt, Thread.State.BLOCKED);
    }
    p.arriveAndAwaitAdvance(); // phase[2]

    testWaited(ti1, () -> mbean.getThreadInfo(lt.getId()), 1);
    p.arriveAndDeregister(); // phase[3]

    lt.join();

    printok();
}
 

/** Checks state of unterminated phaser. */
protected void assertState(Phaser phaser,
                           int phase, int parties, int unarrived) {
    assertEquals(phase, phaser.getPhase());
    assertEquals(parties, phaser.getRegisteredParties());
    assertEquals(unarrived, phaser.getUnarrivedParties());
    assertEquals(parties - unarrived, phaser.getArrivedParties());
    assertFalse(phaser.isTerminated());
}
 

static Writer writer(final StampedLock sl, final Phaser gate) {
    return new Writer() { public void run() {
        if (gate != null ) toTheStartingGate(gate);
        try {
            stamp(sl.writeLock());
            check(sl.validate(stamp()));
            check(!sl.isReadLocked());
            check(sl.isWriteLocked());
        } finally { sl.unlockWrite(stamp()); } }};
}
 

static Reader interruptibleReader(final StampedLock sl,
                                  final long timeout,
                                  final TimeUnit unit,
                                  final Phaser gate,
                                  final boolean view) {
    return view ? interruptibleReaderView(sl, timeout, unit, gate)
                : interruptibleReader(sl, timeout, unit, gate);
}
 

public BeamFnLoggingClient(
    PipelineOptions options,
    Endpoints.ApiServiceDescriptor apiServiceDescriptor,
    Function<Endpoints.ApiServiceDescriptor, ManagedChannel> channelFactory) {
  this.apiServiceDescriptor = apiServiceDescriptor;
  this.inboundObserverCompletion = new CompletableFuture<>();
  this.configuredLoggers = new ArrayList<>();
  this.phaser = new Phaser(1);
  this.channel = channelFactory.apply(apiServiceDescriptor);

  // Reset the global log manager, get the root logger and remove the default log handlers.
  LogManager logManager = LogManager.getLogManager();
  logManager.reset();
  Logger rootLogger = logManager.getLogger(ROOT_LOGGER_NAME);
  for (Handler handler : rootLogger.getHandlers()) {
    rootLogger.removeHandler(handler);
  }

  // Use the passed in logging options to configure the various logger levels.
  SdkHarnessOptions loggingOptions = options.as(SdkHarnessOptions.class);
  if (loggingOptions.getDefaultSdkHarnessLogLevel() != null) {
    rootLogger.setLevel(LEVEL_CONFIGURATION.get(loggingOptions.getDefaultSdkHarnessLogLevel()));
  }

  if (loggingOptions.getSdkHarnessLogLevelOverrides() != null) {
    for (Map.Entry<String, SdkHarnessOptions.LogLevel> loggerOverride :
        loggingOptions.getSdkHarnessLogLevelOverrides().entrySet()) {
      Logger logger = Logger.getLogger(loggerOverride.getKey());
      logger.setLevel(LEVEL_CONFIGURATION.get(loggerOverride.getValue()));
      configuredLoggers.add(logger);
    }
  }

  BeamFnLoggingGrpc.BeamFnLoggingStub stub = BeamFnLoggingGrpc.newStub(channel);
  inboundObserver = new LogControlObserver();
  logRecordHandler = new LogRecordHandler(options.as(GcsOptions.class).getExecutorService());
  logRecordHandler.setLevel(Level.ALL);
  outboundObserver = (CallStreamObserver<BeamFnApi.LogEntry.List>) stub.logging(inboundObserver);
  rootLogger.addHandler(logRecordHandler);
}
 

@Test
public void combineWithOneElement() throws InterruptedException, TimeoutException {
	AtomicReference<Object> ref = new AtomicReference<>(null);

	Phaser phaser = new Phaser(2);

	Flux<Object> s1 = Processors.more().replayLatestOrDefault(new Object())
	                                 .publishOn(asyncGroup);
	Flux<Object> s2 = Processors.more().replayLatestOrDefault(new Object())
	                                .publishOn(asyncGroup);

	// The following works:
	//List<Flux<Object>> list = Arrays.collectList(s1);
	// The following fails:
	List<Flux<Object>> list = Arrays.asList(s1, s2);

	Flux.combineLatest(list, t -> t)
	       .log()
	       .doOnNext(obj -> {
		       ref.set(obj);
		       phaser.arrive();
	       })
	       .subscribe();

	phaser.awaitAdvanceInterruptibly(phaser.arrive(), 1, TimeUnit.SECONDS);
	Assert.assertNotNull(ref.get());
}
 

public PhaserHelperThread(Phaser phaserIn, boolean awaitOthersIn, int phaseToWaitForIn, boolean allowInterruptIn, boolean expectInterruptIn, boolean deregisterTestIn)
{
	phaser = phaserIn;
	awaitOthers = awaitOthersIn;
	phaseToWaitFor = phaseToWaitForIn;
	allowInterrupt = allowInterruptIn;
	expectInterrupt = expectInterruptIn;
	deregisterTest = deregisterTestIn;
	
	// Register with the Phaser
	phaser.register();
}
 

static void adderTest(int nthreads, int incs) {
    System.out.print("DoubleAdder  ");
    Phaser phaser = new Phaser(nthreads + 1);
    DoubleAdder a = new DoubleAdder();
    for (int i = 0; i < nthreads; ++i)
        pool.execute(new AdderTask(a, phaser, incs));
    report(nthreads, incs, timeTasks(phaser), a.sum());
}
 

/**
 * the phase number increments correctly when tripping the barrier
 */
public void testPhaseIncrement1() {
    for (int size = 1; size < nine; size++) {
        final Phaser phaser = new Phaser(size);
        for (int index = 0; index <= (1 << size); index++) {
            int phase = phaser.arrive();
            assertTrue(index % size == 0 ? (index / size) == phase : index - (phase * size) > 0);
        }
    }
}
 

static long timeTasks(Phaser phaser) {
    phaser.arriveAndAwaitAdvance();
    long start = System.nanoTime();
    phaser.arriveAndAwaitAdvance();
    phaser.arriveAndAwaitAdvance();
    return System.nanoTime() - start;
}
 

@Inject
public WriteCloseableDataStore(@ManagedDataStoreDelegate DataStore delegate,
                               @ManagedTableBackingStoreDelegate TableBackingStore tableBackingStore,
                               MetricRegistry metricRegistry) {
    _delegate = requireNonNull(delegate);
    _tableBackingStore = requireNonNull(tableBackingStore);
    _writesAccepted = true;
    _writerPhaser = new Phaser(1);
    _writesRejectedCounter = metricRegistry.counter(MetricRegistry.name("bv.emodb.sor", "WriteCloseableDataStore",
            "writesRejected"));
}