未排序地接收Java套接字数据

我正在从Android应用程序（加速计和陀螺仪）收集数据，并通过Java套接字将数据发送到桌面应用程序，但速度很快 （传感器延迟最快，传感器延迟游戏）

注:

• ReadingList：包含来自传感器的所有读数
• 我从列表中删除发送到服务器的数据
• 只发送一次数据，我确保它是从客户端订购的 但我在服务器端使它们无序（我收到了所有数据，但没有排序）
• processData（字符串读取）函数可能需要时间，但不会太多

客户端代码：

    class SocketClientThread implements Runnable {

    public SocketClientThread(){

    }
    public void run() {
        while (!Thread.currentThread().isInterrupted() && breathingStarted) {
            try {

                InetAddress serverAddr = InetAddress.getByName(SERVER_IP);
                socket = new Socket(serverAddr, SERVERPORT);


                PrintWriter out =
                        new PrintWriter(socket.getOutputStream(), true);

                socket.setSendBufferSize(Integer.MAX_VALUE);
                socket.setReceiveBufferSize(Integer.MAX_VALUE);

                int lastCount = readingsList.size();

                out.println(readingsList); 
                out.flush();
                out.close(); 
                int toberemoved = lastCount;   
                if(readingsList.size() > 0){
                    for (int i = 0; i < toberemoved; i++) {
                        readingsList.remove(0);
                    }
                }


                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }


            } catch (UnknownHostException e1) {
                e1.printStackTrace();   
            } catch (IOException e1) {
                e1.printStackTrace();
            }

        }
    }
}

类SocketClientThread实现可运行{
公共SocketClientThread（）{
}
公开募捐{
而（！Thread.currentThread（）.isInterrupted（）&&breathingStarted）{
试一试{
inetAddressServerAddr=InetAddress.getByName（服务器IP）；
套接字=新套接字（serverAddr、SERVERPORT）；
打印输出=
新的PrintWriter（socket.getOutputStream（），true）；
socket.setSendBufferSize（整数.MAX_值）；
套接字.setReceiveBufferSize（整数.MAX_值）；
int lastCount=readingsList.size（）；
out.println（读取列表）；
out.flush（）；
out.close（）；
int toberemoved=最后一次计数；
if（readingsList.size（）>0）{
for（int i=0；i

服务器代码：

serverSocket = new ServerSocket(port);
    serverSocket.setSoTimeout(minutes*60*1000);

Thread thread = new Thread() {
    public void run() {
        while(!isStopped)
        {
            try
            {

                Socket connection = serverSocket.accept();
                connection.setReceiveBufferSize(Integer.MAX_VALUE);
                connection.setSendBufferSize(Integer.MAX_VALUE);


                BufferedReader input =
                        new BufferedReader(new InputStreamReader(connection.getInputStream()));


                PrintWriter out =
                        new PrintWriter(connection.getOutputStream(), true);

                String inputLine; 
                while ((inputLine = input.readLine()) != null) {
                    recentReading = inputLine; 
                    String oldReading = recentReading;
                    String modifiedReading = oldReading.replace("[", "");
                    modifiedReading = modifiedReading.replace("]", "");
                    String [] readings = modifiedReading.split(",");
                    for (int i = 0; i < readings.length; i++) {
                        String currentReading = readings[i].trim();
                        String [] tokens = currentReading.split("_");
                         processData(currentReading);


                    }
                }
            }catch(SocketTimeoutException s)
            {
                System.out.println("Socket timed out!");
                display.syncExec(new Runnable() {
                    public void run() {
                        statusVal.setText("Socket timed out!");
                    }
                });

                break;
            }catch(SocketException s)
            {
                if(serverSocket.isClosed()){
                    display.syncExec(new Runnable() {
                        public void run() {
                            statusVal.setText("Disconnected");
                        }
                    });
                }
                break;
            }catch(IOException e)
            {
                e.printStackTrace();
                break;
            }
        }

    }
};
thread.setDaemon(true);
thread.start();

serverSocket=新的serverSocket（端口）；
serverSocket.setSoTimeout（分钟*60*1000）；
线程线程=新线程（）{
公开募捐{
而（！isStopped）
{
尝试
{
套接字连接=serverSocket.accept（）；
connection.setReceiveBufferSize（整数.MAX_值）；
connection.setSendBufferSize（整数.MAX_值）；
缓冲读取器输入=
新的BufferedReader（新的InputStreamReader（connection.getInputStream（））；
打印输出=
新的PrintWriter（connection.getOutputStream（），true）；
字符串输入线；
而（（inputLine=input.readLine（））！=null）{
重新居中阅读=输入行；
字符串oldReading=重新居中读取；
字符串修饰符=oldReading.replace（“[”，”）；
modifiedrarding=modifiedrarding.replace（“]”，“”）；
String[]reads=modifier.split（“，”）；
对于（int i=0；i

---

我在时间过后获取数据（未排序）

什么类型是

readingsList

？有一些类型的

List

忽略了效率的顺序。ListreadingsList和我创建它的方式是：readingsList=Collections.synchronizedList（newarraryList（））；我将它添加到ReadingsList ordered>>中，我在客户端确保了这一点，我指的是它是如何创建的<代码>新建列表（）不可能。它的具体类型是什么；或者更好：如何创建

readingsList

？readingsList=Collections.synchronizedList（newarraylist（））；它是由多个线程更新的，所以我就这样创建了它，我看不出有什么问题。你说的“无序”是什么意思？是否有可能某些网络数据包比其他数据包花费更多的时间并破坏了顺序？如果是这样，那么考虑向您发送的数据添加某种索引或时间戳，这样您就可以确保数据以正确的顺序接收。