Java 线程服务。延迟后如何重新启动一些线程？

我试图用处理程序实现这一点，但我的处理程序希望是静态的，所以我不能使用

startThread

方法

我是汉德勒

private class ServiceHandler extends Handler {
    @Override
    public void handleMessage(Message msg) {
        Integer tmp = msg.what;
        Log.d(Tag, tmp.toString());
        switch (msg.what) {
        case THREAD_SYNC_START:
            startSyncThread();
            break;
        case THREAD_SYNC_STOP:
            mSyncThread.interrupt();
            break;
        default:
            break;
        }
    }
}

这是我的服务启动线程的方法

private void startSyncThread() {
    if (mSyncThread != null) mSyncThread.interrupt();
    mSyncThread = new SyncThread();
    mSyncThread.start();
}

线程向处理程序发送消息

        mServiceHandler.sendEmptyMessageDelayed(THREAD_SYNC_START, 2000);

---

我不需要任何泄漏，所以我正在寻找执行此任务的正确方法。

我编写了一些示例代码，您可以在其中使用AsyncTask，并让它回调以确定是否应该创建新的AsyncTask。如果是错的，请告诉我

测试片段：

public class TestFragment extends Fragment {
    private Handler mHandler;

    /*
     * Skipping most code and I will only show you the most essential.
     */

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        mHandler = new Handler();

        startAsyncTask(0);
    }

    private void startAsyncTask(long milisecondsToDelay) {
        mHandler.postDelayed(new Runnable() {

            @Override
            public void run() {
                TestAsyncTask testAsyncTask = new TestAsyncTask(new FragmentCallback() {

                    @Override
                    public void onTaskDone() {
                        startAsyncTask(1000);
                    }
                });

                testAsyncTask.execute();
            }
        }, milisecondsToDelay);

    }

    public interface FragmentCallback {
        public void onTaskDone();
    }
}

TestAsyncTask：

public class TestAsyncTask extends AsyncTask<Void, Void, Void> {
    private boolean mShouldCreateNewAsyncTask;
    private FragmentCallback mFragmentCallback;

    public TestAsyncTask(FragmentCallback fragmentCallback) {
        mFragmentCallback = fragmentCallback;
    }

    @Override
    protected Void doInBackground(Void... params) {
        /*
         * Do your loop or whatever and when you need to restart it set
         * mShouldCreateNewAsyncTask = true and return null.
         */

        mShouldCreateNewAsyncTask = true;

        return null;
    }

    @Override
    protected void onPostExecute(Void result) {
        if (mShouldCreateNewAsyncTask) {
            mFragmentCallback.onTaskDone();
        }
    }
}

公共类TestAsyncTask扩展了AsyncTask{
私有布尔mShouldCreateNewAsyncTask；
私有碎片回调MFFragmentCallback；
公共TestAsyncTask（碎片回调碎片回调）{
MFFragmentCallback=片段回调；
}
@凌驾
受保护的Void doInBackground（Void…参数）{
/*
*在需要重新启动时执行循环或其他操作
*mShouldCreateNewAsyncTask=true并返回null。
*/
mShouldCreateNewAsyncTask=true；
返回null；
}
@凌驾
受保护的void onPostExecute（void结果）{
if（mShouldCreateNewAsyncTask）{
MFFragmentCallback.onTaskDone（）；
}
}
}

我编写了一些示例代码，其中您使用了一个AsyncTask，并让它回调以确定是否应该创建一个新的AsyncTask。如果是错的，请告诉我

测试片段：

public class TestFragment extends Fragment {
    private Handler mHandler;

    /*
     * Skipping most code and I will only show you the most essential.
     */

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        mHandler = new Handler();

        startAsyncTask(0);
    }

    private void startAsyncTask(long milisecondsToDelay) {
        mHandler.postDelayed(new Runnable() {

            @Override
            public void run() {
                TestAsyncTask testAsyncTask = new TestAsyncTask(new FragmentCallback() {

                    @Override
                    public void onTaskDone() {
                        startAsyncTask(1000);
                    }
                });

                testAsyncTask.execute();
            }
        }, milisecondsToDelay);

    }

    public interface FragmentCallback {
        public void onTaskDone();
    }
}

TestAsyncTask：

public class TestAsyncTask extends AsyncTask<Void, Void, Void> {
    private boolean mShouldCreateNewAsyncTask;
    private FragmentCallback mFragmentCallback;

    public TestAsyncTask(FragmentCallback fragmentCallback) {
        mFragmentCallback = fragmentCallback;
    }

    @Override
    protected Void doInBackground(Void... params) {
        /*
         * Do your loop or whatever and when you need to restart it set
         * mShouldCreateNewAsyncTask = true and return null.
         */

        mShouldCreateNewAsyncTask = true;

        return null;
    }

    @Override
    protected void onPostExecute(Void result) {
        if (mShouldCreateNewAsyncTask) {
            mFragmentCallback.onTaskDone();
        }
    }
}

公共类TestAsyncTask扩展了AsyncTask{
私有布尔mShouldCreateNewAsyncTask；
私有碎片回调MFFragmentCallback；
公共TestAsyncTask（碎片回调碎片回调）{
MFFragmentCallback=片段回调；
}
@凌驾
受保护的Void doInBackground（Void…参数）{
/*
*在需要重新启动时执行循环或其他操作
*mShouldCreateNewAsyncTask=true并返回null。
*/
mShouldCreateNewAsyncTask=true；
返回null；
}
@凌驾
受保护的void onPostExecute（void结果）{
if（mShouldCreateNewAsyncTask）{
MFFragmentCallback.onTaskDone（）；
}
}
}

为什么要构建自己的处理程序？AsyncTask是否不适合您的需要？@SimonZettervall在dalay之后如何重新启动AsyncTask？在我的例子中，“线程向处理程序发送消息”->“处理程序重新启动线程”，这取决于您“重新启动”。线程中没有这样的东西。您可以启动新线程、暂停线程或停止/完成线程。恢复操作取决于您的代码。当线程停止（应用暂停）时，必须存储迄今为止计算的数据。在开始时，再次将该数据传递给线程。您的算法必须跳过已处理的部分，才能从上次停止时开始继续。@Pihhan我需要启动线程，它正在做一些事情，停止，然后在一段时间后自动服务，再次启动此线程。服务如何在延迟后启动线程？默认情况下，处理程序将当前线程配置为消息的目标。然后可以使用handler.runDelayed（newrunnable（）{this.StartNewThread（）；}，2000）；这将立即继续，两秒钟后将从当前线程开始runnable。使用AsyncTask在新线程中启动计算。您可以使用AsyncTask.cancel（）方法，只需保留对它的引用即可。在onCancelled（）中，您可以再次使用处理程序来runDelayed（）。为什么要构建自己的处理程序？AsyncTask是否不适合您的需要？@SimonZettervall在dalay之后如何重新启动AsyncTask？在我的例子中，“线程向处理程序发送消息”->“处理程序重新启动线程”，这取决于您“重新启动”。线程中没有这样的东西。您可以启动新线程、暂停线程或停止/完成线程。恢复操作取决于您的代码。当线程停止（应用暂停）时，必须存储迄今为止计算的数据。在开始时，再次将该数据传递给线程。您的算法必须跳过已处理的部分，才能从上次停止时开始继续。@Pihhan我需要启动线程，它正在做一些事情，停止，然后在一段时间后自动服务，再次启动此线程。服务如何在延迟后启动线程？默认情况下，处理程序将当前线程配置为消息的目标。然后可以使用handler.runDelayed（newrunnable（）{this.StartNewThread（）；}，2000）；这将立即继续，两秒钟后将从当前线程开始runnable。使用AsyncTask在新线程中启动计算。您可以使用AsyncTask.cancel（）方法，只需保留对它的引用即可。从onCancelled（）可以再次使用handler to runDelayed（）。是的，这可以解决这个问题，但我用正确的方法编写了handler是的，这可以解决这个问题，但我用正确的方法编写了handler