home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgLangD.iso / VCAFE.3.0A / Sample.bin / Analyzer.java < prev    next >
Text File  |  1998-11-05  |  3KB  |  104 lines
  1. // Copyright (c) 1997, 1998 Symantec, Inc. All Rights Reserved.
  2.  
  3. /*
  4. This is thread analyzes the log file while the AnalyzeDialog is up.
  5. It also provides the mechanism for safe thread cancelling. 
  6. Note: It is usually not safe to call the Thread.stop() method, as
  7. randomly stopping execution in a thread may leave "damaged" objects
  8. (objects in an inconsistent state).
  9. */
  10. class Analyzer extends Thread {
  11.     TrackProgress trackProgress;
  12.     boolean bCancelled = false;
  13.  
  14.     // Constructs an Analyzer.
  15.     public Analyzer(TrackProgress trackProgress) {
  16.         this.trackProgress = trackProgress;
  17.             //{{INIT_CONTROLS
  18.         //}}
  19. }
  20.  
  21.     // This is Thread's standard run method.
  22.     public void run() {
  23.         Report report = Data.getDataInstance().getCurrentReport();
  24.         report.run(trackProgress);
  25.     }
  26.  
  27.     /* Use this method to cancel an Analyzer thread.
  28.     It flags the thread as cancelled, then waits
  29.     awhile for it to die.
  30.     Returns true if the thread was/is stopped.
  31.     */
  32.     public static boolean cancel(Analyzer analyzer) {
  33.         // return if nothing to do
  34.         if(analyzer == null || !analyzer.isAlive()) {
  35.             return true;
  36.         }
  37.         // cancel the thread
  38.         analyzer.setCancelled();
  39.         // put out message
  40.         analyzer.trackProgress.step("CANCELLING", 0);
  41.         // wait up to 10 seconds for cancel success
  42.         int count = 100;
  43.         while(analyzer.isAlive() && --count >= 0) {
  44.             try {
  45.                 analyzer.join(100);
  46.             } catch(InterruptedException x) {
  47.             }
  48.         }
  49.         return !analyzer.isAlive();
  50.     }
  51.     
  52.     /* This method is used in the run() code to see whether the
  53.     thread should stop running. If so, an exception is thrown.
  54.     */
  55.     public static void throwExceptionIfCurrentThreadCancelled() throws ParseLogException {
  56.         boolean threadIsCancelled;
  57.         Thread t = currentThread();
  58.         if(t instanceof Analyzer) {
  59.             threadIsCancelled = ((Analyzer)t).isCancelled();
  60.         } else {
  61.             // fake it. this bit of code not actually used in this app
  62.             threadIsCancelled = t.isInterrupted();
  63.         }
  64.         // throw exception if cancelled
  65.         if(threadIsCancelled) {
  66.             throw new ParseLogException("CANCELLED", null);
  67.         }
  68.     }
  69.  
  70.     /* Flag this thread as cancelled and interrupt it in case it's blocked
  71.     (waiting on IO, etc).
  72.     */
  73.     private void setCancelled() {
  74.         // if already cancelled, do nothing
  75.         if(bCancelled) {
  76.             return;
  77.         }
  78.         // set cancelled flag
  79.         synchronized(this) { 
  80.             bCancelled = true; 
  81.         }
  82.         // interrupt this thread
  83.         interrupt();
  84.     }
  85.     
  86.     /* Determine if "setCancel" has been called for this thread.
  87.     */
  88.     private boolean isCancelled() {
  89.         // once set never cleared, so no need to sync here
  90.         if(bCancelled) {
  91.             return true;
  92.         }
  93.         // sync here, though
  94.         synchronized(this) { 
  95.             return bCancelled; 
  96.         }
  97.     }
  98.     //{{DECLARE_CONTROLS
  99.     //}}
  100. }
  101.  
  102.  
  103.  
  104.