/** * This method is the main function of the thread of the collective. It does housekeeping and * regularly talks to peers to exchange information. It can be stopped by calling <code>close() * </code>. * * @see #close() */ public final void run() { while (shouldLive) { // try{ System.gc(); removeOldStuff(); if (!refresh()) { Address[] a = observer.getPeerAddresses(); if (a != null) synchronized (cache) { for (int i = 0; i < a.length; ++i) cache.put(a[i].name, new ContributionBox(a[i], null)); } } for (int i = 0; i < REFRESHRATE; i += 1000) { try { Thread.sleep(1000); } catch (InterruptedException e) { shouldLive = false; } if (shouldLive == false) break; Thread.yield(); } /*} catch( RuntimeException e ) { Logger.error( "Collective#run()", "Runtime exception caught, something is going wrong",e); }*/ } cache = null; observer = null; }
/** * The run method for the thread that retrieves the data from the database. This method should not * be called directly. Instead use the retrieve method. */ public void run() { try { DataStoreRow row = new DataStoreRow(this, new DSDataRow(_desc), _desc); while (_dataSource.retrieveRow(this, row)) { _rows.addElement(row.getDSDataRow()); if (_threaded) notifyListeners(ModelChangedEvent.TYPE_ROW_INSERTED_OR_DELETED); if (!_retrieveInProgress || (_maxRows > -1 && _rows.size() >= _maxRows)) { _cancelInProgress = true; _retrieveInProgress = false; interruptWaitingRetrieveThreads(); break; } if (_threaded) Thread.yield(); row.setDSDataRow(new DSDataRow(_desc)); } _dataSource.postRetrieve(this); _cancelInProgress = false; interruptWaitingCancelThreads(); notifyListeners(ModelChangedEvent.TYPE_DATA_LOADED); } catch (Exception e) { System.out.println("DataStore.run:" + e); _cancelInProgress = false; interruptWaitingCancelThreads(); } _retrieveInProgress = false; interruptWaitingRetrieveThreads(); _cancelInProgress = false; interruptWaitingCancelThreads(); }
public static void spinAssertEquals(Object expected, Supplier<Object> s, int timeoutInSeconds) { long now = System.currentTimeMillis(); while (System.currentTimeMillis() - now < now + (1000 * timeoutInSeconds)) { if (s.get().equals(expected)) break; Thread.yield(); } assertEquals(expected, s.get()); }
@Test public void canEcho() throws Exception { server.start(); Thread.yield(); Socket s = new Socket("localhost", port); OutputStream os = s.getOutputStream(); os.write("echo\n".getBytes()); String response = new BufferedReader(new InputStreamReader(s.getInputStream())).readLine(); assertEquals("echo", response); }
public void run() { boolean eof = false; JavaCharStream stream = new JavaCharStream(in, 1, 1); exec("_ps1 = sys.ps1"); PyObject ps1Obj = get("_ps1"); String ps1 = ps1Obj.toString(); exec("_ps2 = sys.ps2"); PyObject ps2Obj = get("_ps2"); String ps2 = ps2Obj.toString(); out.print(getDefaultBanner() + "\n"); out.print(ps1); String line = ""; while (!eof) { // try to sync up the console System.out.flush(); System.err.flush(); Thread.yield(); // this helps a little try { boolean eol = false; line = ""; while (!eol) { char aChar = stream.readChar(); eol = (aChar == '\n'); if (!eol) line = line + aChar; } // hitting Enter at prompt returns a semicolon // get rid of it since it returns an error when executed if (line.equals(";")) line = ""; { boolean retVal = push(line); if (retVal) { out.print(ps2); } else { out.print(ps1); } } } catch (IOException ex) { } } }
public static boolean kill() { int j = 0; Thread meMySelfI = Thread.currentThread(); do { /* iter across the thread group, killing all members. */ shutdown = true; Thread list[] = new Thread[tg.activeCount()]; // get all members of the group (including submembers) int i = tg.enumerate(list); // no members means that we have gracefully suceeded if (i == 0) return true; // if some of the threads do IO during the shut down they will // need time to accomplish the IO. So, I give it to 'em // after the first attempt. if (j > 0) try { meMySelfI.sleep(500); } catch (Exception e) { } ; // try to shudown each thread in the group while (i-- > 0) { FlickrFtpd tftp = (FlickrFtpd) list[i]; tftp.interrupt(); // first, do it politely meMySelfI.yield(); // give 'em time to respond tftp.forceClose(); // second, use a big hammer meMySelfI.yield(); // give 'em time to respond } } while (j++ <= 3); return false; }
@Test public void multipleEchos() throws Exception { server.start(); Thread.yield(); Socket s1 = new Socket("localhost", port); Socket s2 = new Socket("localhost", port); s1.getOutputStream().write("echo1\n".getBytes()); s2.getOutputStream().write("echo2\n".getBytes()); String response1 = new BufferedReader(new InputStreamReader(s1.getInputStream())).readLine(); String response2 = new BufferedReader(new InputStreamReader(s2.getInputStream())).readLine(); assertEquals("echo1", response1); assertEquals("echo2", response2); }
/** * Returns the current file cache. * * @param root root directory * @return id, or {@code null} if newer file cache exists * @throws InterruptedException interruption */ ProjectCache cache(final IOFile root) throws InterruptedException { final ProjectCache pc = cache; if (pc == null) { // no file cache available: create and return new one cache = new ProjectCache(); add(root, cache); cache.finish(); } else { // wait until file cache is initialized while (!pc.valid()) { Thread.yield(); // file cache was replaced with newer version if (pc != cache) throw new InterruptedException(); } } // return existing file cache return cache; }
static void doIt(String toParse, BufferedWriter fw, SimpleNode optNode) throws Exception { long[] testArray = new long[10]; double d = 0; DoubleStack stack = new DoubleStack(); for (int j = 0; j < 10; j++) { Thread.yield(); long start = System.currentTimeMillis(); for (int i = 0; i < 100000; i++) { d = optNode.getValue(); } testArray[j] = System.currentTimeMillis() - start; } fw.write("100000 evaluations: "); for (int j = 0; j < 10; j++) { fw.write(testArray[j] + ", "); } fw.write("\n"); }
protected BTGPSLocationProvider() throws LocationException { // TODO: Move this to searchConnect method? // TODO: The problem here is that it searches every time. Slow. Need to try Properties? // TODO: BIG ONE: Should only connect to GPS that isPaired() (from menu). Will // allow some degree of control over which GPS is connects to in classroom. try { da = LocalDevice.getLocalDevice().getDiscoveryAgent(); da.startInquiry(DiscoveryAgent.GIAC, this); } catch (BluetoothStateException e) { throw new LocationException(e.getMessage()); } while (!doneInq) { Thread.yield(); } if (btDevice == null) throw new LocationException("No device found"); String address = btDevice.getBluetoothAddress(); String btaddy = "btspp://" + address; try { StreamConnectionNotifier scn = (StreamConnectionNotifier) Connector.open(btaddy); if (scn == null) throw new LocationException("Bad BT address"); StreamConnection c = scn.acceptAndOpen(); /* This problem below occurred one time for my Holux GPS. The solution was to * remove the device from the Bluetooth menu, then find and pair again. */ if (c == null) throw new LocationException("Failed. Try pairing at menu again"); InputStream in = c.openInputStream(); if (in != null) { gps = new SimpleGPS(in); // c.close(); // TODO: Clean up when done. HOW TO HANDLE IN LOCATION? } } catch (IOException e) { throw new LocationException(e.getMessage()); } // Add itself to SimpleGPS as listener SimpleGPS.addListener(this); }
/** * This one checks that the stats message was received. If not, the message is sent again up to * five times. Run time an best individual of run are logged. */ public void finalStatistics(final EvolutionState state, final int result) { super.finalStatistics(state, result); EvolutionAgent agent = (EvolutionAgent) state; StatisticsData data = new StatisticsData( new Address(agent.getName()), state.generation, System.currentTimeMillis() - creationtime, getBestIndividual(state), getBestIndividual(state)); if (agent.iamroot) // Local logging printStatistics(state, data); // Every statistic will go there else { // DRM logging for (int i = 0; i < 5; i++) { // Try to send final data 5 times IRequest request = agent.fireMessage(agent.getRootAddress(), EvolutionAgent.M_STATS, data); while (request.getStatus() == IRequest.WAITING) { Thread.yield(); // try{Thread.sleep(1000);} // catch(Exception e){state.output.error("Exception: " + e);} } if (request.getStatus() == IRequest.DONE) { break; } else { state.output.error("There was an error sending final statistics."); try { Thread.sleep(1000 * i ^ 2); } catch (Exception e) { state.output.error("Exception: " + e); } } } } }
public void run() { if (cnt == 0) { // Give precedence to the Thread that is creating the BackEnd Thread.yield(); // In the meanwhile load the ConnectionListener if any try { myConnectionListener = (ConnectionListener) Class.forName(props.getProperty("connection-listener")).newInstance(); } catch (Exception e) { // Just ignore it } } myId = cnt++; myLogger.log(Logger.INFO, "IM-" + myId + " started"); // Prepare an initial dummy response JICPPacket rsp = new JICPPacket(JICPProtocol.RESPONSE_TYPE, JICPProtocol.DEFAULT_INFO, null); while (active) { try { // Prepare the connection for next incoming command refreshConnection(); myDisconnectionManager.waitUntilReachable(); // Deliver the response to the previous incoming command and wait for the next one // If we are delivering the response to an exit command, set active to false to avoid an // annoying stack trace // (due to the fact that the back-end will close the connection instead of sending further // commands) and exit if (this == terminator) { active = false; } JICPPacket cmd = deliver(rsp, myConnection); myKeepAliveManager.update(); if (cmd.getType() == JICPProtocol.KEEP_ALIVE_TYPE) { // Keep-alive if (myLogger.isLoggable(Logger.FINER)) { myLogger.log(Logger.FINER, "Keep-alive received"); } rsp = new JICPPacket(JICPProtocol.RESPONSE_TYPE, JICPProtocol.OK_INFO, null); } else { // Command byte sid = cmd.getSessionID(); if (sid == lastSid) { myLogger.log(Logger.WARNING, "Duplicated command received " + sid); rsp = lastResponse; } else { myLogger.log(Logger.FINE, "Incoming command received " + sid); byte[] rspData = mySkel.handleCommand(cmd.getData()); myLogger.log(Logger.FINE, "Incoming command served " + sid); rsp = new JICPPacket(JICPProtocol.RESPONSE_TYPE, JICPProtocol.DEFAULT_INFO, rspData); rsp.setSessionID(sid); lastSid = sid; lastResponse = rsp; } } } catch (Exception e) { if (active) { myLogger.log(Logger.WARNING, "Exception on input connection", e); // Note that the boolean value passed to setUnreachable() only indicates if the // unreachability was detected by a missing keep-alive myDisconnectionManager.setUnreachable(false); } } } myLogger.log(Logger.INFO, "IM-" + myId + " terminated"); }
public static void main(String[] args) throws Exception { Date startTime = new Date(); parseParams(args); File inFile = new File((String) params.get("-file")); File logFile = new File((String) params.get("-logfile")); BufferedReader fr = new BufferedReader(new FileReader(inFile)); BufferedWriter fw = new BufferedWriter(new FileWriter(logFile)); jep.addStandardConstants(); jep.addStandardFunctions(); String curLine = null; int lines = 0; while (null != (curLine = fr.readLine())) { if (curLine.startsWith("#")) continue; String description = curLine; String toParse = fr.readLine(); double result = Double.parseDouble(fr.readLine().trim()); fw.write("Processing:" + toParse + ",\n"); fw.write("Expected: " + result + "\n"); fw.flush(); // Give enought time to the jit compiler. double d = 0; DoubleStack stack = new DoubleStack(); for (int i = 0; i < 1000; i++) { jep.parseExpression(toParse); d = jep.getValue(stack); } SimpleNode optNode = jep.getTopNode(); // if(Boolean.getBoolean("noopt")) { fw.write("Not Optimized: "); doIt(toParse, fw, optNode); // } // if(Boolean.getBoolean("opt")) { ExpressionOptimizer optimizer = new ExpressionOptimizer(jep.getTopNode()); // optimizer.addConst("pi"); // optimizer.addConst("e"); optNode = optimizer.optimize(); fw.write("Optimized : "); doIt(toParse, fw, optNode); long[] testArray = new long[10]; for (int j = 0; j < 10; j++) { Thread.yield(); long start = System.currentTimeMillis(); for (int i = 0; i < 1000; i++) { jep.parseExpression(toParse); } testArray[j] = System.currentTimeMillis() - start; } fw.write("1000 parses: "); for (int j = 0; j < 10; j++) { fw.write(testArray[j] + ", "); } fw.write("\n"); fw.write(d + "\n_____________________________________________________\n"); fw.flush(); // } } Date endTime = new Date(); fw.write("Start time: " + startTime + "\n"); fw.write("End time: " + endTime + "\n"); fw.write("Total time: " + (endTime.getTime() - startTime.getTime()) + " ms"); fw.close(); }
public void setLocationListener( LocationListener listener, int interval, int timeout, int maxAge) { // * Stop all previous listener threads * listenerRunning = false; if (listyThread != null) { while (listyThread.isAlive()) { Thread.yield(); } // End old thread listyThread = null; // Discard the listener thread instance } // * Remove any listeners from GPSListener * if (listener == null) { // Remove current listener from SimpleGPS SimpleGPS.removeListener(gpsl); gpsl = null; return; // No listener provided, so return now so it dosn't make a new one } // * Inner classes need final variables * final int to = timeout; final LocationListener l = listener; final LocationProvider lp = this; final int delay = interval * 1000; // Oddly interval is in seconds, and not float // Make new thread here and start it if interval > 0, else if -1 // then use the GPSListener interface. if (interval > 0) { // Notify according to interval by user listyThread = new Thread() { public void run() { while (listenerRunning) { try { // TODO: Probably only notify if location changed? Need to compare to old. // TODO: Make helper method since this is used below too. l.locationUpdated(lp, lp.getLocation(to)); Thread.sleep(delay); } catch (LocationException e) { // TODO Auto-generated catch block } catch (InterruptedException e) { // TODO Auto-generated catch block } } } }; listyThread.setDaemon(true); // so JVM exits if thread is still running listenerRunning = true; listyThread.start(); } else if (interval < 0) { // If interval is -1, use default update interval // In our case, update as soon as new coordinates are available from GPS (via GPSListener) // TODO: Alternate method: Use GPSListener for ProximityListener and this. gpsl = new GPSListener() { public void sentenceReceived(NMEASentence sen) { // Check if GGASentence. Means that new location info is ready if (sen.getHeader().equals(GGASentence.HEADER)) { try { // TODO: Probably only notify if location changed? Need to compare to old. l.locationUpdated(lp, lp.getLocation(to)); } catch (LocationException e) { // TODO Auto-generated catch block } catch (InterruptedException e) { // TODO Auto-generated catch block } } } }; SimpleGPS.addListener(gpsl); } // TODO: Need to implement LocationListener.providerStateChanged() }