Gain control of a thread and then kills it

Question

I have a question regarding threading in Java. In my code,

...
client.doSth();
// now need to get hold of the thread that is initiated by 'client'
(get a reference to the 'client' thread)
// now kills it
(kills the 'client' thread)
...

So what I would like to know is: in the first brackets, how do I programmatically get hold of a reference to the 'client' thread (NOT the main thread the program is running on), and in the second brackets, how do I properly kill it, i.e. without using the depreciated stop() method.

Many thanks.

Answer 1

To show the Thread tree do like that :

you can do like this :

// Find the root thread group
ThreadGroup root = Thread.currentThread().getThreadGroup().getParent();
while (root.getParent() != null) {
    root = root.getParent();
}

// Visit each thread group
visit(root, 0);

// This method recursively visits all thread groups under `group'.
public static void visit(ThreadGroup group, int level) {
    // Get threads in `group'
    int numThreads = group.activeCount();
    Thread[] threads = new Thread[numThreads*2];
    numThreads = group.enumerate(threads, false);

    System.out.println("    ");

    // Enumerate each thread in `group'
    for (int i=0; i<numThreads; i++) {
        // Get thread
        Thread thread = threads[i];
        System.out.println(thread.toString());
    }

    // Get thread subgroups of `group'
    int numGroups = group.activeGroupCount();
    ThreadGroup[] groups = new ThreadGroup[numGroups*2];
    numGroups = group.enumerate(groups, false);

    // Recursively visit each subgroup
    for (int i=0; i<numGroups; i++) {
        visit(groups[i], level+1);
        }

}

You can choose to call a method that shows the stackTrace for a specified Thread id :

 System.out.println(thread.dumpStack());

Now you have the id to kill :

int idToKill = 2;
int active = Thread.activeCount();
System.out.println("currently active threads: " + active);
Thread all[] = new Thread[active];
Thread.enumerate(all);
for (int i = 0; i < active; i++) {
  System.out.println(i + ": " + all[i]);
  if(idToKill == i)
    ((Thread) all[i]).interrupt();
}

Answer 2

you can create a stpSth() method in your Client and call that to stop it

public class Client(){
    private Thread t;
    volatile private boolean stop;//volatile to ensure visibility across threads
    public doSth(){
        stop=false;
        Runnable r = new Runnable(){
            @Override
            public void run(){
                while(!stop){
                    //do stuff and periodically and ensure that interrupts bubble through
                }
            }
        };

        t = new Thread(r);
        t.start();
    }

    public void stopSht(){
         stop=true;
         t.interupt();
    }
}

Answer 3

Edit: after rereading the question I am not sure any more if you have access to the client code. If you do, well you can revise it and not even use thread but java.util.concurrent.ExecutorService or the likes.. yet

Since the code is not your own... you are on your own to stop it.

ThreadGroup class is designed for. Managing partial programs or modules is not exactly easy and usually it takes some already established framework. Ensuring some 3rd party code will behave and be nice and all it's not always possible. It should include context classloader and what not but here is a skimmed version of how it's done.

Still there might be something you can do to break the bone of the intruder. Assuming stop()/close(), etc has been used, some tricks like ThreadDeath during logging and so on.

ThreadGroup g=new ThreadGroup("client X group");

Runnable r=new Runnable(){
public void run(){
  client.doSmth();//assuming a new thread is started...
}
}
Thread t= new Thread(g, r, "clientStarter");
t.start();

 //stopping, last resort code, it's usually more complicated than just thread.stop, though

//now you can enumerate threads of the ThreadGroup
synchronized(g){//sync ensures no more threads will be created, use it w/ extreme caution
  Thread[] threads = new Thread[g.activeCount()];
  for(Thread thread:threads){
    if(thread==null) break;
    thread.stop();//
  //cannot join in sync of ThreadGroup, do not use it here
    }
  }

Good luck!

Answer 4

I see in the comment you are using kryonet API.

kryonet supplies a stop() method for Client objects. If you start the client using start() creates a Thread, and stop() should stop it.

Following is a snippet to start and stop kryonet servers and clients, showing the active threads at various points in the process. The 2 second sleep is to let the threads come to an end when they are requested to stop.

import java.io.IOException;
import java.util.Arrays;

import com.esotericsoftware.kryonet.Client;
import com.esotericsoftware.kryonet.Server;

public class KryonetAndThreads {
    public static void main(String[] args) throws IOException,
            InterruptedException {
        Server s = new Server();
        s.start();
        s.bind(1927);
        printThreads("server started");

        Client c = new Client();
        c.start();
        c.connect(5000, "LOCALHOST", 1927);
        printThreads("client connected");
        Server s1 = s;
        s.stop();
        printThreads("server stopped");

        s = new Server();
        s.start();
        s.bind(1928);
        printThreads("new server started"); // new server thread will be last on
                                            // the list.

        c.stop();
        printThreads("client stopped");

        c.start();
        c.connect(5000, "localhost", 1928);
        printThreads("client connected to second server");

        c.stop();
        s.stop();
        s1.stop();
        printThreads("both stopped");
    }

    private static void printThreads(String message)
            throws InterruptedException {
        // tick:
        Thread.sleep(2000L);
        Thread[] threads = new Thread[Thread.activeCount()];
        Thread.enumerate(threads);
        System.out.println(message + " :  " + Arrays.asList(threads));
    }
}

Answer 5

If the doSth() method returns a Thread object, you can do the following;

Thread t = client.doSth();
t.interrupt();