此刻我有如下代码：
public class SomeActivity {
 void onCreate() {
  doSomething();
  if (weNeedToDoSomeAsncTask()) {
   new SomeAsyncTask(afterSomeAsyncTask).execute();
  } else {
   new DifferentAsyncTask(afterAnotherAsyncTask).execute();
  }
 }
 PostExecute afterSomeAsyncTask = new PostExecute() {
  void Callback(String response) {
   doSomethingElse(response);
   new DifferentAsyncTask(afterAnotherAsyncTask).execute();
  }
 }
}

public class SomeActivity {
 void onCreate() {
  doSomething();
  if (weNeedToDoSomeAsncTask()) {
   new SomeAsyncTask().execute();
   doSomethingElse(response);
  } 
  new DifferentAsyncTask().execute();
  afterAnotherAsyncTask();
 }
}

NetworkService networkService = new NetworkService();
Needle.onBackgroundThread().serially().execute(networkService);
String result = doSomethingWithResponse(networkService.response);
AnotherNetworkService anotherNetworkService = new AnotherNetworkService(result);
Needle.onBackgroundThread().serially().execute(anotherNetworkService);

<details>
<summary>英文:</summary>
At the moment I have something like;

This doesn't look too bad on the face of it, but I have hugely simplified the code and you can imagine how complex it becomes when you have more than a few calls going on and some branching starts to happen.
To help with context, the actual use case is normally something like;
 - use an sdk to get some device/user information
 - use the returned information to authenticate with a web service
 - send some logging info to the web service
 - get some data from the web service
 - get some other data from the web service
 - use that data to generate the UI
I would prefer my code to look a bit more like;

I have tried used `.get()` in the past and had issues but never got to the bottom of why (potentially I was trying to call one `AsyncTask` inside another, which I've read is a no go- but it was a long time ago so can't be sure). Whilst I realise `.get` somewhat defeats the object of `AsyncTask`, I am only using it because Java forces me to (for network communication etc). My application is relying on the result to continue and can't do anything else till it returns anyway.
Should I try the `.get()` technique again? Or is it a really bad idea?
Should I just suck it up and realise the code is harder to read and I will need to jump to the callback methods to try and understand the code flow?
Or is there a different option?
I have also just learnt of Needle which looks like quite a nice library https://zsoltsafrany.github.io/needle/ and I think I could do more like;

But perhaps this is exactly the same as the `AsyncTask.get()` approach?
</details>
# 答案1
**得分**: 1
Kotlin协程。
<details>
<summary>英文:</summary>
The TL;DR of any answer really will be: Kotlin coroutines.
</details>
# 答案2
**得分**: 1
以下是翻译好的部分：
看一下[ScheduledThreadPoolExecutor](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ScheduledExecutorService.html)，你可以这样获取它：
```java
ExecutorService executor = Executors.newScheduledThreadPool(8);

public class SomeActivity {
 void onCreate() {
  doSomething();
  if (weNeedToDoSomeAsncTask()) {
   executor.submit(() -> /* 异步任务 */);
   doSomethingElse(response);
  } 
  executor.submit(() -> /* 不同的异步任务 */)
  afterAnotherAsyncTask();
 }
}