java多线程中面临的问题

我在多线程处理期间读取广播数据的流数据捕获方面遇到一个问题，请提供帮助或建议

实际上，有一个类正在从一个udp套接字读取数据。另一个类接受来自每个客户端请求的tcp连接，为每个客户端创建一个线程，并为数据请求相同的udp类。这件事是与第一个线程得到创建工作。但当我从另一台pc/ip向另一台客户机请求时，数据包会丢失到第二台客户机/线程

通过创建一个列表，我在其中存储了Threads outputstream对象，解决了这个问题 并循环发送数据到所有客户端。但这只是暂时的，因为如果客户端/连接增加，它将延迟数据包

读取UDP数据的代码

   public class EventNotifier    
    {
      private InterestingEvent ie;
      public DatagramSocket clientSocket;
      public String[] split_str;

      byte[] receiveData;

      HashMap<String, String> secMap = new HashMap<String, String>();


      public EventNotifier(InterestingEvent event)
      {
        ie = event; 
     clientSocket = new DatagramSocket(9050);
        receiveData = new byte[500];
      }



      public String getDataFeed(String client_id)
      {
        try 
        {
             DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
             clientSocket.receive(receivePacket);
             String s = new String(receivePacket.getData());
             String split_str = s.split(","); 
             if(secMap.containsValue(split_str[0]))
                  return s;
             else
                  return "";
             } catch(Exception e3) {}
      }
     }// end of eventNotifier class

公共类事件通知程序
{
私人利益；
公共DatagramSocket客户端套接字；
公共字符串[]split_str；
字节[]接收数据；
HashMap secMap=新的HashMap（）；
公共事件通知程序（兴趣事件）
{
ie=事件；
clientSocket=newdatagramsocket（9050）；
接收数据=新字节[500]；
}
公共字符串getDataFeed（字符串客户端\u id）
{
尝试
{
DatagramPacket receivePacket=新的DatagramPacket（receiveData，receiveData.length）；
clientSocket.receive（receivePacket）；
字符串s=新字符串（receivePacket.getData（））；
字符串拆分\u str=s.split（“，”）；
if（secMap.containsValue（split_str[0]））
返回s；
其他的
返回“”；
}捕获（异常e3）{}
}
}//eventNotifier类的结束

多线程处理客户端请求的代码

public class multiServer 
{

    static protected List<PrintWriter> writers = new ArrayList<PrintWriter>();
    static String client_id = "";
    public static void main(String[] args)
    { 
       try
       {
           ServerSocket servsock = new ServerSocket(8858);
           Socket incoming;
           while(true)
           {
             incoming = servsock.accept();
             multiServerThread  connection = new multiServerThread(incoming);

             Thread t1 = new Thread(connection);
             t1.start();
           }
       }
       catch(IOException e)
       {
            System.out.println("couldnt make socket");
       }
    }
}

class multiServerThread extends Thread implements InterestingEvent
{

    Socket incoming;
    PrintWriter out=null;
    PrintWriter broad=null;
    BufferedReader in = null;
    String cliString=null;
    private EventNotifier en; 
    int id;

    public static String udp_data;

    public void interestingEvent(String str1)
    {
          this.udp_data = str1;
    }
    public String getUdpData()
    {
      String _udp_data = this.udp_data;
      return _udp_data;
    }
    multiServerThread(Socket incoming)
    {  
        this.incoming=incoming;
        en = new EventNotifier(this);
    } 
    public void run()
    {
        try
        {
            out = new PrintWriter(incoming.getOutputStream(), true);
            in = new BufferedReader(new InputStreamReader(incoming.getInputStream()));
        cliString = in.readLine();
        multiServer.writers.add(out);
        while(true)
                {
               try
                   {
                    udp_data = en.getDataFeed(cliString);
                    if(udp_data!=null && udp_data.length()>0)
                    {
              //workaround for serving the data to all cleints who are connected    
                        for (int i=0; i<multiServer.writers.size();i++)
                        {
                            broad=multiServer.writers.get(i);
                            broad.println(udp_data.trim());
                        }
             //else will directly write to the outputstream object for every thread which is connected
             // out.println(udp_data.trim());
                    }

               }
               catch (Exception e)
               {
                 System.out.println("exception "+e);
               }
               Thread.sleep(1);

            }
        } catch(IOException e)
        {
            System.out.print("IO Exception :: "+ e);
        }
        catch(InterruptedException e)
        {
            System.out.print("exception "+ e);
        }        
    }
}

公共类多服务器
{
静态受保护的列表编写器=新建ArrayList（）；
静态字符串client_id=“”；
公共静态void main（字符串[]args）
{ 
尝试
{
ServerSocket servsock=新的ServerSocket（8858）；
插座输入；
while（true）
{
incoming=servsock.accept（）；
多服务器线程连接=新的多服务器线程（传入）；
螺纹t1=新螺纹（连接）；
t1.start（）；
}
}
捕获（IOE异常）
{
System.out.println（“无法制作套接字”）；
}
}
}
类multiServerThread扩展线程实现InterestingEvent
{
插座输入；
PrintWriter out=null；
PrintWriter宽=空；
BufferedReader in=null；
字符串cliString=null；
私有事件通知程序；
int-id；
公共静态字符串udp_数据；
公共作废利息事件（字符串str1）
{
this.udp_data=str1；
}
公共字符串getUdpData（）
{
String _udp_data=this.udp_data；
返回_udp_数据；
}
多服务器线程（套接字传入）
{  
这个。传入=传入；
en=新事件通知程序（此）；
} 
公开募捐
{
尝试
{
out=新的PrintWriter（incoming.getOutputStream（），true）；
in=新的BufferedReader（新的InputStreamReader（incoming.getInputStream（））；
cliString=in.readLine（）；
multiServer.writers.add（out）；
while（true）
{
尝试
{
udp_data=en.getDataFeed（cliString）；
if（udp_数据！=null&&udp_数据.length（）>0）
{
//将数据提供给所有连接的Cleint的变通方法
对于（int i=0；i您需要互斥（或不同的设计）

例如，如果两个线程同时调用
multiServer.writers.add（out）；
会发生什么

来自ArrayList Javadocs

请注意，此实现未同步。如果多个线程同时访问ArrayList实例，并且至少有一个线程在结构上修改列表，则必须在外部对其进行同步。（结构修改是添加或删除一个或多个元素的任何操作，或[…]）

另一个问题是两个线程同时调用
udp_data=en.getDataFeed（cliString）；
。第二个线程可能会覆盖第一个线程的结果。您将丢失数据

如果一个线程调用（int i=0；我为什么你有用于
公共静态字符串udp_data
的静态数据？请编辑你的帖子，使其易于理解，并在修复忽略catch块的异常后再次运行它。我已声明udp_数据字符串为静态，因为它在所有线程中都应该是通用的。更新代码@EJP，请检查！！！你仍然有
}catch（异常e3）{}
而您仍然没有澄清您的问题。我不理解这句话：“另一个类接受来自每个客户端请求的tcp连接，为每个客户端创建一个线程，并请求相同的udp类来获取数据。”感谢您的回复，我的问题是，每个线程在udp端口上读取的数据应该是一致的，并且在每个线程之间是并发的。我知道，如果相同的变量或方法被覆盖或调用，将有一个数据丢失。这就是我需要一个解决方案，如何在线程内调用一个方法，该方法将无法正确识别每个thread和数据在所有项目中都是相同的threads@praveen2609这几乎是不可能的。你需要一些同步来保持数据一致。我不明白为什么我的答案不符合你的要求。所有收到的udp_数据。trim（）打印到所有正在运行的线程。我是这个博客的新手，有什么方法可以和你聊天吗？我可能会准确地向你解释我的问题。根据我对你所说的理解，我需要为writers进行同步。添加和到serverallwriters，但在这种情况下，每个线程都会调用相同的方法，并多次发送数据不是吗
public class multiServer 
{

    private List<PrintWriter> writers = new ArrayList<PrintWriter>();

    public synchronized void addWriter(PrintWrite out) {
         writers.add(out);
    }
    public synchronized void serveAllWriters(String data) {
         for (int i=0; i<multiServer.writers.size();i++)
         {
             broad=multiServer.writers.get(i);
             broad.println(data);
         }
    }
}

class multiServerThread extends Thread implements InterestingEvent
{
      //...
      private String udp_data;
      //...
      myMultiServer.addWriter(out);

      //...
      udp_data = en.getDataFeed(cliString);
      if(udp_data!=null && udp_data.length()>0)
            myMultiServer.serveAllWriters(udp_data.trim());
      //...
}