Java/线程的优先级

Question

我有一个启动四个线程来监听传入数据包的应用程序。每个线程在不同的端口上打开一个套接字。通常一次只能在一个端口上接收到数据包，但在某些情况下，可能会在几秒钟内在两个端口上接收到消息。这些线程中的每一个都处理消息并更新一堆监听器(它们都在做一些 Swing 绘画的事情)。由于消息以 10 Hz 的频率发送，并且 Swing 组件上的绘制操作需要一些时间，因此我的第一种方法是只处理 20 条消息中的一条消息(2 秒时间完成组件上的绘制)。效果很好...

但是当同时收到两条消息时，我需要告诉我的应用程序只处理其中一条(收到的时间很短)。总之，第二个端口接收到 10 条消息，频率也是 10 Hz。意思是，使用第一种方法有时我会错过所有 10 个，因为只处理了 20 个中的一个。

每当在第二个端口上收到一条消息时，我希望我的应用程序处理该消息，而不管在第一个端口上收到什么或者当时是否绘制了某些东西。

以下代码显示了我的线程的实现，其中四个同时启动，具体取决于通过构造函数提供的端口。

private class IncomingRunner implements Runnable {

    private int listenPort;
    private DatagramSocket localSocket;
    private DatagramPacket packet;
    private int counter = 0;

    public IncomingRunner(int port) {
        this.listenPort = port;
    }

    @Override
    public void run() {
        try {
            localSocket = new DatagramSocket(listenPort);

            byte[] buffer = new byte[1024];
            packet = new DatagramPacket(buffer, buffer.length);

            while(isRunning)
                recvIncomingMsg();

        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    private void recvIncomingMsg() {
        try {
            localSocket.receive(packet);
            port = localSocket.getLocalPort();

            ReceivedMsg eventMsg;

            if(port == Config.PORT_1) {
                eventMsg = new ReceivedMsg(Config.PORT_1, Config.SOMETHING_1);
                System.out.println(HexWriter.getHex(packet.getData()));
            } else if (port == Config.PORT_2) {
                eventMsg = new ReceivedMsg(Config.PORT_2, Config.SOMETHING_2);
                System.out.println(HexWriter.getHex(packet.getData()));
            } else if (port == Config.PORT_3) {
                eventMsg = new ReceivedMsg(Config.PORT_3, Config.SOMETHING_3);
                System.out.println(HexWriter.getHex(packet.getData()));
            } else {
                eventMsg = new ReceivedMsg(Config.PORT_4, Config.SOMETHING_4);
                System.out.println(HexWriter.getHex(packet.getData()));
            }

            counter++;

            if(counter%20 == 0) {
                forward2PacketPanel(eventMsg);
                counter = 0;
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void forward2PacketPanel(final ReceivedMsg t) {
        for(final IPacketListener c : listeners) {
            if(c instanceof IPacketListener) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        ((IPacketListener)c).update(t);
                    }
                }).start();
            }
        }
    }
}

更新:我启动新线程来更新监听器的原因是，因为它们都应该同时更新 GUI。每个 updated 都会在不同的 JPanel 上调用一个 paintComponent() 方法。所以它们都应该一起运行。

更新 2:我不能使用第一种方法，因为这会导致消息丢失可能很重要的消息(在第二个端口上接收到)。我需要的是，当收到一条普通消息时，只需处理它并进行绘画，不管有多少新的普通消息(在第一个端口上)进来。但即使在第二个端口上只收到一条消息，应用程序需要处理那个，不管正常接收器线程中发生了什么。

我想我在这里面临两个问题:

1. 我需要让每个线程等到绘画完成，因为这是 UDP，我可以处理一个普通数据包，而在绘画操作期间忘记所有后续的普通数据包。完成后，处理下一个正常数据包。

2. 如果在第 2 个端口收到数据包，中断所有正常的数据包处理操作并执行处理特殊数据包所需的操作。

问题 (1) 使用 MainIncomingClass 中的 BitSet 解决。每个 Listener 都使用某种回调函数来指示它已完成绘制并在 BitSet 中设置一个特定的 Bit。如果不是所有的都是真的，我不处理任何新的数据包，只是让他们去。

Answer 1

他们谈论事件派发线程here .您必须使用它来更新您的 GUI。幸运的是，您还可以使用它以任意顺序发布您的更新。 EDT 会为您处理 start()。您仍然需要同步对 t 的访问。

EventQueue.invokeLater(new Runnable() {
    @Override
    public void run() {
        ((IPacketListener)c).update(t);
    }
});