/** * * 解析从服务器收到的包,切割完整包,并返回半包 * * @param unHandledPkg 从socket收到的数据包 * @param parser 不同的协议,传递不同的包内容解析器 * @return 如果收到的包是一个或者多个完整包,那么返回0长度字节数组 如果收到的包是1个半或者N个半数据包,那么截取一个或N个完整包,并把剩余的部分返回 */ private final byte[] handlePackage(byte[] unHandledPkg, IPackageContenParser parser) { /** 调用一次read,从Server收到的数据包(可能是半包、1个包、1.x、2.x....) */ int pkgLen = unHandledPkg.length; /** 一个完整数据包的长度 */ int completePkgLen = parser.getCompletePackageLength(unHandledPkg); if (completePkgLen > pkgLen) { /** 当前收到的数据不到一个完整包,则直接返回,等待下一个包 */ return unHandledPkg; } else if (completePkgLen == pkgLen) { /** 一个完整包,则直接丢到已处理队列 */ handledQueue.offer(unHandledPkg); return EmptyContainer.EMPTY_BYTE_ARRAY; } else { /** 有多个包,那么就递归解析, */ byte[] onePkg = parser.getCompletePackage(unHandledPkg); handledQueue.offer(onePkg); /** 截取除完整包后的剩余部分 */ byte[] remain = PackageTools.getSubBytes(unHandledPkg, onePkg.length, pkgLen - onePkg.length); return handlePackage(remain, parser); } }
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; }
@Override public void release(char[] value) { releaseCalls.incrementAndGet(); QUEUE.offer(value); }
public static void release(SessionRemote sr) { if (sr == null || sr.isClosed()) return; ConcurrentLinkedQueue<SessionRemote> queue = getQueue(sr.getURL()); if (queue.size() > corePoolSize) sr.close(); else queue.offer(sr); }
/** * 下载一个任务 * * @param url * @param listener */ public void addTask(String url, DownloadListener listener) { if (StringUtils.isEmpty(url)) { Logger.d("download url null"); return; } DownloadInfo downloadInfo = new DownloadInfo(); downloadInfo.setUrl(url); if (!hasTask(url)) { downloadInfo.setTargetFolder(mTargetFolder); try { mDbHelper.save(downloadInfo); } catch (DbException e) { Logger.e(e); } if (mDownloadingTasks.size() < MAX_DOWNLOAD_COUNT) { downloadInfo.setState(DownloadInfo.DOWNLOADING); mDownloadingTasks.add(downloadInfo); DownloadHttpTask task = new DownloadHttpTask(downloadInfo, mDownloadUIHandler, mDbHelper, this); mDownloadingTaskMap.put(url, task); task.start(); } else { // 加入等待队列 downloadInfo.setState(DownloadInfo.WAIT); boolean b = mWaitTasks.offer(downloadInfo); if (b) { addTaskListener(url, listener); } } mAllTasks.add(downloadInfo); } else { Logger.d("任务已存在"); } }
/** * 重新下载 * * @param url */ public void restartTask(String url) { Iterator<DownloadInfo> pauseIt = mPausingTasks.iterator(); if (mPausingTasks.size() > 0) { synchronized (mIteratorLock) { while (pauseIt.hasNext()) { DownloadInfo downloadInfo = pauseIt.next(); if (TextUtils.equals(downloadInfo.getUrl(), url)) { if (mDownloadingTasks.size() < MAX_DOWNLOAD_COUNT) { downloadInfo.setState(DownloadInfo.DOWNLOADING); DownloadHttpTask task = new DownloadHttpTask(downloadInfo, mDownloadUIHandler, mDbHelper, this); mDownloadingTaskMap.put(url, task); mDownloadingTasks.add(downloadInfo); pauseIt.remove(); task.start(); } else { downloadInfo.setState(DownloadInfo.WAIT); mWaitTasks.offer(downloadInfo); pauseIt.remove(); } return; } } } } else { stopTask(url); restartTask(url); } }
public void writeChunk(Object chunk) throws Exception { String message = chunk == null ? "" : chunk.toString(); StringWriter writer = new StringWriter(); Integer l = message.getBytes("utf-8").length + 2; writer.append(Integer.toHexString(l)).append("\r\n").append(message).append("\r\n\r\n"); nextChunks.offer(writer.toString()); }
public ObjectPool(Class<T> c, int preAllocate) { queue = new ConcurrentLinkedQueue<T>(); this.c = c; for (int i = 0; i < preAllocate; i++) { queue.offer(newInstance()); } }
public ObjectPool(ObjectGenerator<T> generator, int preAllocate) { queue = new ConcurrentLinkedQueue<T>(); this.generator = generator; for (int i = 0; i < preAllocate; i++) { queue.offer(newInstance()); } }
@Override public boolean offer(E e) { if (queue.size() > capacity) { queue.poll(); } queue.offer(e); return true; }
public void addOperation(final MemcachedNode node, final Operation o) { o.initialize(); node.addOp(o); addedQueue.offer(node); Selector s = selector.wakeup(); assert s == selector : "Wakeup returned the wrong selector."; getLogger().debug("Added %s to %s", o, node); }
public void restore(TileGenerator tileGenerator) { if (mPool.size() < mMaxSize && mPool.offer(tileGenerator)) { return; } // pool is too big or returning to pool failed, so just try to clean // up. tileGenerator.cleanUp(); }
public void finishDialog(String aReturn) { mInputs = null; mButtons = null; mDialog = null; mSelected = null; mPromptQueue.offer(aReturn); // poke the Gecko thread in case it's waiting for new events GeckoAppShell.sendEventToGecko(GeckoEvent.createNoOpEvent()); }
@TaskAction public void doTask() throws ParserConfigurationException, SAXException, IOException, InterruptedException { File out = new File(getAssetsDir(), "objects"); out.mkdirs(); AssetIndex index = getIndex(); for (Entry<String, AssetEntry> e : index.objects.entrySet()) { Asset asset = new Asset(e.getValue().hash, e.getValue().size); File file = new File(out, asset.path); // exists but not the right size?? delete if (file.exists() && file.length() != asset.size) file.delete(); // does the file exist (still) ?? if (!file.exists()) filesLeft.offer(asset); } getLogger().info("Finished parsing JSON"); int max = filesLeft.size(); getLogger().info("Files Missing: " + max + "/" + index.objects.size()); // get number of threads int threadNum = max / 100; if (threadNum == 0 && max > 0) threadNum++; // atleats 1 thread // spawn threads for (int i = 0; i < threadNum; i++) spawnThread(); getLogger().info("Threads initially spawned: " + threadNum); while (stillRunning()) { int done = max - filesLeft.size(); getLogger() .lifecycle( "Current status: " + done + "/" + max + " " + (int) ((double) done / max * 100) + "%"); spawnThread(); Thread.sleep(1000); } if (errored) { // CRASH! getLogger().error("Something went wrong with the assets downloading!"); this.setDidWork(false); return; } }
public void markMessageAsRead(Message message) { if (unreadMessageHandler == null) { Log.e("zulipApp", "markMessageAsRead called before unreadMessageHandler was instantiated"); return; } unreadMessageQueue.offer(message.getID()); if (!unreadMessageHandler.hasMessages(0)) { unreadMessageHandler.sendEmptyMessageDelayed(0, 2000); } }
/** Broadcast an operation to all nodes. */ public CountDownLatch broadcastOperation(final BroadcastOpFactory of) { final CountDownLatch latch = new CountDownLatch(locator.getAll().size()); for (MemcachedNode node : locator.getAll()) { Operation op = of.newOp(node, latch); op.initialize(); node.addOp(op); addedQueue.offer(node); } Selector s = selector.wakeup(); assert s == selector : "Wakeup returned the wrong selector."; return latch; }
/** {@inheritDoc} */ @Override public void receive(final Message message) { final String msg = (String) message.getObject(); if (message.getSrc() != jchannel.getLocalAddress()) { if (msg != null) { receivedMessages.offer(msg); if (bc != null) { bc.broadcast(msg); } } } }
public void addOperations(final Map<MemcachedNode, Operation> ops) { for (Map.Entry<MemcachedNode, Operation> me : ops.entrySet()) { final MemcachedNode node = me.getKey(); Operation o = me.getValue(); o.initialize(); node.addOp(o); addedQueue.offer(node); } Selector s = selector.wakeup(); assert s == selector : "Wakeup returned the wrong selector."; }
/** {@inheritDoc} */ @Override public <T> Future<T> broadcastOnResume(T msg) { if (destroyed.get()) throw new IllegalStateException("This Broadcaster has been destroyed and cannot be used"); start(); Object newMsg = filter(msg); if (newMsg == null) return null; BroadcasterFuture<Object> f = new BroadcasterFuture<Object>(newMsg); broadcastOnResume.offer(new Entry(newMsg, null, f, msg)); return f; }
/** {@inheritDoc} */ public <T> Future<T> delayBroadcast(final T o, long delay, TimeUnit t) { if (destroyed.get()) throw new IllegalStateException("This Broadcaster has been destroyed and cannot be used"); start(); final Object msg = filter(o); if (msg == null) return null; final BroadcasterFuture<Object> future = new BroadcasterFuture<Object>(msg); final Entry e = new Entry(msg, null, future, o); Future<T> f; if (delay > 0) { f = bc.getScheduledExecutorService() .schedule( new Callable<T>() { public T call() throws Exception { delayedBroadcast.remove(e); if (Callable.class.isAssignableFrom(o.getClass())) { try { Object r = Callable.class.cast(o).call(); final Object msg = filter(r); if (msg != null) { Entry entry = new Entry(msg, null, null, r); push(entry); } return (T) msg; } catch (Exception e1) { logger.error("", e); } } final Object msg = filter(o); final Entry e = new Entry(msg, null, null, o); push(e); return (T) msg; } }, delay, t); e.future = new BroadcasterFuture<Object>(f, msg); } delayedBroadcast.offer(e); return future; }
/** * return the instance to the manager after use * * @param buf */ public void release(T buf) { if (_releaseQueueSize.get() > 8000) { log.info("release queue full"); synchronized (MemoryManager.this) { MemoryManager.this.notifyAll(); } return; } if (buf != null) { _releaseQueue.offer(buf); _releaseQueueSize.incrementAndGet(); synchronized (MemoryManager.this) { MemoryManager.this.notifyAll(); } } }
public boolean process(Socket socket) { Http11Processor processor = recycledProcessors.poll(); try { if (processor == null) { processor = createProcessor(); } if (processor instanceof ActionHook) { ((ActionHook) processor).action(ActionCode.ACTION_START, null); } if (proto.isSSLEnabled() && (proto.sslImplementation != null)) { processor.setSSLSupport(proto.sslImplementation.getSSLSupport(socket)); } else { processor.setSSLSupport(null); } processor.process(socket); return false; } catch (java.net.SocketException e) { // SocketExceptions are normal Http11Protocol.log.debug(sm.getString("http11protocol.proto.socketexception.debug"), e); } catch (java.io.IOException e) { // IOExceptions are normal Http11Protocol.log.debug(sm.getString("http11protocol.proto.ioexception.debug"), e); } // Future developers: if you discover any other // rare-but-nonfatal exceptions, catch them here, and log as // above. catch (Throwable e) { // any other exception or error is odd. Here we log it // with "ERROR" level, so it will show up even on // less-than-verbose logs. Http11Protocol.log.error(sm.getString("http11protocol.proto.error"), e); } finally { // if(proto.adapter != null) proto.adapter.recycle(); // processor.recycle(); if (processor instanceof ActionHook) { ((ActionHook) processor).action(ActionCode.ACTION_STOP, null); } recycledProcessors.offer(processor); } return false; }
synchronized void send(JSONStreamAware response) { if (asyncContext == null) { if (isInactive) { // user not seen recently, no responses should be collected return; } if (pendingResponses.size() > 1000) { pendingResponses.clear(); // stop collecting responses for this user isInactive = true; if (secretPhrase == null) { // but only completely remove users that don't have unlocked accounts Users.remove(this); } return; } pendingResponses.offer(response); } else { JSONArray responses = new JSONArray(); JSONStreamAware pendingResponse; while ((pendingResponse = pendingResponses.poll()) != null) { responses.add(pendingResponse); } responses.add(response); JSONObject combinedResponse = new JSONObject(); combinedResponse.put("responses", responses); asyncContext.getResponse().setContentType("text/plain; charset=UTF-8"); try (Writer writer = asyncContext.getResponse().getWriter()) { combinedResponse.writeJSONString(writer); } catch (IOException e) { Logger.logMessage("Error sending response to user", e); } asyncContext.complete(); asyncContext = null; } }
/** Send any pending topics. */ private void sendPending() { while (outstanding.get() < concurrency) { final TopicQueue queue = pendingTopics.poll(); if (queue == null) { return; } queue.pending = false; final int sent = queue.sendBatch(); // Did we send a whole batch? Then there might be more messages in the queue. Mark as pending // again. if (sent == batchSize) { queue.pending = true; pendingTopics.offer(queue); } } }
private void processCameraData( final byte[] cameraData, final int imageWidth, final int imageHeight) { cameraPreviewCallbackQueue.clear(); boolean offerSuccess = cameraPreviewCallbackQueue.offer( new Runnable() { @Override public void run() { long start = System.nanoTime(); // Convert data to JPEG and compress YuvImage image = new YuvImage(cameraData, ImageFormat.NV21, imageWidth, imageHeight, null); ByteArrayOutputStream out = new ByteArrayOutputStream(); Rect area = new Rect(0, 0, imageWidth, imageHeight); image.compressToJpeg(area, IMAGE_QUALITY, out); byte[] jpegVideoFrameData = out.toByteArray(); // rotate image byte[] rotatedCameraData = rotateImage(jpegVideoFrameData, imageWidth, imageHeight, currentCameraId); if (rotatedCameraData.length == 0) { return; } // send data to the opponent // cameraDataListener.onCameraDataReceive(rotatedCameraData); // // // close stream try { out.close(); } catch (IOException e) { e.printStackTrace(); } } }); }
// Handle IO for a specific selector. Any IOException will cause a // reconnect private void handleIO(SelectionKey sk) { MemcachedNode qa = (MemcachedNode) sk.attachment(); try { getLogger() .debug( "Handling IO for: %s (r=%s, w=%s, c=%s, op=%s)", sk, sk.isReadable(), sk.isWritable(), sk.isConnectable(), sk.attachment()); if (sk.isConnectable()) { getLogger().info("Connection state changed for %s", sk); final SocketChannel channel = qa.getChannel(); if (channel.finishConnect()) { assert channel.isConnected() : "Not connected."; qa.connected(); addedQueue.offer(qa); if (qa.getWbuf().hasRemaining()) { handleWrites(sk, qa); } } else { assert !channel.isConnected() : "connected"; } } else { if (sk.isReadable()) { handleReads(sk, qa); } if (sk.isWritable()) { handleWrites(sk, qa); } } } catch (Exception e) { // Various errors occur on Linux that wind up here. However, any // particular error processing an item should simply cause us to // reconnect to the server. getLogger().info("Reconnecting due to exception on %s", qa, e); queueReconnect(qa); } qa.fixupOps(); }
public static int processNotification(String queueArn, String remoteAddress) { int messageCount = 0; long ts1 = System.currentTimeMillis(); CMBControllerServlet.valueAccumulator.initializeAllCounters(); contextQueues.putIfAbsent(queueArn, new ConcurrentLinkedQueue<AsyncContext>()); ConcurrentLinkedQueue<AsyncContext> contextQueue = contextQueues.get(queueArn); AsyncContext asyncContext = contextQueue.poll(); if (asyncContext == null) { logger.debug( "event=no_pending_receive queue_arn=" + queueArn + " remote_address=" + remoteAddress); return messageCount; } if (asyncContext.getRequest() == null) { logger.info( "event=skipping_invalid_context queue_arn=" + queueArn + " remote_address=" + remoteAddress); return messageCount; } if (!(asyncContext.getRequest() instanceof CQSHttpServletRequest)) { logger.info( "event=skipping_invalid_request queue_arn=" + queueArn + " remote_address=" + remoteAddress); return messageCount; } CQSHttpServletRequest request = (CQSHttpServletRequest) asyncContext.getRequest(); // skip if request is already finished or outdated if (!request.isActive() || System.currentTimeMillis() - request.getRequestReceivedTimestamp() > request.getWaitTime()) { logger.info( "event=skipping_outdated_context queue_arn=" + queueArn + " remote_address=" + remoteAddress); return messageCount; } logger.debug( "event=notification_received queue_arn=" + queueArn + " remote_address=" + remoteAddress); try { CQSQueue queue = request.getQueue(); List<CQSMessage> messageList = PersistenceFactory.getCQSMessagePersistence() .receiveMessage(queue, request.getReceiveAttributes()); if (messageList.size() > 0) { messageCount = messageList.size(); List<String> receiptHandles = new ArrayList<String>(); for (CQSMessage message : messageList) { receiptHandles.add(message.getReceiptHandle()); } request.setReceiptHandles(receiptHandles); request.setAttribute("lp", "yy"); // found lp call with messages CQSMonitor.getInstance() .addNumberOfMessagesReturned(queue.getRelativeUrl(), messageList.size()); String out = CQSMessagePopulator.getReceiveMessageResponseAfterSerializing( messageList, request.getFilterAttributes(), request.getFilterMessageAttributes()); Action.writeResponse(out, (HttpServletResponse) asyncContext.getResponse()); long lp_ms = System.currentTimeMillis() - ts1; request.setAttribute("lp_ms", lp_ms); String cass_msString = String.valueOf( CQSControllerServlet.valueAccumulator.getCounter(AccumulatorName.CassandraTime)); request.setAttribute("cass_ms", cass_msString); request.setAttribute( "cass_num_rd", CQSControllerServlet.valueAccumulator.getCounter(AccumulatorName.CassandraRead)); request.setAttribute( "cass_num_wr", CQSControllerServlet.valueAccumulator.getCounter(AccumulatorName.CassandraWrite)); request.setAttribute( "redis_ms", CQSControllerServlet.valueAccumulator.getCounter(AccumulatorName.RedisTime)); request.setAttribute( "io_ms", CQSControllerServlet.valueAccumulator.getCounter(AccumulatorName.IOTime)); asyncContext.complete(); } else { // if there's longpoll time left, put back on queue if (request.getWaitTime() - System.currentTimeMillis() + request.getRequestReceivedTimestamp() > 0) { logger.info( "event=no_messages_found_for_longpoll_receive action=re_queueing time_left_ms=" + (request.getWaitTime() - System.currentTimeMillis() + request.getRequestReceivedTimestamp()) + " queue_arn=" + queueArn + " remote_address=" + remoteAddress); contextQueue.offer(asyncContext); } } } catch (Exception ex) { logger.error("event=longpoll_queue_error queue_arn=" + queueArn, ex); } finally { CMBControllerServlet.valueAccumulator.deleteAllCounters(); } return messageCount; }
/** 生产 */ public static void offer() { for (int i = 0; i < 100000; i++) { queue.offer(i); } }
void enqueue(JSONStreamAware response) { pendingResponses.offer(response); }
/** * Sends a message to the target worker function. This method returns immediately as message * processing is asynchronous. * * @param message the message of any type. * @return the same port object. */ public Port send(Object message) { queue.offer(message); scheduleNext(); return this; }