@Override public void run() { try { boolean running = true; while (running) { try { // block on event availability ThreadBoundEvent event = queue.take(); // add to the batch, and see if we can add more batch.add(event); if (maxBatchSize > 0) { queue.drainTo(batch, maxBatchSize); } // check for the stop condition (and remove it) // treat batches of 1 (the most common case) specially if (batch.size() > 1) { ListIterator<ThreadBoundEvent> itr = batch.listIterator(); while (itr.hasNext()) { ThreadBoundEvent next = itr.next(); if (next.getClass().equals(ShutdownTask.class)) { running = false; ((ShutdownTask) next).latch.countDown(); itr.remove(); } } eventProcessor.process(batch); } else { // just the one event, no need to iterate if (event.getClass().equals(ShutdownTask.class)) { running = false; ((ShutdownTask) event).latch.countDown(); } else { eventProcessor.process(batch); } } } catch (InterruptedException e) { LOG.warn( String.format( "Consumer on queue %s interrupted.", Thread.currentThread().getName())); // ignore } catch (Throwable exception) { LOG.error( String.format( "exception on queue %s while executing events", Thread.currentThread().getName()), exception); } finally { // reset the batch batch.clear(); } } } catch (Throwable unexpectedThrowable) { // we observed some cases where trying to log the inner exception threw an error // don't use the logger here as that seems to be causing the problem in the first place System.err.println("Caught and unexpected Throwable while logging"); System.err.println( "This problem happens when jar files change at runtime, JVM might be UNSTABLE"); unexpectedThrowable.printStackTrace(System.err); } }
public void run() { try { for (; ; ) { final Pair<Handler, Message> entry = eventQueue.take(); final Handler handler = entry.left; final Message message = entry.right; try { // A message is either a command or an event. // A command returns a value that must be read by // the caller. if (message instanceof Command<?>) { Command<?> command = (Command<?>) message; try { Locus.push(command.getLocus()); Object result = command.call(); responseQueue.put(command, Pair.of(result, (Throwable) null)); } catch (PleaseShutdownException e) { responseQueue.put(command, Pair.of(null, (Throwable) null)); return; // exit event loop } catch (Throwable e) { responseQueue.put(command, Pair.of(null, e)); } finally { Locus.pop(command.getLocus()); } } else { Event event = (Event) message; event.acceptWithoutResponse(handler); // Broadcast the event to anyone who is interested. RolapUtil.MONITOR_LOGGER.debug(message); } } catch (Throwable e) { // REVIEW: Somewhere better to send it? e.printStackTrace(); } } } catch (InterruptedException e) { // REVIEW: Somewhere better to send it? e.printStackTrace(); } catch (Throwable e) { e.printStackTrace(); } }
public void start(String[] args) throws Exception { if (lineReader == null) { lineReader = new DefaultLineReader(); } running = true; while (running) { print("hazelcast[" + namespace + "] > "); try { final String command = lineReader.readLine(); handleCommand(command); } catch (Throwable e) { e.printStackTrace(); } } }
/** Submit exec into pool and throw exceptions */ public void execute() { String p = project.getProperty("number.of.threads"); if (p != null) { ((ThreadPoolExecutor) threadPool).setCorePoolSize(Integer.parseInt(p)); ((ThreadPoolExecutor) threadPool).setMaximumPoolSize(Integer.parseInt(p)); } TaskRunnable tr = new TaskRunnable(); threadPool.submit(tr); try { synchronized (semaphore) { while (!tr.isFinished()) semaphore.wait(); } } catch (InterruptedException e) { e.printStackTrace(); } Throwable t = tr.getException(); if (t != null) { if (t instanceof BuildException) throw (BuildException) t; else t.printStackTrace(); } }
public void _saveSettings() { // public for testing purposes if (mySaveSettingsIsInProgress.compareAndSet(false, true)) { try { doSave(); } catch (final Throwable ex) { if (isUnitTestMode()) { System.out.println("Saving application settings failed"); ex.printStackTrace(); } else { LOG.info("Saving application settings failed", ex); invokeLater( new Runnable() { public void run() { if (ex instanceof PluginException) { final PluginException pluginException = (PluginException) ex; PluginManager.disablePlugin(pluginException.getPluginId().getIdString()); Messages.showMessageDialog( "The plugin " + pluginException.getPluginId() + " failed to save settings and has been disabled. Please restart " + ApplicationNamesInfo.getInstance().getFullProductName(), CommonBundle.getErrorTitle(), Messages.getErrorIcon()); } else { Messages.showMessageDialog( ApplicationBundle.message( "application.save.settings.error", ex.getLocalizedMessage()), CommonBundle.getErrorTitle(), Messages.getErrorIcon()); } } }); } } finally { mySaveSettingsIsInProgress.set(false); } } }
static void unexpected(Throwable t) { failed++; t.printStackTrace(); }
public synchronized RPC<V> call() { // Any Completer will not be carried over to remote; add it to the RPC call // so completion is signaled after the remote comes back. CountedCompleter cc = _dt.getCompleter(); if (cc != null) handleCompleter(cc); // If running on self, just submit to queues & do locally if (_target == H2O.SELF) return handleLocal(); // Keep a global record, for awhile if (_target != null) _target.taskPut(_tasknum, this); try { if (_nack) return this; // Racing Nack rechecked under lock; no need to send retry // We could be racing timeouts-vs-replies. Blow off timeout if we have an answer. if (isDone()) { if (_target != null) _target.taskRemove(_tasknum); return this; } // Default strategy: (re)fire the packet and (re)start the timeout. We // "count" exactly 1 failure: just whether or not we shipped via TCP ever // once. After that we fearlessly (re)send UDP-sized packets until the // server replies. // Pack classloader/class & the instance data into the outgoing // AutoBuffer. If it fits in a single UDP packet, ship it. If not, // finish off the current AutoBuffer (which is now going TCP style), and // make a new UDP-sized packet. On a re-send of a TCP-sized hunk, just // send the basic UDP control packet. if (!_sentTcp) { while (true) { // Retry loop for broken TCP sends AutoBuffer ab = new AutoBuffer(_target, _dt.priority()); try { final boolean t; int offset = ab.position(); ab.putTask(UDP.udp.exec, _tasknum).put1(CLIENT_UDP_SEND); ab.put(_dt); t = ab.hasTCP(); assert sz_check(ab) : "Resend of " + _dt.getClass() + " changes size from " + _size + " to " + ab.size() + " for task#" + _tasknum; ab.close(); // Then close; send final byte _sentTcp = t; // Set after close (and any other possible fail) break; // Break out of retry loop } catch (AutoBuffer.AutoBufferException e) { Log.info( "IOException during RPC call: " + e._ioe.getMessage() + ", AB=" + ab + ", for task#" + _tasknum + ", waiting and retrying..."); ab.drainClose(); try { Thread.sleep(500); } catch (InterruptedException ignore) { } } } // end of while(true) } else { // Else it was sent via TCP in a prior attempt, and we've timed out. // This means the caller's ACK/answer probably got dropped and we need // him to resend it (or else the caller is still processing our // request). Send a UDP reminder - but with the CLIENT_TCP_SEND flag // instead of the UDP send, and no DTask (since it previously went via // TCP, no need to resend it). AutoBuffer ab = new AutoBuffer(_target, _dt.priority()).putTask(UDP.udp.exec, _tasknum); ab.put1(CLIENT_TCP_SEND).close(); } // Double retry until we exceed existing age. This is the time to delay // until we try again. Note that we come here immediately on creation, // so the first doubling happens before anybody does any waiting. Also // note the generous 5sec cap: ping at least every 5 sec. _retry += (_retry < MAX_TIMEOUT) ? _retry : MAX_TIMEOUT; // Put self on the "TBD" list of tasks awaiting Timeout. // So: dont really 'forget' but remember me in a little bit. // UDPTimeOutThread.PENDING.put(_tasknum, this); return this; } catch (Throwable t) { t.printStackTrace(); throw Log.throwErr(t); } }