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
}
}
// 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();
}
}
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();
}
}
/**
* @throws UnsupportedOperationException {@inheritDoc}
* @throws ClassCastException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
* @throws IllegalArgumentException {@inheritDoc}
*/
public int drainTo(Collection<? super E> c, int maxElements) {
if (c == null) throw new NullPointerException();
if (c == this) throw new IllegalArgumentException();
if (maxElements <= 0) return 0;
final E[] items = this.items;
final ReentrantLock lock = this.lock;
lock.lock();
try {
int i = takeIndex;
int n = 0;
int sz = count;
int max = (maxElements < count) ? maxElements : count;
while (n < max) {
c.add(items[i]);
items[i] = null;
i = inc(i);
++n;
}
if (n > 0) {
count -= n;
takeIndex = i;
notFull.signalAll();
}
return n;
} finally {
lock.unlock();
}
}
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;
}
/**
* Removes the next element (at hd +1). <em>Note that this method is not concurrent, as RingBuffer
* can only have 1 remover thread active at any time !</em>
*
* @param nullify Nulls the element in the array if true
* @return T if there was a non-null element at position hd +1, or null if the element at hd+1 was
* null, or hd+1 > hr.
*/
public T remove(boolean nullify) {
long tmp = hd + 1;
if (tmp > hr.get()) return null;
int index = index(tmp);
T element = buf.get(index);
if (element == null) return null;
hd = tmp;
if (nullify) {
long tmp_low = low;
if (tmp == tmp_low + 1) buf.compareAndSet(index, element, null);
else {
int from = index(tmp_low + 1), length = (int) (tmp - tmp_low), capacity = capacity();
for (int i = from; i < from + length; i++) {
index = i % capacity;
buf.set(index, null);
}
}
low = tmp;
lock.lock();
try {
buffer_full.signalAll();
} finally {
lock.unlock();
}
}
return element;
}
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();
}
}
/**
* Append next message part to the buffer.
*
* @param message the message.
* @param last should be {@code true} iff this is the last part of the message, {@code false}
* otherwise.
*/
public void appendMessagePart(ByteBuffer message, boolean last) {
lock.lock();
try {
currentlyBuffered += message.remaining();
if (currentlyBuffered <= bufferSize) {
bufferedFragments.add(message);
} else {
final MessageTooBigException messageTooBigException =
new MessageTooBigException(LocalizationMessages.PARTIAL_MESSAGE_BUFFER_OVERFLOW());
LOGGER.log(
Level.FINE,
LocalizationMessages.PARTIAL_MESSAGE_BUFFER_OVERFLOW(),
messageTooBigException);
receivedLast = true;
throw messageTooBigException;
}
this.receivedLast = last;
condition.signalAll();
} finally {
lock.unlock();
}
if (this.inputStream == null) {
this.inputStream = new BufferedInputStream(this);
executorService.execute(
new Runnable() {
@Override
public void run() {
messageHandler.onMessage(inputStream);
}
});
}
}
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();
}
}
protected void flush(final Address new_coord) throws InterruptedException {
// wait until all threads currently sending messages have returned (new threads after
// flushing=true) will block
// flushing is set to true in startFlusher()
while (flushing && running) {
if (in_flight_sends.get() == 0) break;
Thread.sleep(100);
}
send_lock.lockInterruptibly();
try {
if (log.isTraceEnabled())
log.trace(local_addr + ": coord changed from " + coord + " to " + new_coord);
coord = new_coord;
is_coord = Objects.equals(local_addr, coord);
flushMessagesInForwardTable();
} finally {
if (log.isTraceEnabled()) log.trace(local_addr + ": flushing completed");
flushing = false;
ack_mode = true; // go to ack-mode after flushing
num_acks = 0;
send_cond.signalAll();
send_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();
}
}
private void onStartCommand(String commandDisplayName, Runnable onDisconnect) {
lock.lock();
try {
switch (state) {
case Broken:
throw new DaemonUnavailableException("This daemon is in a broken state and will stop.");
case StopRequested:
throw new DaemonUnavailableException("This daemon is currently stopping.");
case Stopped:
throw new DaemonUnavailableException("This daemon has stopped.");
}
if (currentCommandExecution != null) {
throw new DaemonUnavailableException(
String.format("This daemon is currently executing: %s", currentCommandExecution));
}
LOGGER.debug(
"onStartCommand({}) called after {} minutes of idle",
commandDisplayName,
getIdleMinutes());
try {
onStartCommand.run();
currentCommandExecution = commandDisplayName;
this.onDisconnect = onDisconnect;
updateActivityTimestamp();
condition.signalAll();
} catch (Throwable throwable) {
setState(State.Broken);
throw UncheckedException.throwAsUncheckedException(throwable);
}
} finally {
lock.unlock();
}
}
private void onFinishCommand() {
lock.lock();
try {
String execution = currentCommandExecution;
LOGGER.debug("onFinishCommand() called while execution = {}", execution);
currentCommandExecution = null;
onDisconnect = null;
updateActivityTimestamp();
switch (state) {
case Running:
try {
onFinishCommand.run();
condition.signalAll();
} catch (Throwable throwable) {
setState(State.Broken);
throw UncheckedException.throwAsUncheckedException(throwable);
}
break;
case StopRequested:
stop();
break;
case Stopped:
break;
default:
throw new IllegalStateException("Daemon is in unexpected state: " + state);
}
} finally {
lock.unlock();
}
}
private void backgroundCall() throws IOException {
mutex.lock();
try {
if (backgroundCompaction == null) {
return;
}
try {
if (!shuttingDown.get()) {
backgroundCompaction();
}
} finally {
backgroundCompaction = null;
}
} finally {
try {
// Previous compaction may have produced too many files in a level,
// so reschedule another compaction if needed.
maybeScheduleCompaction();
} finally {
try {
backgroundCondition.signalAll();
} finally {
mutex.unlock();
}
}
}
}
private void compactMemTableInternal() throws IOException {
Preconditions.checkState(mutex.isHeldByCurrentThread());
if (immutableMemTable == null) {
return;
}
try {
// Save the contents of the memtable as a new Table
VersionEdit edit = new VersionEdit();
Version base = versions.getCurrent();
writeLevel0Table(immutableMemTable, edit, base);
if (shuttingDown.get()) {
throw new DatabaseShutdownException("Database shutdown during memtable compaction");
}
// Replace immutable memtable with the generated Table
edit.setPreviousLogNumber(0);
edit.setLogNumber(log.getFileNumber()); // Earlier logs no longer needed
versions.logAndApply(edit);
immutableMemTable = null;
deleteObsoleteFiles();
} finally {
backgroundCondition.signalAll();
}
}
/**
* 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();
}
}
@Override
public void handleMessage(Message msg) {
if (!mListenerAdded) {
Looper.myQueue().addIdleHandler(this);
mListenerAdded = true;
}
removeMessages(BLANK);
lock.lock();
try {
// Perform up to 10 tasks at once.
// Consider only performing 10 remove tasks, not adds and animations.
// Removes are relatively slow and are much better when batched.
for (int i = 0; i < 10; i++) {
performNextTask();
}
if (!isBusy()) {
mListenerAdded = false;
Looper.myQueue().removeIdleHandler(this);
// Signal any other threads that are waiting.
busyCondition.signalAll();
} else {
// Sometimes the idle queue may not be called - schedule up some work regardless
// of whether the UI thread is busy or not.
// TODO: try to remove this.
sendEmptyMessageDelayed(BLANK, 10);
}
} 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 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 void doNotify() {
lock.lock();
try {
condition.signalAll();
} finally {
lock.unlock();
}
}
private void signalStop() {
bucketWriteLock.lock();
try {
stoppedButBucketNotEmpty.signalAll();
} finally {
bucketWriteLock.unlock();
}
}
public void stop(int maxTime) {
if (maxTime != 0) {
awaitFinish(maxTime);
}
synchronized (this) {
runState = STATE_STOP;
}
try {
lock.lock();
hasFreeThread.signalAll();
hasTask.signalAll();
releaseAllFreeThread();
} finally {
lock.unlock();
}
logger.info("线程池即将关闭");
}
public void finishJoin() {
joinStateLock.lock();
try {
joinState = JoinState.JOINED;
joined.signalAll();
} finally {
joinStateLock.unlock();
}
}
@Override
public void signalAllWhenBlocking() {
lock.lock();
try {
processorNotifyCondition.signalAll();
} finally {
lock.unlock();
}
}
public void stop() {
bucketWriteLock.lock();
try {
workDelay.set(0);
stopState = STOP_STATE.STOP_REQUESTED;
while (!toolkitList.isEmpty()) {
stoppedButBucketNotEmpty.await();
}
stopState = STOP_STATE.STOPPED;
bucketNotEmpty.signalAll();
bucketNotFull.signalAll();
processingWorkerThread.interrupt();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
bucketWriteLock.unlock();
}
}
public void unlock() {
lock.lock();
failingOver = false;
failoverCondition.signalAll();
lock.unlock();
}
/**
* Queues error that will be thrown in any waiting thread or any thread that attempts to wait on
* this future hereafter.
*
* @param e the error
*/
public void error(Throwable e) {
lock();
try {
pendingEx = chainer.chain(e);
cond.signalAll();
} finally {
unlock();
}
}