/**
* 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();
}
}
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();
}
}
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 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 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();
}
}
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();
}
}
/**
* 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();
}
}
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;
}
/** Acquire one permit from the semaphore in a manner that can be interrupted. */
public void acquire() throws InterruptedException {
// TODO - you fill in here.
lock.lockInterruptibly();
try {
while (availablePermits() == 0) permitAvailable.await();
numAvailablePermits--;
} finally {
lock.unlock();
}
}
public T take() throws InterruptedException {
lock.lockInterruptibly();
try {
while (count == 0) {
notEmpty.await();
}
return dequeue();
} finally {
lock.unlock();
}
}
public void put(T t) throws InterruptedException {
lock.lockInterruptibly();
try {
while (count == getCapacity()) {
notFull.await();
}
enqueue(t);
} finally {
lock.unlock();
}
}
@Override
public E takeFirst() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
E result;
try {
while ((result = removeAt(0)) == null) notEmpty.await();
} finally {
lock.unlock();
}
return result;
}
/** Acquire one permit from the semaphore in a manner that can be interrupted. */
public void acquire() throws InterruptedException {
// TODO - you fill in here.
reentrantLock.lockInterruptibly();
try {
while (permits == 0) {
condition.await();
}
permits--;
} finally {
reentrantLock.unlock();
}
}
@Override
public E pollFirst(long timeout, TimeUnit unit) throws InterruptedException {
long nanos = unit.toNanos(timeout);
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
E result;
try {
while ((result = removeAt(0)) == null && nanos > 0) nanos = notEmpty.awaitNanos(nanos);
} finally {
lock.unlock();
}
return result;
}
public void insert(E obj) throws Exception {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (this.capacity == this.queue.size()) {
this.notFull.await();
}
this.queue.add(obj);
this.notEmpty.signal();
} finally {
lock.unlock();
}
}
@Override
public E takeLast() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
E result;
try {
int indexMax = indexOfLargerChild(deque, size, 0, comparator);
int indexRemove = indexMax > 0 ? indexMax : 0;
while ((result = removeAt(indexRemove)) == null) notEmpty.await();
} finally {
lock.unlock();
}
return result;
}
public E remove() throws Exception {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (queue.size() == 0) {
this.notEmpty.await();
}
E result = this.queue.poll();
this.notFull.signal();
return result;
} finally {
lock.unlock();
}
}
public final Object call() throws Exception {
barrier.await();
int sum = v;
int x = 0;
int n = ITERS;
while (n-- > 0) {
lock.lockInterruptibly();
try {
v = x = LoopHelpers.compute1(v);
} finally {
lock.unlock();
}
sum += LoopHelpers.compute2(LoopHelpers.compute2(x));
}
return new Integer(sum);
}
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
try {
while (count == 0) notEmpty.await();
} catch (InterruptedException ie) {
notEmpty.signal(); // propagate to non-interrupted thread
throw ie;
}
E x = extract();
return x;
} finally {
lock.unlock();
}
}
/**
* Inserts the specified element at the tail of this queue, waiting for space to become available
* if the queue is full.
*
* @throws InterruptedException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
*/
public void put(E e) throws InterruptedException {
if (e == null) throw new NullPointerException();
final E[] items = this.items;
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
try {
while (count == items.length) notFull.await();
} catch (InterruptedException ie) {
notFull.signal(); // propagate to non-interrupted thread
throw ie;
}
insert(e);
} finally {
lock.unlock();
}
}
public Events<Event> get(Position start, int batchSize)
throws InterruptedException, CanalStoreException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
try {
while (!checkUnGetSlotAt((LogPosition) start, batchSize)) notEmpty.await();
} catch (InterruptedException ie) {
notEmpty.signal(); // propagate to non-interrupted thread
throw ie;
}
return doGet(start, batchSize);
} finally {
lock.unlock();
}
}
public boolean enterIfInterruptibly(Monitor.Guard var1) throws InterruptedException {
if (var1.monitor != this) {
throw new IllegalMonitorStateException();
} else {
ReentrantLock var2 = this.lock;
var2.lockInterruptibly();
boolean var3 = false;
boolean var4;
try {
var4 = var3 = var1.isSatisfied();
} finally {
if (!var3) {
var2.unlock();
}
}
return var4;
}
}
@Override
public void resume() throws EventException {
try {
lock.lockInterruptibly();
} catch (Exception ne) {
throw new EventException(ne);
}
try {
awaitPaused = false;
// We don't have to actually start anything again because the getMessage(...) call reconnects
// automatically.
paused.signalAll();
logger.info(getName() + " running");
System.out.println(getName() + " running");
} finally {
lock.unlock();
}
}
/**
* Wait on the latest, previously enlisted element to get forced or failed.
*
* <p>Important: A call to this method measures the storage of all enlisted element that were
* enlisted in the current thread under the assumption that elements are stored in the order they
* were placed in the queue.
*
* @return returns true if the force operation succeeded and false if an IO error was reported.
*/
public boolean waitOnEnlisted() {
long enlistedElementNumber =
pendingRecordsQueue.getMaxElementSequenceNumberForCurrentThread(true);
try {
// Wait until we have our entry forced (may not require a wait at all if it already happened).
forceLock.lockInterruptibly();
try {
while (enlistedElementNumber > latestForcedElement.get()) {
if (verifyIsInFailedRange(enlistedElementNumber)) return false;
if (log.isDebugEnabled()) {
log.debug(
"Waiting until entry with sequence " + enlistedElementNumber + " was forced.");
}
performedForce.await();
}
} finally {
forceLock.unlock();
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException(e);
}
// Check if we had an exception.
if (verifyIsInFailedRange(enlistedElementNumber)) {
return false;
} else {
if (log.isDebugEnabled()) {
log.debug(
"Entry with sequence "
+ enlistedElementNumber
+ " was successfully forced (force ranges up to "
+ latestForcedElement.get()
+ ").");
}
return true;
}
}
public E poll(long timeout, TimeUnit unit) throws InterruptedException {
long nanos = unit.toNanos(timeout);
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
for (; ; ) {
if (count != 0) {
E x = extract();
return x;
}
if (nanos <= 0) return null;
try {
nanos = notEmpty.awaitNanos(nanos);
} catch (InterruptedException ie) {
notEmpty.signal(); // propagate to non-interrupted thread
throw ie;
}
}
} finally {
lock.unlock();
}
}
public void enterWhen(Monitor.Guard var1) throws InterruptedException {
if (var1.monitor != this) {
throw new IllegalMonitorStateException();
} else {
ReentrantLock var2 = this.lock;
boolean var3 = var2.isHeldByCurrentThread();
var2.lockInterruptibly();
boolean var4 = false;
try {
if (!var1.isSatisfied()) {
this.await(var1, var3);
}
var4 = true;
} finally {
if (!var4) {
this.leave();
}
}
}
}
/**
* <pre>
* Makes it possible to test invalid usages of {@link Locale#getDefault()} in a synchronized
* manner making sure that test cases don't fail suddenly when they are run concurrently.
* I.e a pipelined version of {@link Locale#getDefault()}.
*
* <b>Note:</b> Don't forget to call {@link #resetDefaultLocale()} when you're done with using
* the {@link Locale#getDefault()} method. Otherwise other threads waiting to use it may starve.
*
* @param locale the locale {@link Locale#getDefault()} should return
* @throws InterruptedException if the current thread is interrupted
* @return the previous default locale
* </pre>
*/
public static Locale setDefault(Locale locale) throws InterruptedException {
checkNotNull(locale);
// Allow the same thread to change the locale during its "period" without locking
if (!LOCK.isHeldByCurrentThread()) {
try {
LOCK.lockInterruptibly();
defaultLocale = Locale.getDefault();
} catch (InterruptedException interrupt) {
throw new InterruptedException(
format(
"%s waited on %s to finish using %s but got interrupted",
currentThread().getName(), LOCK, Locale.getDefault()));
}
}
try {
Locale.setDefault(locale);
} catch (SecurityException e) {
LOCK.unlock(); // Let someone else try again
throw e;
}
return defaultLocale;
}
@Override
public void pause() throws EventException {
if (!isActive()) return; // Nothing to pause
try {
lock.lockInterruptibly();
} catch (Exception ne) {
throw new EventException(ne);
}
try {
awaitPaused = true;
if (mconsumer != null) mconsumer.close();
mconsumer = null; // Force unpaused consumers to make a new connection.
logger.info(getName() + " is paused");
System.out.println(getName() + " is paused");
} catch (Exception ne) {
throw new EventException(ne);
} finally {
lock.unlock();
}
}
/**
* Inserts the specified element at the tail of this queue, waiting up to the specified wait time
* for space to become available if the queue is full.
*
* @throws InterruptedException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
*/
public boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException {
if (e == null) throw new NullPointerException();
long nanos = unit.toNanos(timeout);
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
for (; ; ) {
if (count != items.length) {
insert(e);
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 void put(List<Event> data) throws InterruptedException, CanalStoreException {
if (data == null || data.isEmpty()) {
return;
}
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
try {
while (!checkFreeSlotAt(putSequence.get() + data.size())) { // 检查是否有空位
notFull.await(); // wait until not full
}
} catch (InterruptedException ie) {
notFull.signal(); // propagate to non-interrupted thread
throw ie;
}
doPut(data);
if (Thread.interrupted()) {
throw new InterruptedException();
}
} finally {
lock.unlock();
}
}