Java Code Examples for java.util.concurrent.atomic.AtomicBoolean#notifyAll()

The following examples show how to use java.util.concurrent.atomic.AtomicBoolean#notifyAll() . These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
Source Project: gemfirexd-oss   File: Discovery.java    License: Apache License 2.0 5 votes vote down vote up
/** GemStoneAddition - tell the waiter it can start its countdown now */
public final void wakeWaiter(AtomicBoolean waiter_sync) {
    synchronized(waiter_sync) {
      waiter_sync.set(true);
      waiter_sync.notifyAll();
    }
}
 
Example 2
Source Project: gemfirexd-oss   File: Discovery.java    License: Apache License 2.0 5 votes vote down vote up
/** GemStoneAddition - tell the waiter it can start its countdown now */
public final void wakeWaiter(AtomicBoolean waiter_sync) {
    synchronized(waiter_sync) {
      waiter_sync.set(true);
      waiter_sync.notifyAll();
    }
}
 
Example 3
@Override
public Void call(ConfigBag parameters) {
    Entity child = Iterables.getOnlyElement(entity().getChildren());
    AtomicBoolean lock = new AtomicBoolean();
    Task<Void> dummyTask = null;

    try {
        // Queue a (DST secondary) task which waits until notified, so that tasks queued later will get blocked
        queue(Effectors.invocation(entity(), STALL, ImmutableMap.of("lock", lock)));
    
        // Start a new task - submitted directly to child's ExecutionContext, as well as added as a
        // DST secondary of the current effector.
        dummyTask = child.invoke(DUMMY, ImmutableMap.<String, Object>of());
        dummyTask.getUnchecked();

        // Execution completed in the child's ExecutionContext, but still queued as a secondary.
        // Destroy the child entity so that no subsequent tasks can be executed in its context.
        Entities.destroy(child);
    } finally {
        // Let STALL complete
        synchronized(lock) {
            lock.set(true);
            lock.notifyAll();
        }
        // At this point DUMMY will be unblocked and the DST will try to execute it as a secondary.
        // Submission will be ignored because DUMMY already executed.
        // If it's not ignored then submission will fail because entity is already unmanaged.
    }
    return null;
}
 
Example 4
Source Project: atomix   File: DistributedSemaphoreTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test(timeout = 10000)
public void testInterrupt() throws Exception {
  Atomix atomix = atomix();
  DistributedSemaphore semaphore = atomix.semaphoreBuilder("test-semaphore-interrupt")
      .withProtocol(protocol())
      .withInitialCapacity(10)
      .build();

  DistributedSemaphore semaphore2 = atomix.semaphoreBuilder("test-semaphore-interrupt")
      .withProtocol(protocol())
      .withInitialCapacity(10)
      .build();

  AtomicBoolean interrupted = new AtomicBoolean();

  Thread t = new Thread(() -> {
    try {
      semaphore.acquire(11);
    } catch (InterruptedException e) {
      synchronized (interrupted) {
        interrupted.set(true);
        interrupted.notifyAll();
      }
    }
  });
  t.start();
  synchronized (interrupted) {
    t.interrupt();
    interrupted.wait();
  }

  assertTrue(interrupted.get());
  semaphore2.increasePermits(1);

  // wait asynchronous release.
  Thread.sleep(1000);
  assertEquals(11, semaphore.availablePermits());
}
 
Example 5
Source Project: atomix   File: AtomicSemaphoreTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test(timeout = 10000)
public void testInterrupt() throws Exception {
  Atomix atomix = atomix();
  AtomicSemaphore semaphore = atomix.atomicSemaphoreBuilder("test-semaphore-interrupt")
      .withProtocol(protocol())
      .withInitialCapacity(10)
      .build();

  AtomicSemaphore semaphore2 = atomix.atomicSemaphoreBuilder("test-semaphore-interrupt")
      .withProtocol(protocol())
      .withInitialCapacity(10)
      .build();

  AtomicBoolean interrupted = new AtomicBoolean();

  Thread t = new Thread(() -> {
    try {
      semaphore.acquire(11);
    } catch (PrimitiveException.Interrupted e) {
      synchronized (interrupted) {
        interrupted.set(true);
        interrupted.notifyAll();
      }
    }
  });
  t.start();
  synchronized (interrupted) {
    t.interrupt();
    interrupted.wait();
  }

  assertTrue(interrupted.get());
  semaphore2.increasePermits(1);

  // wait asynchronous release.
  Thread.sleep(1000);
  assertEquals(11, semaphore.availablePermits());
}
 
Example 6
@Test
public void testExceptionPropagationReader() {
	try {
		// use atomic boolean as a boolean reference
		final AtomicBoolean handlerCalled = new AtomicBoolean();
		final AtomicBoolean exceptionForwarded = new AtomicBoolean();
		
		ReadRequest req = new ReadRequest() {
			
			@Override
			public void requestDone(IOException ioex) {
				if (ioex instanceof TestIOException) {
					exceptionForwarded.set(true);
				}
				
				synchronized (handlerCalled) {
					handlerCalled.set(true);
					handlerCalled.notifyAll();
				}
			}
			
			@Override
			public void read() throws IOException {
				throw new TestIOException();
			}
		};
		
		
		// test the read queue
		RequestQueue<ReadRequest> rq = ioManager.getReadRequestQueue(ioManager.createChannel());
		rq.add(req);

		// wait until the asynchronous request has been handled
		synchronized (handlerCalled) {
			while (!handlerCalled.get()) {
				handlerCalled.wait();
			}
		}
		
		assertTrue(exceptionForwarded.get());
	}
	catch (Exception e) {
		e.printStackTrace();
		fail(e.getMessage());
	}
}
 
Example 7
@Test
public void testExceptionPropagationWriter() {
	try {
		// use atomic boolean as a boolean reference
		final AtomicBoolean handlerCalled = new AtomicBoolean();
		final AtomicBoolean exceptionForwarded = new AtomicBoolean();
		
		WriteRequest req = new WriteRequest() {
			
			@Override
			public void requestDone(IOException ioex) {
				if (ioex instanceof TestIOException) {
					exceptionForwarded.set(true);
				}
				
				synchronized (handlerCalled) {
					handlerCalled.set(true);
					handlerCalled.notifyAll();
				}
			}
			
			@Override
			public void write() throws IOException {
				throw new TestIOException();
			}
		};
		
		
		// test the read queue
		RequestQueue<WriteRequest> rq = ioManager.getWriteRequestQueue(ioManager.createChannel());
		rq.add(req);

		// wait until the asynchronous request has been handled
		synchronized (handlerCalled) {
			while (!handlerCalled.get()) {
				handlerCalled.wait();
			}
		}
		
		assertTrue(exceptionForwarded.get());
	}
	catch (Exception e) {
		e.printStackTrace();
		fail(e.getMessage());
	}
}
 
Example 8
Source Project: flink   File: IOManagerAsyncTest.java    License: Apache License 2.0 4 votes vote down vote up
@Test
public void testExceptionPropagationReader() {
	try {
		// use atomic boolean as a boolean reference
		final AtomicBoolean handlerCalled = new AtomicBoolean();
		final AtomicBoolean exceptionForwarded = new AtomicBoolean();
		
		ReadRequest req = new ReadRequest() {
			
			@Override
			public void requestDone(IOException ioex) {
				if (ioex instanceof TestIOException) {
					exceptionForwarded.set(true);
				}
				
				synchronized (handlerCalled) {
					handlerCalled.set(true);
					handlerCalled.notifyAll();
				}
			}
			
			@Override
			public void read() throws IOException {
				throw new TestIOException();
			}
		};
		
		
		// test the read queue
		RequestQueue<ReadRequest> rq = ioManager.getReadRequestQueue(ioManager.createChannel());
		rq.add(req);

		// wait until the asynchronous request has been handled
		synchronized (handlerCalled) {
			while (!handlerCalled.get()) {
				handlerCalled.wait();
			}
		}
		
		assertTrue(exceptionForwarded.get());
	}
	catch (Exception e) {
		e.printStackTrace();
		fail(e.getMessage());
	}
}
 
Example 9
Source Project: flink   File: IOManagerAsyncTest.java    License: Apache License 2.0 4 votes vote down vote up
@Test
public void testExceptionPropagationWriter() {
	try {
		// use atomic boolean as a boolean reference
		final AtomicBoolean handlerCalled = new AtomicBoolean();
		final AtomicBoolean exceptionForwarded = new AtomicBoolean();
		
		WriteRequest req = new WriteRequest() {
			
			@Override
			public void requestDone(IOException ioex) {
				if (ioex instanceof TestIOException) {
					exceptionForwarded.set(true);
				}
				
				synchronized (handlerCalled) {
					handlerCalled.set(true);
					handlerCalled.notifyAll();
				}
			}
			
			@Override
			public void write() throws IOException {
				throw new TestIOException();
			}
		};
		
		
		// test the read queue
		RequestQueue<WriteRequest> rq = ioManager.getWriteRequestQueue(ioManager.createChannel());
		rq.add(req);

		// wait until the asynchronous request has been handled
		synchronized (handlerCalled) {
			while (!handlerCalled.get()) {
				handlerCalled.wait();
			}
		}
		
		assertTrue(exceptionForwarded.get());
	}
	catch (Exception e) {
		e.printStackTrace();
		fail(e.getMessage());
	}
}
 
Example 10
public void notify(AtomicBoolean running) {
    running.set(false);
    synchronized (running) {
        running.notifyAll();
    }
}
 
Example 11
Source Project: flink   File: IOManagerAsyncTest.java    License: Apache License 2.0 4 votes vote down vote up
@Test
public void testExceptionPropagationReader() {
	try {
		// use atomic boolean as a boolean reference
		final AtomicBoolean handlerCalled = new AtomicBoolean();
		final AtomicBoolean exceptionForwarded = new AtomicBoolean();
		
		ReadRequest req = new ReadRequest() {
			
			@Override
			public void requestDone(IOException ioex) {
				if (ioex instanceof TestIOException) {
					exceptionForwarded.set(true);
				}
				
				synchronized (handlerCalled) {
					handlerCalled.set(true);
					handlerCalled.notifyAll();
				}
			}
			
			@Override
			public void read() throws IOException {
				throw new TestIOException();
			}
		};
		
		
		// test the read queue
		RequestQueue<ReadRequest> rq = ioManager.getReadRequestQueue(ioManager.createChannel());
		rq.add(req);

		// wait until the asynchronous request has been handled
		synchronized (handlerCalled) {
			while (!handlerCalled.get()) {
				handlerCalled.wait();
			}
		}
		
		assertTrue(exceptionForwarded.get());
	}
	catch (Exception e) {
		e.printStackTrace();
		fail(e.getMessage());
	}
}
 
Example 12
Source Project: flink   File: IOManagerAsyncTest.java    License: Apache License 2.0 4 votes vote down vote up
@Test
public void testExceptionPropagationWriter() {
	try {
		// use atomic boolean as a boolean reference
		final AtomicBoolean handlerCalled = new AtomicBoolean();
		final AtomicBoolean exceptionForwarded = new AtomicBoolean();
		
		WriteRequest req = new WriteRequest() {
			
			@Override
			public void requestDone(IOException ioex) {
				if (ioex instanceof TestIOException) {
					exceptionForwarded.set(true);
				}
				
				synchronized (handlerCalled) {
					handlerCalled.set(true);
					handlerCalled.notifyAll();
				}
			}
			
			@Override
			public void write() throws IOException {
				throw new TestIOException();
			}
		};
		
		
		// test the read queue
		RequestQueue<WriteRequest> rq = ioManager.getWriteRequestQueue(ioManager.createChannel());
		rq.add(req);

		// wait until the asynchronous request has been handled
		synchronized (handlerCalled) {
			while (!handlerCalled.get()) {
				handlerCalled.wait();
			}
		}
		
		assertTrue(exceptionForwarded.get());
	}
	catch (Exception e) {
		e.printStackTrace();
		fail(e.getMessage());
	}
}
 
Example 13
Source Project: hbase   File: TestExecutorStatusChore.java    License: Apache License 2.0 4 votes vote down vote up
@Test
public void testMetricsCollect() throws Exception {
  int maxThreads = 5;
  int maxTries = 10;
  int sleepInterval = 10;

  Server mockedServer = mock(Server.class);
  when(mockedServer.getConfiguration()).thenReturn(HBaseConfiguration.create());

  // Start an executor service pool with max 5 threads
  ExecutorService executorService = new ExecutorService("unit_test");
  executorService.startExecutorService(
    ExecutorType.RS_PARALLEL_SEEK, maxThreads);

  MetricsRegionServerSource serverSource = CompatibilitySingletonFactory
      .getInstance(MetricsRegionServerSourceFactory.class).createServer(null);
  assertTrue(serverSource instanceof MetricsRegionServerSourceImpl);

  ExecutorStatusChore statusChore = new ExecutorStatusChore(60000,
      mockedServer, executorService, serverSource);

  AtomicBoolean lock = new AtomicBoolean(true);
  AtomicInteger counter = new AtomicInteger(0);

  for (int i = 0; i < maxThreads + 1; i++) {
    executorService.submit(new TestEventHandler(mockedServer,
        EventType.RS_PARALLEL_SEEK, lock, counter));
  }

  // The TestEventHandler will increment counter when it starts.
  int tries = 0;
  while (counter.get() < maxThreads && tries < maxTries) {
    LOG.info("Waiting for all event handlers to start...");
    Thread.sleep(sleepInterval);
    tries++;
  }

  // Assert that pool is at max threads.
  assertEquals(maxThreads, counter.get());

  statusChore.chore();
  Pair<Long, Long> executorStatus = statusChore.getExecutorStatus("RS_PARALLEL_SEEK");
  assertEquals(maxThreads, executorStatus.getFirst().intValue()); // running
  assertEquals(1, executorStatus.getSecond().intValue()); // pending

  // Now interrupt the running Executor
  synchronized (lock) {
    lock.set(false);
    lock.notifyAll();
  }
  executorService.shutdown();
}
 
Example 14
Source Project: hbase   File: TestExecutorService.java    License: Apache License 2.0 4 votes vote down vote up
@Test
public void testExecutorService() throws Exception {
  int maxThreads = 5;
  int maxTries = 10;
  int sleepInterval = 10;

  Server mockedServer = mock(Server.class);
  when(mockedServer.getConfiguration()).thenReturn(HBaseConfiguration.create());

  // Start an executor service pool with max 5 threads
  ExecutorService executorService = new ExecutorService("unit_test");
  executorService.startExecutorService(
    ExecutorType.MASTER_SERVER_OPERATIONS, maxThreads);

  Executor executor =
    executorService.getExecutor(ExecutorType.MASTER_SERVER_OPERATIONS);
  ThreadPoolExecutor pool = executor.threadPoolExecutor;

  // Assert no threads yet
  assertEquals(0, pool.getPoolSize());

  AtomicBoolean lock = new AtomicBoolean(true);
  AtomicInteger counter = new AtomicInteger(0);

  // Submit maxThreads executors.
  for (int i = 0; i < maxThreads; i++) {
    executorService.submit(
      new TestEventHandler(mockedServer, EventType.M_SERVER_SHUTDOWN,
          lock, counter));
  }

  // The TestEventHandler will increment counter when it starts.
  int tries = 0;
  while (counter.get() < maxThreads && tries < maxTries) {
    LOG.info("Waiting for all event handlers to start...");
    Thread.sleep(sleepInterval);
    tries++;
  }

  // Assert that pool is at max threads.
  assertEquals(maxThreads, counter.get());
  assertEquals(maxThreads, pool.getPoolSize());

  ExecutorStatus status = executor.getStatus();
  assertTrue(status.queuedEvents.isEmpty());
  assertEquals(5, status.running.size());
  checkStatusDump(status);


  // Now interrupt the running Executor
  synchronized (lock) {
    lock.set(false);
    lock.notifyAll();
  }

  // Executor increments counter again on way out so.... test that happened.
  while (counter.get() < (maxThreads * 2) && tries < maxTries) {
    System.out.println("Waiting for all event handlers to finish...");
    Thread.sleep(sleepInterval);
    tries++;
  }

  assertEquals(maxThreads * 2, counter.get());
  assertEquals(maxThreads, pool.getPoolSize());

  // Add more than the number of threads items.
  // Make sure we don't get RejectedExecutionException.
  for (int i = 0; i < (2 * maxThreads); i++) {
    executorService.submit(
      new TestEventHandler(mockedServer, EventType.M_SERVER_SHUTDOWN,
          lock, counter));
  }
  // Now interrupt the running Executor
  synchronized (lock) {
    lock.set(false);
    lock.notifyAll();
  }

  // Make sure threads are still around even after their timetolive expires.
  Thread.sleep(ExecutorService.Executor.keepAliveTimeInMillis * 2);
  assertEquals(maxThreads, pool.getPoolSize());

  executorService.shutdown();

  assertEquals(0, executorService.getAllExecutorStatuses().size());

  // Test that submit doesn't throw NPEs
  executorService.submit(
    new TestEventHandler(mockedServer, EventType.M_SERVER_SHUTDOWN,
          lock, counter));
}