How do I kill a ThreadGroup?!?!?!?

Question

I'm trying to build a very simple Multiprocess JVM class manager. I can start my processes (classes with main) but I am trying to catch the System.exit method calls with a SecurityManager. I'm getting the following error when I try to kill a ThreadGroup
AWT blocker activation interrupted:
java.lang.InterruptedException
at java.lang.Object.wait(Native Method)
at java.lang.Object.wait(Object.java:425)
at sun.awt.AWTAutoShutdown.activateBlockerThread(AWTAutoShutdown.java:312)
at sun.awt.AWTAutoShutdown.setToolkitBusy(AWTAutoShutdown.java:229)
at sun.awt.AWTAutoShutdown.notifyToolkitThreadBusy(AWTAutoShutdown.java:121)
at sun.awt.windows.WToolkit.eventLoop(Native Method)
at sun.awt.windows.WToolkit.run(WToolkit.java:222)
at java.lang.Thread.run(Thread.java:539)
The app I'm testing with is a simple Swing app with a JMenu. Listed below is the code I'm using as my sample Multiprocess manager.
// File Name: Sample2.java
import java.lang.reflect.*;
import java.awt.*;
import java.io.*;
import java.lang.Thread;
import java.util.*;
// very simple class to run code
public class Sample2 {
public static void main(String argv[]) {
ProcessMgr p = new ProcessMgr();
p.Run(argv);
// The security manager that will catch the System.exit calls
class ExitCatchingSecurityManager extends SecurityManager {
public void checkExit(int status) {
ThreadGroup tg = getThreadGroup();
Process.terminateProcessWithThreadGroup( tg );
System.out.println("Stopping ThreadGroup");
// this is the stmt that gets the error
tg.stop();
System.out.println("ThreadGroup stopped");
throw new SecurityException();
// The class that actually handles the Process Initiation and Termination
class Process implements Runnable {
String theClassName;
String[] theStartupArguments;
ThreadGroup mainThreadGroup;
Thread thisThread;
static ArrayList allProcesses = new ArrayList();
// terminate all processes associated with a particular ThreadGroup
public static void terminateProcessWithThreadGroup( ThreadGroup tg ) {
for (Iterator i = allProcesses.iterator() ; i.hasNext() ;) {
Process p = (Process) i.next();
if (p.getThreadGroup() == tg) {
System.out.println( "Terminating Thread" );
p.getThread().stop();
// pull out the ThreadGroup for this process
public ThreadGroup getThreadGroup() {
return mainThreadGroup;
// pull out the Thread for this process
public Thread getThread() {
return thisThread;
// Constructor
public Process( String classname, String[] args ) {
theClassName = classname;
theStartupArguments = args;
// Implement the run
public void run() {
try {
thisThread = Thread.currentThread();
mainThreadGroup = Thread.currentThread().getThreadGroup();
startAnotherClass( theClassName, theStartupArguments );
allProcesses.add( (Process) this );
} catch (Exception e) {
System.out.println("Could not start " + theClassName);
System.out.println(e);
// terminate this thread
public void terminate() {
if (thisThread != null)
thisThread.stop();
// Start a process in its own thread
public static Process startAnotherClassInItsOwnThread(String classname, String[] args) {
Process process = new Process( classname, args );
ThreadGroup threadgroup = new ThreadGroup("MPJVM");
Thread thread = new Thread( threadgroup, process );
thread.start();
return process;
// Here is the nuts and bolts of starting the class
public static void startAnotherClass( String className, String[] args ) throws Exception
// Get the class
Class classObject = Class.forName( className );
// Find the main(String[]) method of that class.
// main has one parameter, a string array. Set
// that argument type
Class[] mainParamType = { args.getClass() };
// Search for the main(String[]) method
Method main = classObject.getMethod("main", mainParamType);
// Create an object array of the arguments to pass
// to the method
Object[] mainParams = { args };
// start the real class
main.invoke( null, mainParams );
// The testing Application
class ProcessMgr {
public static void Run(String[] args) {
String s = "";
// Install the new Security Manager
System.setSecurityManager( new ExitCatchingSecurityManager( ) );
BufferedReader in = new BufferedReader( new InputStreamReader( System.in ) );
System.out.println("Enter class to run or exit to terminate");
try {
while ( s.compareTo("exit") != 0) {
s = in.readLine();
if ( s.compareTo("exit") != 0 ) {
Process.startAnotherClassInItsOwnThread( s, args );
System.out.println("Process Started");
System.out.println("Enter next class or exit to terminate");
} catch (Exception eRead) {
System.out.println("Error reading string");
System.out.println( eRead );
System.exit(-1);

Answer 1

Thats OK if you are the author of the app you are running or the app you are running is designed so that you can modify it to do so. However, if you do not have that option, is there not another way?