public void comer(int id) {
accessLock.lock(); // bloqueia a mesa
int x = 0, contador = 0;
boolean teste = false;
try {
do {
for (int i = 0; i < feitos.size(); i++) {
if (feitos.get(i).getId_cliente() == id) {
x = i;
teste = true;
}
}
if (!produtos.isEmpty() && !teste) { // se não tiver itens feitos
System.out.printf("Cliente[%d] aguardando\n", id);
comer.await(); // bloqueia alguem comer
}
for (int i = 0; i < feitos.size(); i++) {
if (feitos.get(i).getId_cliente() == id) {
x = i;
teste = true;
}
}
} while (!teste && !produtos.isEmpty());
if (teste) {
feitos.get(x).setStatus("CONSUMIDO");
System.out.printf("O Cliente[%d] consumiu o item[%d]\n", id, feitos.get(x).getId_pedido());
feitos.remove(x);
cozinhar.signalAll(); // libera a producao de mais itens
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
accessLock.unlock(); // libera a mesa
}
}
private void dispatchMessages(Dispatch<? super T> dispatch) {
while (true) {
T message = null;
lock.lock();
try {
while (state != State.Stopped && queue.isEmpty()) {
try {
condition.await();
} catch (InterruptedException e) {
throw new UncheckedException(e);
}
}
if (!queue.isEmpty()) {
message = queue.remove();
condition.signalAll();
}
} finally {
lock.unlock();
}
if (message == null) {
// Have been stopped and nothing to deliver
return;
}
dispatch.dispatch(message);
}
}
/**
* Forces the current thread to wait for the voting to complete if it is responsible for creating
* the Saga. As soon as an invocation has been recorded, the waiting thread is released.
*
* @param didInvocation indicates whether the current processor found a Saga to process
* @param totalVotesExpected The total number of processors expected to cast a vote
* @param isSagaOwner Indicates whether the current processor "owns" the to-be-created saga
* instance.
* @return <code>true</code> if the current processor should create the new instance, <code>false
* </code> otherwise.
*/
public boolean waitForSagaCreationVote(
final boolean didInvocation, final int totalVotesExpected, final boolean isSagaOwner) {
votingLock.lock();
try {
invocationDetected = invocationDetected || didInvocation;
castVotes++;
while (isSagaOwner && !invocationDetected && castVotes < totalVotesExpected) {
try {
allVotesCast.await();
} catch (InterruptedException e) {
// interrupting this process is not supported.
logger.warn(
"This thread has been interrupted, but the interruption has "
+ "been ignored to prevent loss of information.");
}
}
if (isSagaOwner) {
return !invocationDetected;
}
allVotesCast.signalAll();
} finally {
votingLock.unlock();
}
return false;
}
public void waitUntilNumIsAtLeast(int expected) {
lock.lock();
try {
while (true) {
if (num >= expected) return;
log.fine(
"Waiting "
+ uniqueId
+ ", expected sequence number "
+ expected
+ ", was "
+ num
+ ".");
boolean timedOut = false;
try {
timedOut = !numIncreased.await(5, TimeUnit.SECONDS);
} catch (InterruptedException e) {
log.log(Level.FINE, "interrupted", e);
}
if (timedOut) {
log.warning(
uniqueId
+ " expected sequence number "
+ expected
+ ", was "
+ num
+ ". Continuing anyway");
num++;
numIncreased.signalAll();
}
}
} finally {
lock.unlock();
}
}
// the landing method
public void landing(int flight_num, int wind) throws InterruptedException {
L.lock();
try {
// if turn is set to takeoff, then wait
if (turn == 0) {
C.await();
}
wind_direction = wind;
RunwaySystem();
System.out.println(
"Flight "
+ flight_num
+ " is cleared for landing on runway "
+ runway_number
+ runway_direction);
System.out.println("Flight " + flight_num + " has arrived. The runway is now clear.");
System.out.println("===========>\n");
// set the turn for takeoff
turn = 0;
C.signalAll();
} finally {
L.unlock();
}
}
public TaskInfo getTaskToExecute(Spec<TaskInfo> criteria) {
lock.lock();
try {
TaskInfo nextMatching;
while ((nextMatching = getNextReadyAndMatching(criteria)) != null) {
while (!nextMatching.allDependenciesComplete()) {
try {
condition.await();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
// The task state could have been modified while we waited for dependency completion. Check
// that it is still 'ready'.
if (!nextMatching.isReady()) {
continue;
}
if (nextMatching.allDependenciesSuccessful()) {
nextMatching.startExecution();
return nextMatching;
} else {
nextMatching.skipExecution();
condition.signalAll();
}
}
return null;
} finally {
lock.unlock();
}
}
public Events<Event> get(Position start, int batchSize, long timeout, TimeUnit unit)
throws InterruptedException, CanalStoreException {
long nanos = unit.toNanos(timeout);
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
for (; ; ) {
if (checkUnGetSlotAt((LogPosition) start, batchSize)) {
return doGet(start, batchSize);
}
if (nanos <= 0) {
// 如果时间到了，有多少取多少
return doGet(start, batchSize);
}
try {
nanos = notEmpty.awaitNanos(nanos);
} catch (InterruptedException ie) {
notEmpty.signal(); // propagate to non-interrupted thread
throw ie;
}
}
} finally {
lock.unlock();
}
}
public static void escritorSeVa(Escritor escritor) {
lock.lock();
System.out.println("El Escritor:" + escritor.nombre + " Termino De Escribir.");
escritorEscribiendo = false;
if (!cola.isEmpty()) {
if (cola.get(0).lector) {
lectoresLeyendo = cola.get(0).cantidad;
System.out.println("");
System.out.println("Se setea lectoresLeyendo = " + lectoresLeyendo);
System.out.println("");
for (int i = 0; i < cola.get(0).cantidad; i++) {
lectores.signal();
}
cola.remove(0);
} else {
cola.get(0).cantidad -= 1;
escritorEscribiendo = true;
if (cola.get(0).cantidad == 0) {
cola.remove(0);
}
escritores.signal();
}
}
lock.unlock();
}
public T receive() {
lock.lock();
try {
while (true) {
DelayedMessage message = queue.peek();
if (message == null && stopping) {
return null;
}
if (message == null) {
condition.await();
continue;
}
long now = timeProvider.getCurrentTime();
if (message.dispatchTime > now) {
condition.awaitUntil(new Date(message.dispatchTime));
} else {
queue.poll();
if (queue.isEmpty()) {
condition.signalAll();
}
return message.message;
}
}
} catch (InterruptedException e) {
throw UncheckedException.throwAsUncheckedException(e);
} finally {
lock.unlock();
}
}
public E take() throws InterruptedException {
Node<E> x;
final AtomicInteger count = this.count;
final ReentrantLock takeLock = this.takeLock;
takeLock.lockInterruptibly();
try {
try {
while (count.get() == 0) notEmpty.await();
} catch (InterruptedException ie) {
notEmpty.signal(); // propagate to a non-interrupted thread
throw ie;
}
x = extract();
if (count.getAndDecrement() > 1) notEmpty.signal();
} finally {
takeLock.unlock();
}
E result = x.item;
// temporary clearence
x.item = null;
x.next = null;
return result;
}
public RunnableScheduledFuture<?> take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
for (; ; ) {
RunnableScheduledFuture<?> first = queue[0];
if (first == null) available.await();
else {
long delay = first.getDelay(NANOSECONDS);
if (delay <= 0) return finishPoll(first);
else if (leader != null) available.await();
else {
Thread thisThread = Thread.currentThread();
leader = thisThread;
try {
available.awaitNanos(delay);
} finally {
if (leader == thisThread) leader = null;
}
}
}
}
} finally {
if (leader == null && queue[0] != null) available.signal();
lock.unlock();
}
}
/**
* Retrieves and removes the head of this queue, waiting if necessary until an element with an
* expired delay is available on this queue, or the specified wait time expires.
*
* @return the head of this queue, or <tt>null</tt> if the specified waiting time elapses before
* an element with an expired delay becomes available
* @throws InterruptedException {@inheritDoc}
*/
public E poll(long timeout, TimeUnit unit) throws InterruptedException {
long nanos = unit.toNanos(timeout);
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
for (; ; ) {
E first = q.peek();
if (first == null) {
if (nanos <= 0) return null;
else nanos = available.awaitNanos(nanos);
} else {
long delay = first.getDelay(TimeUnit.NANOSECONDS);
if (delay > 0) {
if (nanos <= 0) return null;
if (delay > nanos) delay = nanos;
long timeLeft = available.awaitNanos(delay);
nanos -= delay - timeLeft;
} else {
E x = q.poll();
assert x != null;
if (q.size() != 0) available.signalAll();
return x;
}
}
}
} finally {
lock.unlock();
}
}
void foo() {
Object obj;
Condition condition;
synchronized (obj) {
if (!suitableCondition()) {
obj.wait(12); // Noncompliant {{Remove this call to "wait" or move it into a "while" loop.}}
condition.await(); // Noncompliant
}
for (; ; ) {
obj.wait(12);
}
do {
obj.wait(12);
} while (!suitableCondition);
while (!suitableCondition()) {
obj.wait(12);
condition.await();
while (!suitableCondition()) {
obj.wait(12);
condition.await();
}
obj.wait(12);
}
}
}
public void waitForLSPaddition(long lspId, long timeWait) {
Lock lock;
Condition lspEstablished;
try {
lock = lockList.get(lspId);
if (lock == null) log.info("Lock is NULL!");
lspEstablished = conditionList.get(lspId);
} catch (Exception e) {
return;
}
lock.lock();
try {
if (established == false) {
log.info("Waiting " + timeWait + " ms for LSP " + lspId + " to be established");
lspEstablished.await(timeWait, TimeUnit.MILLISECONDS);
} else {
log.info("Inside waitForLSPaddition lockList.remove");
// FIXME: Revisar esto
lockList.remove(lspId);
conditionList.remove(lspId);
}
log.info("LSP " + lspId + " has been established");
} catch (InterruptedException e) {
return;
} finally {
lock.unlock();
}
}
@Override
public float[] getBlock(int timeout) {
// TODO Auto-generated method stub
float[] frame = null;
lock.lock();
try {
if (listFrame.size() > 0) {
frame = listFrame.removeFirst();
}
if (frame == null && timeout != 0) {
try {
if (timeout > 0) {
condition.await(timeout, TimeUnit.MILLISECONDS);
} else {
condition.await();
}
} catch (InterruptedException e) {
// TODO: handle exception
}
}
if (listFrame.size() > 0) {
frame = listFrame.removeFirst();
}
} finally {
lock.unlock();
}
return frame;
}
/**
* Retrieves and removes the head of this queue, waiting if necessary until an element with an
* expired delay is available on this queue.
*
* @return the head of this queue
* @throws InterruptedException {@inheritDoc}
*/
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
for (; ; ) {
E first = q.peek();
if (first == null) available.await();
else {
long delay = first.getDelay(TimeUnit.NANOSECONDS);
if (delay <= 0) return q.poll();
else if (leader != null) available.await();
else {
Thread thisThread = Thread.currentThread();
leader = thisThread;
try {
available.awaitNanos(delay);
} finally {
if (leader == thisThread) leader = null;
}
}
}
}
} finally {
if (leader == null && q.peek() != null) available.signal();
lock.unlock();
}
}
/**
* Calls shutdown on current state and waits until a finished state is reached.
*
* @throws InterruptedException if the waiting for a finished state is interrupted.
*/
public void shutdown() throws InterruptedException {
stateLock.lock();
try {
isShutdown = true;
// interrupts any take operations
takeCallLock.lock();
try {
takeCallCondition.signalAll();
} finally {
takeCallLock.unlock();
}
currentServerState.shutdown();
while (true) {
if (currentServerState.getCurrentState() == ServerStates.Finished) {
break;
}
if (currentServerState.getCurrentState() == ServerStates.Error) {
break;
}
stateChangeCondition.await();
}
callMapCleanupTimer.cancel();
callMapCleanupTask.cancel();
stateTimeoutTimer.cancel();
} catch (InterruptedException e) {
throw e;
} finally {
stateLock.unlock();
}
}
/*
* (non-Javadoc)
*
* @see java.io.Reader#read(char[], int, int)
*/
@Override
public int read(char[] cbuf, int off, int len) throws IOException {
lock.lock(); // lock this object
int i = 0;
try {
// while no data to read, place thread in waiting state
while (size == 0) {
if (blocking) notEmpty.await(); // await until a buffer element is
// filled
else {
lock.unlock();
return -1;
}
} // end while
} // end try
// if waiting thread interrupted, print stack trace
catch (Exception exception) {
exception.printStackTrace();
} // end catch
for (; i < len && i < size; i++) {
cbuf[off + i] = (char) getByte();
}
notFull.signal();
lock.unlock(); // unlock this object
return i;
}
@Test(timeout = 1500l)
public void testConditionWaitsForSignalOtherThread() throws Exception {
final Lock firstLock = new ReentrantZkLock(baseLockPath, zkSessionManager);
final Condition firstCondition = firstLock.newCondition();
firstLock.lock();
// fire off a thread that will signal the main process thread
testService.submit(
new Runnable() {
@Override
public void run() {
firstLock.lock();
System.out.println("Lock acquired on second thread");
try {
firstCondition.signal();
System.out.println("Lock signalled on second thread");
} finally {
System.out.println("Lock released on second thread");
firstLock.unlock();
}
}
});
// wait for signal notification
System.out.println("First thread waiting for notification");
firstCondition.await();
System.out.println("First thread has been notified");
}
/**
* Get bytes from the buffer and return these in an array. Blocks if the buffer is empty and no
* values have yet been added to the array.
*
* @param buf array to return bytes
* @param off the off
* @param len the len
* @return the number of bytes returned in the array
*/
public int get(byte[] buf, int off, int len) {
lock.lock(); // lock this object
int i = 0;
try {
// while no data to read, place thread in waiting state
while (size == 0) {
// System.out.println("read wait");
notEmpty.await(); // await until a buffer element is
// filled
} // end while
} // end try
// if waiting thread interrupted, print stack trace
catch (Exception exception) {
exception.printStackTrace();
} // end catch
for (; i < len && i < size; i++) {
buf[off + i] = getByte();
}
notFull.signal();
lock.unlock(); // unlock this object
return i;
}
/**
* Get next value from the buffer. Blocks indefinitely if buffer is empty.
*
* @return the byte
*/
public byte get() {
byte result = 0; // initialize value read from buffer
lock.lock(); // lock this object
// wait until buffer has data, then read value
try {
// while no data to read, place thread in waiting state
while (size == 0) {
if (blocking) notEmpty.await(); // await until a buffer element is
// filled
else {
lock.unlock();
return 0;
}
} // end while
result = getByte();
notFull.signal();
} // end try
// if waiting thread interrupted, print stack trace
catch (InterruptedException exception) {
exception.printStackTrace();
Thread.currentThread().interrupt();
} // end catch
finally {
lock.unlock(); // unlock this object
} // end finally
return result;
} // end method get
public boolean put(List<Event> data, long timeout, TimeUnit unit)
throws InterruptedException, CanalStoreException {
if (data == null || data.isEmpty()) {
return true;
}
long nanos = unit.toNanos(timeout);
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
for (; ; ) {
if (checkFreeSlotAt(putSequence.get() + data.size())) {
doPut(data);
return true;
}
if (nanos <= 0) {
return false;
}
try {
nanos = notFull.awaitNanos(nanos);
} catch (InterruptedException ie) {
notFull.signal(); // propagate to non-interrupted thread
throw ie;
}
}
} finally {
lock.unlock();
}
}
public Session take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (active) {
Session first = queue.peek();
if (first == null) {
available.await();
} else {
long delay = getDelay(first, TimeUnit.NANOSECONDS);
if (delay > 0) {
available.awaitNanos(delay);
} else {
Session x = queue.poll();
assert x != null;
if (queue.size() != 0) {
available.signalAll(); // wake up other takers
}
return x;
}
}
}
throw new InterruptedException("Session queue is stopping");
} finally {
lock.unlock();
}
}
// Do not take any clustered write lock in this path.
public void add(final E item) {
if (null == item) return;
int maxQueueSize = config.getMaxQueueSize();
bucketWriteLock.lock();
boolean interrupted = false;
try {
if (maxQueueSize != UNLIMITED_QUEUE_SIZE) {
while (!isCancelled() && toolkitList.size() >= maxQueueSize) {
try {
bucketNotFull.await();
} catch (final InterruptedException e) {
interrupted = true;
}
}
}
boolean signalNotEmpty = toolkitList.isEmpty();
toolkitList.unlockedAdd(item);
if (signalNotEmpty) {
bucketNotEmpty.signalAll();
}
} finally {
bucketWriteLock.unlock();
if (interrupted) {
Thread.currentThread().interrupt();
}
}
}
public RunnableScheduledFuture<?> poll(long timeout, TimeUnit unit)
throws InterruptedException {
long nanos = unit.toNanos(timeout);
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
for (; ; ) {
RunnableScheduledFuture<?> first = queue[0];
if (first == null) {
if (nanos <= 0) return null;
else nanos = available.awaitNanos(nanos);
} else {
long delay = first.getDelay(NANOSECONDS);
if (delay <= 0) return finishPoll(first);
if (nanos <= 0) return null;
if (nanos < delay || leader != null) nanos = available.awaitNanos(nanos);
else {
Thread thisThread = Thread.currentThread();
leader = thisThread;
try {
long timeLeft = available.awaitNanos(delay);
nanos -= delay - timeLeft;
} finally {
if (leader == thisThread) leader = null;
}
}
}
}
} finally {
if (leader == null && queue[0] != null) available.signal();
lock.unlock();
}
}
/**
* Blocks until an object is received that is handled by process, or the specified timeout has
* passed.
*
* <p>Once closed any attempt to wait will throw an exception.
*
* @param timeout The timeout in milliseconds.
* @return The object that resolved the blocking.
* @throws QpidException
* @throws FailoverException
*/
public Object block(long timeout) throws QpidException, FailoverException {
if (timeout < 0) {
throw new IllegalArgumentException("timeout must be zero or greater");
}
long nanoTimeout = TimeUnit.MILLISECONDS.toNanos(timeout);
_lock.lock();
try {
if (_closed) {
throw throwClosedException();
}
if (_error == null) {
_waiting.set(true);
while (!_ready && _error == null) {
try {
nanoTimeout = _receivedCondition.awaitNanos(nanoTimeout);
if (nanoTimeout <= 0 && !_ready && _error == null) {
_error = new AMQTimeoutException("Server did not respond in a timely fashion", null);
_ready = true;
}
} catch (InterruptedException e) {
_logger.error(e.getMessage(), e);
// IGNORE -- //fixme this isn't ideal as being interrupted isn't equivalent to
// success
}
}
}
if (_error != null) {
if (_error instanceof QpidException) {
throw (QpidException) _error;
} else if (_error instanceof FailoverException) {
// This should ensure that FailoverException is not wrapped and can be caught.
throw (FailoverException) _error; // needed to expose FailoverException.
} else {
throw new QpidException("Woken up due to " + _error.getClass(), _error);
}
}
} finally {
_waiting.set(false);
// Release Error handling thread
if (_error != null) {
_errorAck = true;
_errorConditionAck.signal();
_error = null;
}
_lock.unlock();
}
return _doneObject;
}
/*
* (non-Javadoc)
*
* @see java.io.Reader#close()
*/
public void close() {
lock.lock();
notFull.signal();
notEmpty.signal();
size = 0;
putIndex = 0;
getIndex = 0;
lock.unlock();
}
@Test(timeout = 1000l)
public void testConditionTimesOut() throws Exception {
Lock firstLock = new ReentrantZkLock(baseLockPath, zkSessionManager);
Condition firstCondition = firstLock.newCondition();
firstLock.lock();
boolean timedOut = firstCondition.await(250l, TimeUnit.MILLISECONDS);
assertTrue("Condition did not time out!", !timedOut);
firstLock.unlock();
}
// we don't care about the return value but care about it throwing exception
public void runMayThrow() throws Exception {
if (endpoints.isEmpty()) {
differencingDone.signalAll();
logger.info(
"No neighbors to repair with for "
+ tablename
+ " on "
+ range
+ ": "
+ getName()
+ " completed.");
return;
}
// Checking all nodes are live
for (InetAddress endpoint : endpoints) {
if (!FailureDetector.instance.isAlive(endpoint)) {
differencingDone.signalAll();
logger.info(
"Could not proceed on repair because a neighbor ("
+ endpoint
+ ") is dead: "
+ getName()
+ " failed.");
return;
}
}
AntiEntropyService.instance.sessions.put(getName(), this);
Gossiper.instance.register(this);
FailureDetector.instance.registerFailureDetectionEventListener(this);
try {
// Create and queue a RepairJob for each column family
for (String cfname : cfnames) {
RepairJob job = new RepairJob(cfname);
jobs.offer(job);
activeJobs.put(cfname, job);
}
jobs.peek().sendTreeRequests();
// block whatever thread started this session until all requests have been returned:
// if this thread dies, the session will still complete in the background
completed.await();
if (exception != null) throw exception;
} catch (InterruptedException e) {
throw new RuntimeException(
"Interrupted while waiting for repair: repair will continue in the background.");
} finally {
FailureDetector.instance.unregisterFailureDetectionEventListener(this);
Gossiper.instance.unregister(this);
AntiEntropyService.instance.sessions.remove(getName());
}
}
public void stopNow() {
bucketWriteLock.lock();
try {
destroyAfterStop = false;
stopState = STOP_STATE.STOPPED;
bucketNotEmpty.signalAll();
bucketNotFull.signalAll();
processingWorkerThread.interrupt();
} finally {
bucketWriteLock.unlock();
}
}