Question

我需要建议这个解决方案是否可以接受并且不会导致溢出，我更新了使用AsyncTask读取的数据，在AsyncTask完成后我需要一次又一次地更新。这个解决方案是否可接受且安全

private class DownloadFilesTask extends AsyncTask<URL,Integer,com.ring_view.www.json.System> {

    @Override
    protected com.ring_view.www.json.System doInBackground(URL... params) {
        int count = params.length;
         URL temp=params[0];
         System system=null;
        try {
            system = Communicator.getSystem(temp);
        } catch (LoggingConnectionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (JSONParsingErrorException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

         return system;
    }

     protected void onProgressUpdate(Integer... progress) {
         //setProgressPercent(progress[0]);
     }

     protected void onPostExecute(com.ring_view.www.json.System result) {
         txtWorkAllowedValue.setText(result.work_allowed);
         try {
            new DownloadFilesTask().execute(new URL("http://test/status-system.json"));
        } catch (MalformedURLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
     }

 }

我第一次调用new DownloadFilesTask（）。execute（new URL（“http：//test/status-system.json”））;在OvCreate方法中，它在模拟器中工作正常。这是安全还是有更优雅的解决方案？

Answer 1

是的，多次实例化AsyncTask是可以接受的，例如......

new DownloadFilesTask().execute(...);
...
new DownloadFilesTask().execute(...);

......是允许的。

你不能做以下事情，但......

DownloadFilesTask myTask = new DownloadFilesTask();
myTask.execute(...); // This is OK
myTask.execute(...); // This will cause an exception

这是因为两次执行同一个线程是不合法的。在第一个示例中，使用new重复为doInBackground(...)创建新线程，但在第二个示例中，它尝试重新使用前一个线程。

Answer 2

默认情况下，AsyncTask自动处理它自己的对象池。所以你不必担心溢出。我认为它默认只允许10个AsyncTasks在任何时候运行，我不确定确切的数字。是的，就像MisterSquonk说的那样，每次都必须创建一个新任务。

Answer 3

你只需要一些东西让它停下来，比如索引或条件，或者它会一直运行。

我做了以下事情：

private ProgressDialog mProgressDialog;

private class FilesDownloadTask extends AsyncTask<Integer, Integer, Integer> {

    private Context context;

    public FilesDownloadTask(Context context) {
        this.context = context;
    }

    @Override
    protected void onPreExecute() {
        super.onPreExecute();
        if (mProgressDialog == null) {
            mProgressDialog = new ProgressDialog(context);
            mProgressDialog.setMessage(getString(R.string.downloading));
            mProgressDialog.setIndeterminate(true);
            mProgressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
            mProgressDialog.setCancelable(false);
            mProgressDialog.show();
        }
    }

    @Override
    protected Integer doInBackground(Integer... index) {

        int i = index[0];

        if (i < fileList.length) {
            if (!new File(path[i]).exists())
                doDownload(urls[i], path[i]);
        publishProgress(i);
        }

        return i++;
    }

    @Override
    protected void onProgressUpdate(Integer... progress) {
        super.onProgressUpdate(progress);
        mProgressDialog.setIndeterminate(false);
        mProgressDialog.setMax(fileList.length);
        mProgressDialog.setProgress(progress[0]);
    }

    @Override
    protected void onPostExecute(Integer nextIndex) {
        if (index < fileList.length)
            new FilesDownloadTask(context).execute((Integer) nextIndex);
        else
            mProgressDialog.dismiss();
    }

    @Override
    protected void onCancelled() {
        mProgressDialog.dismiss();
        super.onCancelled();
    }
}

需要建议新的AsyncTask递归调用

3 个答案: