protected void sendUpdates() {
// get the current version
int currentVersion = version.get();
//
boolean persist = isPersistentObject();
// get read-only version of events
ConcurrentLinkedQueue<ISharedObjectEvent> events =
new ConcurrentLinkedQueue<ISharedObjectEvent>(ownerMessage.getEvents());
// clear out previous events
ownerMessage.getEvents().clear();
//
if (!events.isEmpty()) {
// Send update to "owner" of this update request
SharedObjectMessage syncOwner = new SharedObjectMessage(null, name, currentVersion, persist);
syncOwner.addEvents(events);
if (source != null) {
// Only send updates when issued through RTMP request
Channel channel = ((RTMPConnection) source).getChannel((byte) 3);
if (channel != null) {
// ownerMessage.acquire();
channel.write(syncOwner);
log.debug("Owner: {}", channel);
} else {
log.warn("No channel found for owner changes!?");
}
}
}
// clear owner events
events.clear();
// get read-only version of sync events
events.addAll(syncEvents);
// clear out previous events
syncEvents.clear();
if (!events.isEmpty()) {
// Synchronize updates with the current listeners of this shared
for (IEventListener listener : currentListeners) {
if (listener == source) {
// Don't re-send update to active client
log.debug("Skipped {}", source);
continue;
}
if (!(listener instanceof RTMPConnection)) {
log.warn("Can't send sync message to unknown connection {}", listener);
continue;
}
// Create a new sync message for every client to avoid
// concurrent access through multiple threads
// TODO: perhaps we could cache the generated message
SharedObjectMessage syncMessage =
new SharedObjectMessage(null, name, currentVersion, persist);
syncMessage.addEvents(events);
Channel channel = ((RTMPConnection) listener).getChannel((byte) 3);
log.debug("Send to {}", channel);
channel.write(syncMessage);
}
}
}
private void initSDCardPath() {
if (!mExternalPathList.isEmpty()) {
mSDCardPath = mExternalPathList.peek();
} else if (!mInternalPathList.isEmpty()) {
mSDCardPath = mInternalPathList.peek();
} else {
mSDCardPath = Environment.getExternalStorageDirectory().getPath();
}
Log.i(TAG, "initSDCardPath() === > SDCARD PATH = (" + mSDCardPath + ")");
}
void sendPartitionInfos() {
// check if the ExecutionVertex has already been archived and thus cleared the
// partial partition infos queue
if (partialInputChannelDeploymentDescriptors != null
&& !partialInputChannelDeploymentDescriptors.isEmpty()) {
PartialInputChannelDeploymentDescriptor partialInputChannelDeploymentDescriptor;
List<IntermediateDataSetID> resultIDs = new ArrayList<IntermediateDataSetID>();
List<InputChannelDeploymentDescriptor> inputChannelDeploymentDescriptors =
new ArrayList<InputChannelDeploymentDescriptor>();
while ((partialInputChannelDeploymentDescriptor =
partialInputChannelDeploymentDescriptors.poll())
!= null) {
resultIDs.add(partialInputChannelDeploymentDescriptor.getResultId());
inputChannelDeploymentDescriptors.add(
partialInputChannelDeploymentDescriptor.createInputChannelDeploymentDescriptor(this));
}
UpdatePartitionInfo updateTaskMessage =
createUpdateTaskMultiplePartitionInfos(
attemptId, resultIDs, inputChannelDeploymentDescriptors);
sendUpdatePartitionInfoRpcCall(assignedResource, updateTaskMessage);
}
}
public void checkqueue() {
if (!ismoving && !movequeue.isEmpty()) {
ismoving = true;
UI.instance.mainview.moveto = movequeue.poll();
movequeue.remove(0);
}
}
public String getNextInboundMessage() {
String result = null;
if (!inboundCommandQueue.isEmpty()) {
result = inboundCommandQueue.poll();
}
return result;
}
/**
* Releases any resources held by the writer.
*
* @param shutdownWrapped If the wrapped writer should be closed as well.
*/
public void shutdown(boolean shutdownWrapped) {
stopRequested.set(true);
// Wait for publisher thread to terminate
while (writerThread != null && writerThread.isAlive()) {
try {
// Interrupt the thread if its blocking
writerThread.interrupt();
writerThread.join();
} catch (InterruptedException ex) {
// Ignore; we gotta wait..
}
}
// The writer writerThread SHOULD have drained the queue.
// If not, handle outstanding requests ourselves,
// and push them to the writer.
while (!queue.isEmpty()) {
String message = queue.poll();
writer.writeRecord(message);
}
// Shutdown the wrapped writer.
if (shutdownWrapped && writer != null) writer.shutdown();
DirectoryServer.deregisterShutdownListener(this);
}
/** Selects on sockets and informs their Communicator when there is something to do. */
public void communicate(int timeout) {
try {
selector.select(timeout);
} catch (IOException e) {
// Not really sure why/when this happens yet
return;
}
Iterator<SelectionKey> keys = selector.selectedKeys().iterator();
while (keys.hasNext()) {
SelectionKey key = keys.next();
keys.remove();
if (!key.isValid()) continue; // WHY
Communicator communicator = (Communicator) key.attachment();
if (key.isReadable()) communicator.onReadable();
if (key.isWritable()) communicator.onWritable();
if (key.isAcceptable()) communicator.onAcceptable();
}
// Go through the queue and handle each communicator
while (!queue.isEmpty()) {
Communicator c = queue.poll();
c.onMemo();
}
}
public void run() {
// while (queue.size()>0) {
while (!queue
.isEmpty()) { // 这里不要用size（）==0会非常耗时 会遍历一遍整个队列 而isEmpty()则是看看队列对头是否为空 要是为空则整个队列的大小就是0
// while(queue.size()!=0){
System.out.println(queue.poll());
}
latch.countDown();
}
void offer(Action action) {
if (DEBUG) {
assertOnIcThread();
Log.d(
LOGTAG, "offer: Action(" + getConstantName(Action.class, "TYPE_", action.mType) + ")");
}
/* Events don't need update because they generate text/selection
notifications which will do the updating for us */
if (action.mType != Action.TYPE_EVENT
&& action.mType != Action.TYPE_ACKNOWLEDGE_FOCUS
&& action.mType != Action.TYPE_SET_HANDLER) {
action.mShouldUpdate = mUpdateGecko;
}
if (mActions.isEmpty()) {
mActionsActive.acquireUninterruptibly();
mActions.offer(action);
} else
synchronized (this) {
// tryAcquire here in case Gecko thread has just released it
mActionsActive.tryAcquire();
mActions.offer(action);
}
switch (action.mType) {
case Action.TYPE_EVENT:
case Action.TYPE_SET_SELECTION:
case Action.TYPE_SET_SPAN:
case Action.TYPE_REMOVE_SPAN:
case Action.TYPE_SET_HANDLER:
onImeSynchronize();
break;
case Action.TYPE_REPLACE_TEXT:
// try key events first
sendCharKeyEvents(action);
// fall-through
case Action.TYPE_COMPOSE_TEXT:
onImeReplaceText(
action.mStart,
action.mEnd,
action.mSequence.toString(),
action.mType == Action.TYPE_COMPOSE_TEXT);
break;
case Action.TYPE_ACKNOWLEDGE_FOCUS:
onImeAcknowledgeFocus();
break;
default:
throw new IllegalStateException("Action not processed");
}
++mIcUpdateSeqno;
}
private void scheduleNext() {
if (!queue.isEmpty() && running.compareAndSet(false, true)) {
try {
executor.execute(runner);
} catch (Throwable t) {
running.set(false);
throw t;
}
}
}
/**
* Adds log messages for rendering.
*
* @param lines Builder of lines to render this frame.
*/
private void renderLogMessages(ImmutableList.Builder<String> lines) {
if (logEvents.isEmpty()) {
return;
}
lines.add("Log:");
for (LogEvent logEvent : logEvents) {
formatLogEvent(logEvent, lines);
}
}
public MemcachedClient getMClient() {
// TODO Auto-generated method stub
MemcachedClient mc;
if (availablePool.isEmpty()) {
mc = createMClient();
} else {
mc = availablePool.poll();
busyPool.add(mc);
}
return mc;
}
void notifyDroneConnectionFailed(final ConnectionResult result) {
if (droneListeners.isEmpty()) return;
handler.post(
new Runnable() {
@Override
public void run() {
for (DroneListener listener : droneListeners) listener.onDroneConnectionFailed(result);
}
});
}
@Override
public void run() {
for (Map.Entry<String, ConcurrentLinkedQueue<HttpRequestTrace>> entry :
connectionIdToRequestTracesMap.entrySet()) {
final ConcurrentLinkedQueue<HttpRequestTrace> httpRequestTraces = entry.getValue();
removeOldRequestTraces(httpRequestTraces);
if (httpRequestTraces.isEmpty()) {
removeOrphanEntry(entry);
}
}
}
void notifyDroneServiceInterrupted(final String errorMsg) {
if (droneListeners.isEmpty()) return;
handler.post(
new Runnable() {
@Override
public void run() {
for (DroneListener listener : droneListeners)
listener.onDroneServiceInterrupted(errorMsg);
}
});
}
/** Remove the head of the queue. Throw if queue is empty. */
void poll() {
if (DEBUG) {
ThreadUtils.assertOnGeckoThread();
}
if (mActions.poll() == null) {
throw new IllegalStateException("empty actions queue");
}
synchronized (this) {
if (mActions.isEmpty()) {
mActionsActive.release();
}
}
}
void syncWithGecko() {
if (DEBUG) {
assertOnIcThread();
}
if (mFocused && !mActions.isEmpty()) {
if (DEBUG) {
Log.d(LOGTAG, "syncWithGecko blocking on thread " + Thread.currentThread().getName());
}
mActionsActive.acquireUninterruptibly();
mActionsActive.release();
} else if (DEBUG && !mFocused) {
Log.d(LOGTAG, "skipped syncWithGecko (no focus)");
}
}
private boolean queueQuery(QuerySpec queryData) {
queryData.searchQuery = mSearchQuery;
Boolean queuedQuery;
synchronized (mQueryQueue) {
queuedQuery = false;
Boolean doQueryNow = mQueryQueue.isEmpty();
mQueryQueue.add(queryData);
queuedQuery = true;
if (doQueryNow) {
doQuery(queryData);
}
}
return queuedQuery;
}
private synchronized void drainBuffer() {
logger.debug("draining buffer");
UILogger.getInstance().add("draining buffer");
while (!notificationsBuffer.isEmpty()) {
final ApnsNotification notification = notificationsBuffer.poll();
try {
sendMessage(notification, true);
} catch (NetworkIOException ex) {
// at this point we are retrying the submission of messages but failing to connect to APNS,
// therefore
// notify the client of this
delegate.messageSendFailed(notification, ex);
}
}
}
public void run() {
while (!this.server.isStopped()) {
try {
if (!queue.isEmpty()) {
// System.out.println("queue not empty");
this.free = false;
flag = 0;
WorkSet set = queue.poll();
synchronized (refineSet) {
if (set.sequence != refineSet.get(set)) {
LOG.info("Job queue cache hit, the row is obsolete " + set.getRow());
System.out.println("cache hits");
continue;
} else {
refineSet.remove(set);
}
}
// System.out.println("get job");
set.getR()
.updateCCIndex(set.getIndexSpec(), set.getRow(), set.getColumnValues(), set.d);
} else {
// System.out.println("queue is empty");
try {
this.free = true;
if (flag >= this.sleepTime.length - 1) {
flushTable();
// System.out.println(this.getId()
// + ":there is no jobs");
sleep(this.sleepTime[flag]);
} else {
// flushTable();
sleep(this.sleepTime[flag++]);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
} catch (Exception e) {
continue;
}
}
}
@Override
protected void flush() {
if (changes.isEmpty()) return;
ImmutableSet.Builder<ScoreboardChange> changesBuilder = ImmutableSet.builder();
ScoreboardChange pending;
while ((pending = this.changes.poll()) != null) {
changesBuilder.add(pending);
}
ImmutableSet<ScoreboardChange> changes = changesBuilder.build();
for (ScoreboardChange change : changes) {
change.execute(buffer);
}
swapBuffer();
for (ScoreboardChange change : changes) {
change.execute(buffer);
}
}
/**
* https://issues.apache.org/jira/browse/WICKET-5316
*
* @throws Exception
*/
@Test
public void failToReleaseUnderLoad() throws Exception {
final Duration duration = Duration.seconds(20); /* seconds */
final ConcurrentLinkedQueue<Exception> errors = new ConcurrentLinkedQueue<Exception>();
final long endTime = System.currentTimeMillis() + duration.getMilliseconds();
// set the synchronizer timeout one second longer than the test runs to prevent
// starvation to become an issue
final PageAccessSynchronizer sync =
new PageAccessSynchronizer(duration.add(Duration.ONE_SECOND));
final CountDownLatch latch = new CountDownLatch(100);
for (int count = 0; count < 100; count++) {
new Thread() {
@Override
public void run() {
try {
while (System.currentTimeMillis() < endTime) {
try {
logger.debug(Thread.currentThread().getName() + " locking");
sync.lockPage(0);
Thread.sleep(1);
logger.debug(Thread.currentThread().getName() + " locked");
sync.unlockAllPages();
logger.debug(Thread.currentThread().getName() + " unlocked");
Thread.sleep(5);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
errors.add(e);
} finally {
latch.countDown();
}
}
}.start();
}
latch.await();
if (!errors.isEmpty()) {
logger.error("Number of lock errors that occurred: {}", errors.size());
throw errors.remove();
}
}
// Handle any requests that have been made against the client.
private void handleInputQueue() {
if (!addedQueue.isEmpty()) {
getLogger().debug("Handling queue");
// If there's stuff in the added queue. Try to process it.
Collection<MemcachedNode> toAdd = new HashSet<MemcachedNode>();
// Transfer the queue into a hashset. There are very likely more
// additions than there are nodes.
Collection<MemcachedNode> todo = new HashSet<MemcachedNode>();
try {
MemcachedNode qa = null;
while ((qa = addedQueue.remove()) != null) {
todo.add(qa);
}
} catch (NoSuchElementException e) {
// Found everything
}
// Now process the queue.
for (MemcachedNode qa : todo) {
boolean readyForIO = false;
if (qa.isActive()) {
if (qa.getCurrentWriteOp() != null) {
readyForIO = true;
getLogger().debug("Handling queued write %s", qa);
}
} else {
toAdd.add(qa);
}
qa.copyInputQueue();
if (readyForIO) {
try {
if (qa.getWbuf().hasRemaining()) {
handleWrites(qa.getSk(), qa);
}
} catch (IOException e) {
getLogger().warn("Exception handling write", e);
queueReconnect(qa);
}
}
qa.fixupOps();
}
addedQueue.addAll(toAdd);
}
}
void flushOneOrMoreLedgers(boolean doAll) throws IOException {
if (ledgersToFlush.isEmpty()) {
ledgersToFlush.addAll(pageMapAndList.getActiveLedgers());
}
Long potentiallyDirtyLedger;
while (null != (potentiallyDirtyLedger = ledgersToFlush.poll())) {
if (!ledgersFlushing.add(potentiallyDirtyLedger)) {
continue;
}
try {
flushSpecificLedger(potentiallyDirtyLedger);
} finally {
ledgersFlushing.remove(potentiallyDirtyLedger);
}
if (!doAll) {
break;
}
}
}
public void run() {
HawtDispatchQueue original = HawtDispatcher.CURRENT_QUEUE.get();
HawtDispatcher.CURRENT_QUEUE.set(this);
executing.set(Boolean.TRUE);
try {
Runnable runnable;
while ((runnable = externalQueue.poll()) != null) {
localQueue.add(runnable);
}
while (true) {
if (isSuspended()) {
return;
}
runnable = localQueue.poll();
if (runnable == null) {
return;
}
try {
runnable.run();
} catch (Throwable e) {
Thread thread = Thread.currentThread();
thread.getUncaughtExceptionHandler().uncaughtException(thread, e);
}
}
} finally {
// Posts any deferred events. This ensures
// the next events generated by this dispatch
// queue are received in order.
for (Runnable runnable : sourceQueue) {
runnable.run();
}
sourceQueue.clear();
executing.remove();
HawtDispatcher.CURRENT_QUEUE.set(original);
triggered.set(false);
boolean empty = externalQueue.isEmpty() && localQueue.isEmpty();
if (!isSuspended() && !empty) {
triggerExecution();
}
}
}
@Override
public boolean registerListener(NotificationListener listener) throws IOException {
checkNotNull(listener);
checkError();
synchronized (lock) {
if (isReleased || !returnedBuffers.isEmpty()) {
return false;
}
if (registeredListener == null) {
registeredListener = listener;
return true;
}
}
throw new IllegalStateException("Already registered listener.");
}
public void run() {
while (!this.stoped) {
try {
synchronized (enQueSignal) {
while (mq.isEmpty() == true && stoped == false) {
try {
enQueSignal.wait(1);
} catch (InterruptedException e) {
}
// System.out.println("sender wake up");
}
processMessage();
}
} catch (Exception e) {
e.printStackTrace();
} catch (Throwable t) {
t.printStackTrace();
}
}
}
void notifyAttributeUpdated(final String attributeEvent, final Bundle extras) {
// Update the bundle classloader
if (extras != null) extras.setClassLoader(contextClassLoader);
if (AttributeEvent.STATE_UPDATED.equals(attributeEvent)) {
getAttributeAsync(
AttributeType.STATE,
new OnAttributeRetrievedCallback<State>() {
@Override
public void onRetrievalSucceed(State state) {
if (state.isFlying()) resetFlightTimer();
else stopTimer();
}
@Override
public void onRetrievalFailed() {
stopTimer();
}
});
} else if (AttributeEvent.SPEED_UPDATED.equals(attributeEvent)) {
checkForGroundCollision();
}
if (droneListeners.isEmpty()) return;
handler.post(
new Runnable() {
@Override
public void run() {
for (DroneListener listener : droneListeners) {
try {
listener.onDroneEvent(attributeEvent, extras);
} catch (Exception e) {
Log.e(TAG, e.getMessage(), e);
}
}
}
});
}
// Apply common parent filter
private boolean isReliable(
ConcurrentLinkedQueue<Node> originallist, ConcurrentHashMap<Node, int[]> intermap) {
ConcurrentLinkedQueue<Node> lowest = new ConcurrentLinkedQueue<Node>();
for (Node entry : originallist) {
boolean toAdd = true;
if (isSignificant(intermap.get(entry), this._STATMIN)) {
for (Node node : lowest) {
// For each node already in the list,
if (isChild(entry, node)) {
// if entry is child of an existing node, remove the
// node
lowest.remove(node);
} else if (isChild(node, entry)) {
// if entry is parent of an existing node, dont add the
// entry
toAdd = false;
break;
}
}
if (toAdd) lowest.add(entry);
}
}
if (lowest.isEmpty()) return false;
// Then for each lowest entry, if one is not reliable, return false
for (Node node : lowest) {
if (getReliabilityScore(intermap.get(node), this._STATMIN) < 0.9) {
return false;
}
}
return true;
}
public boolean workPending() {
synchronized (messageQueue) {
return messageQueue.isEmpty() && !working;
}
}