Java Android TCP通信太慢了

我的TCP发送者类是

TCPSenderTask

，作为客户端，我使用了TCP服务器的服务

当我尝试发送数据时，数据传输太慢。我找不到原因

package com.example.sampletcpclient;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.ObjectOutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.ArrayList;

import com.example.model.Order;

import android.content.Context;
import android.os.AsyncTask;
import android.widget.TextView;

class TCPSenderTask extends AsyncTask<Void, Void, Boolean> {
    Context mContext;
    TextView tv;

    BufferedReader reader;
    PrintWriter writer;
    Socket socket;

    ArrayList<Order> outgoingOrders;
    ObjectOutputStream oos;


    public TCPSenderTask(Context mContext, ArrayList<Order> outgoingOrders, TextView tv) {
        this.mContext = mContext;
        this.tv = tv;
        this.outgoingOrders = outgoingOrders;

    }

    @Override
    protected void onPreExecute() {
        super.onPreExecute();
    }

    @Override
    protected Boolean doInBackground(Void... params) {
        try {

            socket = new Socket("192.168.2.3", 4999);
            oos = new ObjectOutputStream(socket.getOutputStream());
            oos.writeObject(outgoingOrders);
            oos.close();

            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    @Override
    protected void onPostExecute(Boolean result) {
        super.onPostExecute(result);
        if(result){
            tv.setText("Successuful");
        } else{
            tv.setText("Unsuccessuful");
        }
    }
}

package com.example.sampletcpclient；
导入java.io.BufferedReader；
导入java.io.InputStreamReader；
导入java.io.ObjectOutputStream；
导入java.io.PrintWriter；
导入java.net.Socket；
导入java.util.ArrayList；
导入com.example.model.Order；
导入android.content.Context；
导入android.os.AsyncTask；
导入android.widget.TextView；
类TCPSenderTask扩展了异步任务{
语境；
文本视图电视；
缓冲读取器；
版画作家；
插座；
ArrayList支出订单；
对象输出流oos；
公共TCPSenderTask（上下文mContext、阵列列表支出订单、文本视图tv）{
this.mContext=mContext；
this.tv=tv；
this.outgoingOrders=outgoingOrders；
}
@凌驾
受保护的void onPreExecute（）{
super.onPreExecute（）；
}
@凌驾
受保护的布尔doInBackground（Void…params）{
试一试{
插座=新插座（“192.168.2.3”，4999）；
oos=newObjectOutputStream（socket.getOutputStream（））；
oos.writeObject（支出订单）；
oos.close（）；
返回true；
}捕获（例外e）{
e、 printStackTrace（）；
返回false；
}
}
@凌驾
受保护的void onPostExecute（布尔结果）{
super.onPostExecute（结果）；
如果（结果）{
tv.setText（“成功”）；
}否则{
tv.setText（“未成功”）；
}
}
}

以及我的TCP侦听器服务作为TCP服务器

package com.example.sampletcpserver;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;

import com.example.model.Order;


import android.app.Activity;
import android.app.Notification;
import android.app.PendingIntent;
import android.app.Service;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Binder;
import android.os.IBinder;
import android.support.v4.app.NotificationCompat;
import android.support.v4.content.LocalBroadcastManager;
import android.util.Log;

public class TCPListenerService extends Service {

    private final IBinder mBinder = new TCPBinder();

    private int result = Activity.RESULT_CANCELED;

    public static final String NOTIFICATION = "com.example.sampletcpserver";
    public static final String RESULT = "result";
    public static final String MESSAGE = "message";
    private static int FOREGROUND_ID = 1338;

    private String message;

    LocalBroadcastManager broadcaster;

    public static ArrayList<Order> incomingOrders;
    ObjectInputStream ois;

    public int counter = 1;

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {

        Intent notificationIntent = new Intent(this, MainActivity.class);
        PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, notificationIntent, PendingIntent.FLAG_UPDATE_CURRENT);

        broadcaster = LocalBroadcastManager.getInstance(this);

        incomingOrders = new ArrayList<Order>();

        Bitmap icon = BitmapFactory.decodeResource(getResources(),
                R.drawable.service_logo);

        Notification notification = new NotificationCompat.Builder(this)
                .setContentTitle("")
                .setTicker("")
                .setContentText("Service")
                .setSmallIcon(R.drawable.icon)
                .setLargeIcon(Bitmap.createScaledBitmap(icon, 64, 64, false))
                .setContentIntent(pendingIntent)
                .setOngoing(true)
                .build();


        startForeground(FOREGROUND_ID, notification);

        Thread tcp = new Thread(new TcpServer());
        tcp.start();

        return Service.START_STICKY;
    }

    private void publishResults(String message, int result) {
        Intent intent = new Intent(NOTIFICATION);
        intent.putExtra(MESSAGE, message);
        intent.putExtra(RESULT, result);
        broadcaster.sendBroadcast(intent);
    }

    @Override
    public IBinder onBind(Intent arg0) {
        return mBinder;
    }

    public class TCPBinder extends Binder {
        TCPListenerService getService() {
            return TCPListenerService.this;
        }
    }

    class TcpServer implements Runnable {

        @Override
        public void run() {
            try {
                ServerSocket serverSock = new ServerSocket(4999);

                while (true) {
                    Socket clientSocket = serverSock.accept();



                    Thread t = new Thread(new ClientHandler(clientSocket));
                    t.start();
                }
            } catch (IOException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

    }

    class ClientHandler implements Runnable {
        BufferedReader reader;
        Socket sock;

        public ClientHandler(Socket clientSocket) {
            try {
                sock = clientSocket;


                ois = new ObjectInputStream(clientSocket.getInputStream());

            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }

        public void run() {
            String msg = "";
            try {


                incomingOrders = (ArrayList<Order>) ois.readObject();
                ois.close();
                sock.close();
                for (int i = 0; i < incomingOrders.size(); i++) {
                    Log.e("message", incomingOrders.get(i).getTableNo() + incomingOrders.get(i).getFoodName());
                }

                Log.e("packet", "received packet : " + counter++);

    //          Log.e("message", msg);

                result = Activity.RESULT_OK;

    //          publishResults(msg, result);
            } catch (IOException | ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }

}

package com.example.sampletcpserver；
导入java.io.BufferedReader；
导入java.io.IOException；
导入java.io.InputStreamReader；
导入java.io.ObjectInputStream；
导入java.io.PrintWriter；
导入java.net.ServerSocket；
导入java.net.Socket；
导入java.util.ArrayList；
导入com.example.model.Order；
导入android.app.Activity；
导入android.app.Notification；
导入android.app.pendingent；
导入android.app.Service；
导入android.content.Intent；
导入android.graphics.Bitmap；
导入android.graphics.BitmapFactory；
导入android.os.Binder；
导入android.os.IBinder；
导入android.support.v4.app.NotificationCompat；
导入android.support.v4.content.LocalBroadcastManager；
导入android.util.Log；
公共类TCPListenerService扩展了服务{
私有最终IBinder mBinder=新TCPBinder（）；
private int result=Activity.result\u已取消；
公共静态最终字符串通知=“com.example.sampletcpserver”；
公共静态最终字符串RESULT=“RESULT”；
公共静态最终字符串MESSAGE=“MESSAGE”；
私有静态int前台_ID=1338；
私有字符串消息；
本地广播经理；
公共静态数组列表收入单；
目的输入流ois；
公共整数计数器=1；
@凌驾
公共int onStartCommand（Intent Intent、int标志、int startId）{
Intent notificationIntent=新的Intent（this，MainActivity.class）；
PendingEvent PendingEvent=PendingEvent.getActivity（this，0，notificationIntent，PendingEvent.FLAG_UPDATE_CURRENT）；
broadcaster=LocalBroadcastManager.getInstance（this）；
incomingOrders=新ArrayList（）；
位图图标=BitmapFactory.decodeResource（getResources（），
R.可拉拔的服务标识）；
Notification Notification=新建NotificationCompat.Builder（此）
.setContentTitle（“”）
.setTicker（“”）
.setContentText（“服务”）
.setSmallIcon（R.drawable.icon）
.setLargeIcon（位图.createScaledBitmap（图标，64，64，false））
.setContentIntent（挂起内容）
.正在进行（正确）
.build（）；
startForeground（前台ID，通知）；
线程tcp=新线程（新TcpServer（））；
tcp.start（）；
return Service.START\u STICKY；
}
私有void publishResults（字符串消息，int结果）{
意向=新意向（通知）；
intent.putExtra（消息，消息）；
意图。额外（结果，结果）；
广播者。发送广播（意图）；
}
@凌驾
公共IBinder onBind（意图arg0）{
返回mBinder；
}
公共类TCPBinder扩展绑定器{
TCPListenerService getService（）{
返回TCPListenerService.this；
}
}
类TcpServer实现可运行{
@凌驾
公开募捐{
试一试{
ServerSocket serverSock=新的ServerSocket（4999）；
while（true）{
Socket clientSocket=serverSock.accept（）；
线程t=新线程（新ClientHandler（clientSocket））；
t、 start（）；
}
}捕获（IOE异常）{
e、 printStackTrace（）；
}捕获（例外e）{
e、 printStackTrace（）；
}
}
}
类ClientHandler实现Runnable{
缓冲读取器；
插座；
公共客户端句柄（套接字客户端套接字）{
试一试{
sock=clientSocket；
ois=newObjectInputStream（clientSocket.getInputStream（））；
}捕获（例外情况除外）{
例如printStackTrace（）；
}
}
公开募捐{
字符串msg=“”；
试一试{
incomingOrders=（ArrayList）ois.readObject（）；
ois.close（）；
sock.close（）；
对于（int i=0；i