Java Doc for ClockDaemon.java in  » Ajax » Laszlo-4.0.10 » EDU » oswego » cs » dl » util » concurrent » Java Source Code / Java DocumentationJava Source Code and Java Documentation

All commands are executed by the single background thread. The thread is not actually started until the first request is encountered. Also, if the thread is stopped for any reason, one is started upon encountering the next request, or restart() is invoked.

If you would instead like commands run in their own threads, you can use as arguments Runnable commands that start their own threads (or perhaps wrap within ThreadedExecutors).

You can also use multiple daemon objects, each using a different background thread. However, one of the reasons for using a time daemon is to pool together processing of infrequent tasks using a single background thread.

Background threads are created using a ThreadFactory. The default factory does not automatically setDaemon status.

The class uses Java timed waits for scheduling. These can vary in precision across platforms, and provide no real-time guarantees about meeting deadlines.

[ Introduction to this package. ]

Sample Usage. You can use a ClockDaemon to arrange timeout callbacks to break out of stuck IO.

Sample Usage.

Sample Usage. You can use a ClockDaemon to arrange timeout callbacks to break out of stuck IO. For example (code sketch):

 class X {   ...
 ClockDaemon timer = ...
 Thread readerThread;
 FileInputStream datafile;
 void startReadThread() {
 datafile = new FileInputStream("data", ...);
 readerThread = new Thread(new Runnable() {
 public void run() {
 for(;;) {
 // try to gracefully exit before blocking
 if (Thread.currentThread().isInterrupted()) {
 quietlyWrapUpAndReturn();
 }
 else {
 try {
 int c = datafile.read();
 if (c == -1) break;
 else process(c);
 }
 catch (IOException ex) {
 cleanup();
 return;
 }
 }
 } };
 readerThread.start();
 // establish callback to cancel after 60 seconds
 timer.executeAfterDelay(60000, new Runnable() {
 readerThread.interrupt();    // try to interrupt thread
 datafile.close(); // force thread to lose its input file 
 });
 } 
 }
 

Sample Usage. Here is one way to update Swing components acting as progress indicators for long-running actions.

 class X {
 JLabel statusLabel = ...;
 int percentComplete = 0;
 synchronized int  getPercentComplete() { return percentComplete; }
 synchronized void setPercentComplete(int p) { percentComplete = p; }
 ClockDaemon cd = ...;
 void startWorking() {
 Runnable showPct = new Runnable() {
 public void run() {
 SwingUtilities.invokeLater(new Runnable() {
 public void run() {
 statusLabel.setText(getPercentComplete() + "%");
 } 
 } 
 } 
 };
 final Object updater = cd.executePeriodically(500, showPct, true);
 Runnable action = new Runnable() {
 public void run() {
 for (int i = 0; i < 100; ++i) {
 work();
 setPercentComplete(i);
 }
 cd.cancel(updater);
 }
 };
 new Thread(action).start();
 }
 }