線程獲得控制權，然後殺死它

Question

我有一個關於Java線程化的問題。在我的代碼，

... 
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) 
... 

所以我想知道的是：在第一個括號，我怎麼編程方式獲得一個參考的抱到「客戶」線程（不是主線程程序上運行），並在第二個括號中，我如何正確地殺死它，即不使用depreciated stop（）方法。

非常感謝。

Answer 1

編輯： 重讀的問題後，我不知道任何更多，如果你有機會到客戶端的代碼。如果你這樣做，那麼你可以修改它，甚至不使用線程，但java.util.concurrent.ExecutorService或類似的..但

由於代碼不是你自己的...你是在你自己停止它。

ThreadGroup類是專爲。管理部分程序或模塊並不容易，通常需要一些已經建立的框架。確保一些第三方代碼的行爲良好，並不總是可能的。它應該包括上下文類加載器和什麼不是，但這裏是它的完成過程的簡化版本。

儘管如此，你仍然可以做些什麼來打破入侵者的骨骼。假設已經使用了stop（）/ close（）等，在日誌記錄等一些技巧像ThreadDeath。

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 
    } 
    } 

祝你好運！

Answer 2

如果doSth()方法返回一個Thread對象，則可以執行以下操作;

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

Answer 3

你可以創建你的客戶一個stpSth（）方法調用來阻止它

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 4

要顯示的主題樹做這樣的：

，你可以這樣做：

// 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); 
     } 

} 

您可以選擇調用，顯示堆棧跟蹤一個特定線程ID的方法：

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

現在你有ID殺：

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 5

我在comment中看到您正在使用kryonet API。

kryonet爲Client對象提供了一個stop（）方法。如果你使用start（）創建一個線程來啓動客戶端，並且stop（）應該停止它。

以下是啓動和停止kryonet服務器和客戶端的代碼片段，顯示進程中各個點的活動線程。 2秒睡眠是讓線程在要求停止時結束。

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)); 
    } 
}