termination.java

ALGAE是一个快速创建算法演示的框架。目前支持的算法实现语言包括java和c

package edu.odu.cs.zeil.AlgAE;

import edu.odu.cs.zeil.AlgAE.Debug;
import edu.odu.cs.zeil.AlgAE.TerminationAction;

import java.awt.Window;

import java.applet.Applet;

import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;

import java.lang.Thread;

import java.util.Vector;




/**
 *  AlgAE central control for termination-time controls
 *
 *  This class provides a singleton control center for all actions
 *  that must take place at program shutdown, regardless of whether
 *  the program is a standalone application or an applet.
 *
 *  Other portions of the program can register actions to be performed
 *  at program termination, including closing files and terminating threads.
 *  
 *  @author Steven J Zeil
 **/
public class Termination
{

  Vector actions;
  Vector threadActions;
  private Applet applet;


  class Killer extends Thread
  {
    public Killer() {}

    public void run()
    {
      synchronized (actions)
	{
	  try {
	    actions.wait();
	  }
	  catch (InterruptedException e) {}
	}
      for (int i = 0; i < threadActions.size(); ++i)
	{
	  TerminationAction action
	    = (TerminationAction)threadActions.elementAt(i);
	  action.stopping();
	}
      for (int i = 0; i < actions.size(); ++i)
	{
	  TerminationAction action = (TerminationAction)actions.elementAt(i);
	  action.stopping();
	}
      if (applet == null)
	System.exit (0);
    }
  }
  

class WindowCloser implements TerminationAction
{
  private Window w;
  WindowCloser (Window win)  {w = win;}
  
  public void stopping()
  {
    Debug.show (Debug.termination, "Termination: closing window " + w);
    try {
      w.setVisible(false);
    }
    catch (Throwable e) {}
    try {
      w.dispose();
    }
    catch (Throwable e) {}
  }
}


class InputStreamCloser implements TerminationAction
{
  private InputStream v;
  InputStreamCloser (InputStream x)  {v = x;}
  
  public void stopping()
  { 
    Debug.show (Debug.termination, "Termination: closing input stream " + v);
    try {
      v.close();
    }
    catch (Throwable e) {}
  }
}

class ReaderCloser implements TerminationAction
{
  private Reader v;
  ReaderCloser (Reader x)  {v = x;}
  
  public void stopping()
  {
    Debug.show (Debug.termination, "Termination: closing reader " + v);
    try {
      v.close();
    }
    catch (Throwable e) {}
  }
}

class OutputStreamCloser implements TerminationAction
{
  private OutputStream v;
  OutputStreamCloser (OutputStream x)  {v = x;}
  
  public void stopping()
  {
    Debug.show (Debug.termination, "Termination: closing output stream " + v);
    try {
      v.flush();
    }
    catch (Throwable e) {}
    try {
      v.close();
    }
    catch (Throwable e) {}
  }
}


class WriterCloser implements TerminationAction
{
  private Writer v;
  WriterCloser (Writer x)  {v = x;}
  
  public void stopping()
  {
    Debug.show (Debug.termination, "Termination: closing writer " + v);
    try {
      v.flush();
    }
    catch (Throwable e) {}
    try {
      v.close();
    }
    catch (Throwable e) {}
  }
}

class ThreadKiller implements TerminationAction
{
  private Thread v;
 
  ThreadKiller (Thread x)
  {
    v = x; 
    Debug.show (Debug.termination, "Registering thread " + v.getName());
  }
  
  public void stopping()
  {
    if (v != Thread.currentThread())
      {
	try {
	  Debug.show (Debug.termination, "Stopping thread " + v.getName());
	  v.stop();
	  }
	catch (SecurityException e) {}
	catch (Throwable e) {}
      }
  }
}
  
class ThreadGroupKiller implements TerminationAction
{
  private ThreadGroup v;

  ThreadGroupKiller (ThreadGroup x)  {v = x;}
  
  public void stopping()
  {
    Debug.show (Debug.termination, "Stopping thread group" + v);
    try {
      v.stop();
    }
    catch (SecurityException e) {}
    catch (Throwable e) {}
  }
}

  private Killer killer;
  
  public Termination()
  {
    actions = new Vector();
    threadActions = new Vector();
    applet = null;
    killer = new Killer();
    killer.start();
  }
  

  public boolean isAnApplet ()
  {
    return applet != null;
  }



  public void exit (int code)
  {
    synchronized (actions)
      {
	actions.notify();
      }
    
    if (applet == null)
      {
	synchronized (threadActions) {
	  try {
	    threadActions.wait(30*1000);
	  }
	  catch (InterruptedException e) {}
	}
	System.exit (code);
      }
  }

  public void register (TerminationAction action)
  {
    actions.addElement (action);
  }


  private void registerThread (TerminationAction action)
  {
    threadActions.addElement (action);
  }


  public void register (Applet appl)
  {
    applet = appl;
  }


  
  public void register (java.awt.Window window)
  {
    register (new WindowCloser (window));
  }
  

  public void register (java.io.InputStream v)
  {
    register (new InputStreamCloser (v));
  }
  

  public void register (java.io.Reader v)
  {
    register (new ReaderCloser (v));
  }
  

  public void register (java.io.OutputStream v)
  {
    register (new OutputStreamCloser (v));
  }
  

  public void register (java.io.Writer v)
  {
    register (new WriterCloser (v));
  }
  
  public void register (java.lang.Thread v)
  {
    if (applet != null)
      registerThread (new ThreadKiller (v));
  }

  public void register (java.lang.ThreadGroup v)
  {
//    if (applet != null)
      registerThread (new ThreadGroupKiller (v));
  }
  

  
}