Java 同时运行多个Asyntask

我想实现一个程序来执行图像识别。如果图像是在本地处理的，它会发送到另一台计算机进行处理，我将Thread.sleep（1000）设置为本地处理第一个图像，其他将在localprocessing变量设置为false之前发送

private class ProcessImageTask extends AsyncTask<ImageItem, Void, ImageItem>{
    @Override
    protected ImageItem doInBackground(ImageItem... params) {
        if(localProcessing==false){
            //**************processing locally*****************
            localProcessing = true;
            try {
                Bitmap bm = BitmapFactory.decodeFile(params[0].getBitmap());

                Bitmap croppedBitmap = getBitmap(getApplicationContext(), INPUT_SIZE, bm);
                final List<Classifier.Recognition> results = classifier.recognizeImage(croppedBitmap);

                String resultStr = results.toString();
                String trimResult = resultStr.substring(resultStr.indexOf("[")+1,resultStr.indexOf("]")).trim();

                String localId = params[0].getId();
                trimResult = trimResult.substring(0,trimResult.indexOf(")")) + " likely)";

                Bitmap thumbnail = getBitmap(getApplicationContext(), 50, bm);
                ImageItem tmp = new ImageItem(localId, imgToString(thumbnail), trimResult);

                Thread.currentThread();
                Thread.sleep(1000);
                localProcessing = false;
                return tmp;
            } catch (IOException e) {
                e.printStackTrace();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else {
            //****************processing on server*************************
            try {
                String ip = strIP;
                int port = 8195;
                Bitmap bm = BitmapFactory.decodeFile(params[0].getBitmap());
                Bitmap croppedBitmap = getBitmap(getApplicationContext(), INPUT_SIZE, bm);
                String encodedImage = "/ID-BEGIN/" + ID + "/ID-END" + imgToString(croppedBitmap);

                try {
                    //**********Send request to server*********
                    Socket socket = new Socket(ip,port);

                    DataInputStream dis = new DataInputStream(socket.getInputStream());
                    DataOutputStream dout = new DataOutputStream(socket.getOutputStream());

                    byte [] messageToServer = encodedImage.getBytes();
                    dout.writeInt(messageToServer.length);
                    dout.write(messageToServer);

                    //Receive response from server
                    int length = dis.readInt();

                    if(length>0) {
                        byte [] message = new byte[length];
                        dis.readFully(message, 0, message.length);

                        String response = new String(message);
                        //Handler updateHandler.post(new updateUIThread(response));

                        Bitmap thumbnail = getBitmap(getApplicationContext(), 50, bm);
                        ImageItem tmp = new ImageItem(params[0].getId(),imgToString(thumbnail), extractServerMessage(response)+"@@");
                        return tmp;
                    }
                    socket.close();

                } catch (IOException e) {
                    e.printStackTrace();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
    @Override
    protected void onPostExecute(ImageItem imageItem) {
        super.onPostExecute(imageItem);
    }
}

私有类ProcessImageTask扩展了AsyncTask{
@凌驾
受保护的ImageItem doInBackground（ImageItem…参数）{
if（localProcessing==false）{
//**************本地处理*****************
localProcessing=true；
试一试{
位图bm=BitmapFactory.decodeFile（参数[0].getBitmap（））；
位图裁剪位图=getBitmap（getApplicationContext（），输入大小，bm）；
最终列表结果=分类器.recognizeImage（裁剪位图）；
字符串resultStr=results.toString（）；
String trimsresult=resultStr.substring（resultStr.indexOf（“[”）+1，resultStr.indexOf（“]）。trim（）；
字符串localId=params[0]。getId（）；
trimResult=trimResult.substring（0，trimResult.indexOf（“）”）+“可能）”；
位图缩略图=getBitmap（getApplicationContext（），50，bm）；
ImageItem tmp=新ImageItem（本地化、图像缩放（缩略图）、修剪结果）；
Thread.currentThread（）；
睡眠（1000）；
localProcessing=false；
返回tmp；
}捕获（IOE异常）{
e、 printStackTrace（）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
}否则{
//****************在服务器上处理*************************
试一试{
字符串ip=条带；
int端口=8195；
位图bm=BitmapFactory.decodeFile（参数[0].getBitmap（））；
位图裁剪位图=getBitmap（getApplicationContext（），输入大小，bm）；
字符串encodedImage=“/ID-BEGIN/”+ID+“/ID-END”+imgToString（裁剪位图）；
试一试{
//**********向服务器发送请求*********
插座=新插座（ip，端口）；
DataInputStream dis=新的DataInputStream（socket.getInputStream（））；
DataOutputStream dout=新的DataOutputStream（socket.getOutputStream（））；
byte[]messageToServer=encodedImage.getBytes（）；
dout.writeInt（messageToServer.length）；
dout.write（messageToServer）；
//从服务器接收响应
int length=dis.readInt（）；
如果（长度>0）{
字节[]消息=新字节[长度]；
dis.readFully（消息，0，消息长度）；
字符串响应=新字符串（消息）；
//Handler updateHandler.post（新的updateUIThread（响应））；
位图缩略图=getBitmap（getApplicationContext（），50，bm）；
ImageItem tmp=new ImageItem（参数[0].getId（），imgToString（缩略图），extractServerMessage（响应）+“@”）；
返回tmp；
}
socket.close（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
返回null；
}
@凌驾
受保护的void onPostExecute（ImageItem ImageItem）{
super.onPostExecute（imageItem）；
}
}

我意识到它是按顺序工作的，你能告诉我，即使我设置了线程，我也应该如何修复并使不同的任务同时工作

---

非常感谢。

您可能希望在线程池中同时执行所有异步任务

asyncTask1.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, ....);

AsyncTask.THREAD\u POOL\u EXECUTOR

是一个常量

EXECUTOR

。如果您对AsyncTask的线程池不满意。通过这样做，您可以创建自己的线程池

Executor myThreadPool = Executors.newFixedThreadPool(numOfPools);

通常，

numofools

由

Runtime.getRuntime（）.availableProcessors（）从可用处理器获取

需要多少线程仍然取决于您。注意电池的使用。更多的计算能力，更多的电池。只是提醒一下。
您如何执行此任务？