Question

我有一个具有异步任务的方法，它从几个不同的服务调用，并且这些服务定期运行。我想确保当一个任务正在进行时，除非任务完成，否则没有其他任何东西可以调用它。

public class Helper {

    public static void doSomethingAsync() {
        new AsyncTask<String, Void, Integer>() {
            @Override
            protected void onPreExecute() {
            }

            @Override
            protected Integer doInBackground(String... strings) {
                //doing something
            }

            @Override
            protected void onPostExecute(Integer resultCode) {

            }
        }.execute();
    }

    public static void someOtherMethod(){

    }
}

Answer 1

AsyncTask.getStatus()将给出任务的状态，即是否已完成。

声明成员变量

private static AsyncTask<String, Void, Integer> mTask;

将您的方法修改为，

public static void doSomethingAsync() {

    if(null != mTask && mTask.getStatus() != AsyncTask.Status.FINISHED){
       return; //Returning as the current task execution  is not finished yet.
    }

    mTask = new AsyncTask<String, Void, Integer>() {
        @Override
        protected void onPreExecute() {
        }

        @Override
        protected Integer doInBackground(String... strings) {
            //doing something
        }

        @Override
        protected void onPostExecute(Integer resultCode) {

        }
    };
    mTask.execute();
}

Answer 2

确保您的所有服务都可以访问可在整个应用程序中访问的Mutex。

现在，在访问异步任务之前，请执行以下操作

public class Mutex {
   public void acquire() throws InterruptedException { }
   public void release() { }
   public boolean attempt(long msec) throws InterruptedException { }
}

然后可以用作：

try {
  mutex.acquire();
  try {
    // do something
  } finally {
    mutex.release();
  }
} catch(InterruptedException ie) {
  // ...
}

查看here

上的更多详情

在Android中我们有Semaphore。以下是步骤

java.util.concurrent.Semaphore semaphore=new Semaphore(1);

boolean isAvailable = semaphore.tryAcquire();
if(isAvailable){
    // Access AsyncTask
}

完成所有操作后，直到onPostExecute

 semaphore.release();

Answer 3

您可以将“doSomethingAsync（）”设为同步方法来尝试此操作。

public synchronized static void doSomethingAsync() {
        new AsyncTask<String, Void, Integer>() {
            @Override
            protected void onPreExecute() {
            }

            @Override
            protected Integer doInBackground(String... strings) {
                //doing something
            }

            @Override
            protected void onPostExecute(Integer resultCode) {
            }
        }.execute();
    }

注意：

静态同步方法将锁定类而不是对象，它将锁定类，因为关键字static表示：“类而不是实例”。关键字synchronized表示一次只能有一个线程访问该方法。他们在一起意味着：“一次只能有一个人上课”。

Answer 4

尝试使用IntentService，因为它支持排队并在后台线程中运行

Answer 5

你应该参考同步概念，它会对你有所帮助 Link

如何确保异步任务仅调用一次

5 个答案: