停止网络接收器线程

Question

>假设我有一个类型为 NetThread（定义如下）的对象，名为 nt 。我已经初始化并启动了它

nt = new NetThread(port, rs); 
nt.setDaemon(true); 
nt.setPriority(Thread.MAX_PRIORITY); 
nt.start(); 

现在我希望能够在执行过程中随时停止此线程。我可以通过打电话nt.interrupt()来做到这一点。

但是，我想我会尝试做一些对我来说更有意义的事情：在NetThread中创建一个名为 StopListening() 的方法。

nt运行时，我打电话给nt.StopListening()。无。

线程只是继续运行。 我错过了什么？ 为什么这不起作用？

public class NetThread extends Thread {
    int port; 
    private static int PAYLOAD_MAX = 10000; 
    private static int NET_SO_TIMEOUT = 0; 
    private RunStats rs; 
    private boolean stopflag = false; 
    private StageCode stage; 
    NetThread(int port_number, RunStats runstats)
    {
        rs = runstats; 
        port = port_number; 
        stage = StageCode.STAGE_WAIT; 
    }
    public synchronized void stopListening()
    {
        Log.d(C.DTAG, "stopListening() was called..."); 
        stopflag=true; 
    }
    @Override
    public void run() 
    {
        receiveData(); 
        Log.d(C.DTAG, "Network thread is finished."); 
    }
    public void receiveData()
    {
        // request permission to do network operations in manifest file...done
        Log.d(C.DTAG, "network thread has started."); 
        // start the network side of things
        DatagramSocket sock = null; 
        DatagramPacket pkt = null; 
        try 
        {
            byte[] data = new byte[PAYLOAD_MAX]; 
            sock = new DatagramSocket(port); 
            sock.setSoTimeout(NET_SO_TIMEOUT);
            pkt = new DatagramPacket(data, 0, PAYLOAD_MAX); 
            while (!stopflag)
            {
                Thread.sleep(0); // allow for an interrupt
                try 
                {
                    sock.receive(pkt); 
                    int length = pkt.getLength(); 
                    processPayload(pkt.getData(), length); 
                }
                catch (InterruptedIOException e)
                {
                    // thrown when a timeout occurs
                    Log.d(C.DTAG, "net: no packets yet"); 
                }
            }
            Log.d(C.DTAG, "done receiving."); 
            if (sock != null) sock.close(); 
        } 
        catch (InterruptedException x) 
        {
            Log.d(C.DTAG, "net: was interrupted."); 
        } 
        catch (SocketException e) 
        {
            Log.d(C.DTAG, "net: SocketException"); 
            e.printStackTrace();
        } 
        catch (IOException e) 
        {
            Log.d(C.DTAG, "net: IOException"); 
            e.printStackTrace();
        }
        if (sock != null) sock.close(); 
    }
    public void processPayload(byte[] data, int length)
    {
        if (length < 20) return; 
        int sc =    data[ 0] & 0x000000FF | data[ 1]<<8 & 0x0000FF00 | data[ 2]<<16 & 0x00FF0000 | data[ 3]<<24 & 0xFF000000; 
        int seq =   data[ 4] & 0x000000FF | data[ 5]<<8 & 0x0000FF00 | data[ 6]<<16 & 0x00FF0000 | data[ 7]<<24 & 0xFF000000; 
        int i =     data[ 8] & 0x000000FF | data[ 9]<<8 & 0x0000FF00 | data[10]<<16 & 0x00FF0000 | data[11]<<24 & 0xFF000000; 
        int s =     data[12] & 0x000000FF | data[13]<<8 & 0x0000FF00 | data[14]<<16 & 0x00FF0000 | data[15]<<24 & 0xFF000000; 
        int n =     data[16] & 0x000000FF | data[17]<<8 & 0x0000FF00 | data[18]<<16 & 0x00FF0000 | data[19]<<24 & 0xFF000000; 
        StageCode sc2 = null; 
        switch (sc)
        {
        case 20: sc2 = StageCode.STAGE_INIT; break; 
        case 30: sc2 = StageCode.STAGE_TEST; break; 
        case 40: sc2 = StageCode.STAGE_STOP; break; 
        }
        TestPacketHeader tph = new TestPacketHeader(sc2, seq, i, s, n); 
        rs.RegisterReceivedPacket(tph); 
        if (sc2 == StageCode.STAGE_STOP) stopflag = true; 
    }
    public synchronized StageCode status()
    {
        return stage; 
    }
}

Answer 1

你尝试这样做的方式本质上是重新创建中断在幕后的作用，所以你可能最好只使用中断。话虽如此，如果您进行布尔volatile，那么线程将看到其他线程使您的代码应该可以工作的更改。:)

中断

还有一个优点，即如果线程处于某些等待状态，它将唤醒您的线程，因此往往会导致中断处理得更快。请注意，这不能完全依赖，因为在检查标志和进入等待状态之间可能会收到中断 - 在这种情况下，等待仍然需要超时才能看到标志。

中断和您自己的版本都通过向线程发出它应该停止的信号，然后让线程整齐地关闭自己来工作。这是正确的做事方式，因为只是积极地杀死线程会导致各种令人讨厌的副作用，例如半完成的处理。