Java 主程序中的两个线程并发

我有一个程序（

MAIN

），它有两个线程与com端口（

com

）和TCP会话（

TCP

）通信

如果main（

main

）程序需要来自

TCP

和

COM

模块的信息，它将发送请求消息

R

（

tR

和

cR

）。当线程有应答时，它们会发回应答

A

（

tA

和

cA）

。我有问题，当我将reguest发送到

COM

（

cR

）时，没有从中获得答案，而是从

TCP

-

tA

获得答案

COM

R-A

应该以某种方式与TCP中断隔离。如何使用Java1.4解决这个问题

UPD。在

tA

上，事件

MAIN

启动

cR

-请求

COM

端口。Main可以自行启动对

COM

的请求。我希望避免在没有得到第一个问题的答案的情况下，向

COM

端口提出第二个问题

UPD2。实际上整个系统如下图所示

cR

可以由

tA

或

uR

启动。而

cA

可以通过

tR

对

TCP

进行应答，或者通过

uA对
UI
进行应答。
以下情况是正确的

uR->cR->cA->tR-tA->cR->cA->uA
cA->tR->tA->cR
uR->cR->cA->uA

当两个请求同时进入COM时，我会遇到麻烦

cA->tR->tA->cR
uR->cR

我只想在COM向第一个调用者返回应答时才允许新请求。
正如我正确理解的那样，main方法中有两个线程。一个线程与TCP交互，另一个线程与COM交互。对吗？
如果是这种情况，那么可以让handle线程1处理所有TCP请求/响应，让handle线程2处理所有COM请求/响应。主线程没有意识到这一点。直到两个线程独立地完成它们的工作，主线程才会等待，一旦两个线程都完成了它们的工作，主线程就可以继续它的工作。因此，COM和TCP的通信是完全分离的。您可以在这里使用Threads“join（）”方法

我回答你的问题了吗？
这里有一个例子可以解释你的系统。在这里，我创建了一个调用方接收器的环境。直到呼叫者没有以他或她的陈述结束，接收者才能开始说任何话或回应呼叫者

Caller.java

public class Caller implements Runnable {

    MaintainACall call;

    Caller(MaintainACall me)
    {
        call=me;
        new Thread(this,"Mr X").start();
    }
    public void run()
    {
        String a[]={"Hello how r u", "I'm in vadodara"};
        for(int i=0;i<2;i++)
        {

            call.sayHello(a[i]);
        }

    }

}

public class Reciver implements Runnable {

    MaintainACall call;

    Reciver(MaintainACall call)
    {
        this.call=call;
        new Thread(this,"Mr Y").start();
    }
    public void run()
    {

        call.Wtshesay();

    }

}

public class MaintainACall {

    String say;
    boolean valueSet=false;

    synchronized String Wtshesay()
    {
        while(!valueSet)
            try
            {
                wait();
            }
            catch(InterruptedException ie)
            {
                System.out.println(ie);
            }
        System.out.println("I have heared "+say);
        valueSet=false;
        notify();
        return say;
    }

    synchronized void sayHello(String msg)
    {
        while(valueSet)
            try
            {
                wait();
            }
            catch(InterruptedException ie)
            {
                System.out.println(ie);
            }
        say=msg;
        valueSet=true;
        System.out.println("She says "+say);        
        notify();
    }

}

public class MainClass {
    public static void main(String arg[])
    {
        MaintainACall my=new MaintainACall();
        new Caller(my);
        new Reciver(my);
    }

}

maintacacall.java

public class Caller implements Runnable {

    MaintainACall call;

    Caller(MaintainACall me)
    {
        call=me;
        new Thread(this,"Mr X").start();
    }
    public void run()
    {
        String a[]={"Hello how r u", "I'm in vadodara"};
        for(int i=0;i<2;i++)
        {

            call.sayHello(a[i]);
        }

    }

}

public class Reciver implements Runnable {

    MaintainACall call;

    Reciver(MaintainACall call)
    {
        this.call=call;
        new Thread(this,"Mr Y").start();
    }
    public void run()
    {

        call.Wtshesay();

    }

}

public class MaintainACall {

    String say;
    boolean valueSet=false;

    synchronized String Wtshesay()
    {
        while(!valueSet)
            try
            {
                wait();
            }
            catch(InterruptedException ie)
            {
                System.out.println(ie);
            }
        System.out.println("I have heared "+say);
        valueSet=false;
        notify();
        return say;
    }

    synchronized void sayHello(String msg)
    {
        while(valueSet)
            try
            {
                wait();
            }
            catch(InterruptedException ie)
            {
                System.out.println(ie);
            }
        say=msg;
        valueSet=true;
        System.out.println("She says "+say);        
        notify();
    }

}

public class MainClass {
    public static void main(String arg[])
    {
        MaintainACall my=new MaintainACall();
        new Caller(my);
        new Reciver(my);
    }

}

MainClass.java

public class Caller implements Runnable {

    MaintainACall call;

    Caller(MaintainACall me)
    {
        call=me;
        new Thread(this,"Mr X").start();
    }
    public void run()
    {
        String a[]={"Hello how r u", "I'm in vadodara"};
        for(int i=0;i<2;i++)
        {

            call.sayHello(a[i]);
        }

    }

}

public class Reciver implements Runnable {

    MaintainACall call;

    Reciver(MaintainACall call)
    {
        this.call=call;
        new Thread(this,"Mr Y").start();
    }
    public void run()
    {

        call.Wtshesay();

    }

}

public class MaintainACall {

    String say;
    boolean valueSet=false;

    synchronized String Wtshesay()
    {
        while(!valueSet)
            try
            {
                wait();
            }
            catch(InterruptedException ie)
            {
                System.out.println(ie);
            }
        System.out.println("I have heared "+say);
        valueSet=false;
        notify();
        return say;
    }

    synchronized void sayHello(String msg)
    {
        while(valueSet)
            try
            {
                wait();
            }
            catch(InterruptedException ie)
            {
                System.out.println(ie);
            }
        say=msg;
        valueSet=true;
        System.out.println("She says "+say);        
        notify();
    }

}

public class MainClass {
    public static void main(String arg[])
    {
        MaintainACall my=new MaintainACall();
        new Caller(my);
        new Reciver(my);
    }

}

您不必使用多个线程。只需从套接字读取请求，通过COM端口通信同步处理请求，然后通过套接字写入响应

不过，使用多线程可能有其原因。例如，如果COM端口响应速度不够快，但您使用的串行端口库不支持超时配置，则您可能希望能够使用超时错误响应套接字请求。在这种情况下，您必须澄清您的需求。如果从套接字接收到另一个请求，但COM线程仍无法处理前一个请求，您希望发生什么？您可以等待，立即以错误响应，等等

无论请求是来自套接字还是来自主程序本身，只要需要与COM端口进行交互，都可以创建一个连接到该服务的任务。这将确保串行通信不会与竞争请求交错

这里的基本思想是只允许一个线程使用COM端口，使用由其他线程生成的任务队列。
对不起，Vico，您的问题不完全清楚。是否有一个线程专用于将请求写入COM端口并等待响应？另一个对TCP也是这样吗？这两个线程如何相互作用？当你谈到“打扰”时，你到底是什么意思？换句话说，使用两个独立连接的两个独立线程通常不会相互干扰或交互；您必须编写代码来协调它们。你有什么？你所说的“同意”是什么意思？我已经在我更新的消息正文中更新了我的问题