Android 异步转同步有哪些方法（Java）

在Android中，实现异步转同步有以下几种方法：

1. 使用线程的join方法：可以创建一个新的线程，在新线程中执行耗时操作，然后在主线程中调用join方法，等待该线程执行完毕。这样主线程就会阻塞，直到新线程执行完毕，实现异步转同步。

public class MainActivity extends AppCompatActivity {

    private Thread asyncThread;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 创建子线程
        asyncThread = new Thread(new Runnable() {
            @Override
            public void run() {
                // 执行异步操作
                // ...

                // 操作完成后发送消息
                handler.sendEmptyMessage(0);
            }
        });

        // 启动子线程
        asyncThread.start();
    }

    private Handler handler = new Handler(new Handler.Callback() {
        @Override
        public boolean handleMessage(Message msg) {
            // 在主线程中处理操作完成后的逻辑
            // ...

            return true;
        }
    });

    @Override
    protected void onResume() {
        super.onResume();

        try {
            // 等待子线程执行完成
            asyncThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 子线程执行完成后的逻辑
        // ...
    }
}

在上面的代码中，子线程执行异步操作后，通过 handler 发送一个空消息到主线程。主线程中的 handler 处理消息后，可以在 handleMessage() 方法中处理操作完成后的逻辑。

在 onResume() 方法中，我们调用 asyncThread.join() 来等待子线程执行完成。这将阻塞主线程，直到子线程执行完成。执行完 join() 之后，可以在注释部分处理子线程执行完成后的逻辑。

2. 使用Handler的sendMessage和sendMessageSync方法：可以在异步线程中使用sendMessage方法发送消息到主线程，在主线程中使用Handler处理该消息。如果需要等待异步线程执行完毕，可以使用sendMessageSync方法，该方法会等待消息处理完毕才返回。

• 创建一个Handler对象，并重写其handleMessage方法。在handleMessage方法中处理异步任务完成后的逻辑。

Handler handler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
        // 处理异步任务完成后的逻辑
    }
};

• 在异步任务中调用Handler的sendMessage方法发送消息。

new Thread(new Runnable() {
    @Override
    public void run() {
        // 执行异步任务
        // ...

        // 异步任务完成后发送消息
        Message message = new Message();
        message.obj = result; // 将异步任务的结果赋值给消息的obj字段
        handler.sendMessage(message);
    }
}).start();

• 使用sendMessageSync方法实现等待异步任务完成并获取结果的功能。

private Object getResultSync() {
    Handler handler = new Handler();
    Message message = handler.sendMessageSync(new Message());
    return message.obj; // 获取异步任务的结果
}

在上述代码中，getResultSync方法会在调用sendMessageSync方法后阻塞，直到异步任务完成并发送消息后，才会继续执行并返回异步任务的结果。

 3. 使用CountDownLatch：可以在主线程中创建一个CountDownLatch对象，并设置初始计数值为1。在异步线程中执行完耗时操作后，调用CountDownLatch的countDown方法，主线程调用await方法等待计数值变为0，然后继续执行。

import java.util.concurrent.CountDownLatch;

public class MainActivity extends AppCompatActivity {
    private CountDownLatch countDownLatch;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        countDownLatch = new CountDownLatch(1);

        // 创建一个子线程执行耗时操作
        new Thread(new Runnable() {
            @Override
            public void run() {
                // 模拟耗时操作
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 完成耗时操作后调用countDown()
                countDownLatch.countDown();
            }
        }).start();

        // 主线程等待子线程完成操作
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 子线程完成操作后继续执行下一步操作
        Toast.makeText(this, "耗时操作已完成", Toast.LENGTH_SHORT).show();
    }
}

 4. 使用AsyncTask：可以继承AsyncTask类，在doInBackground方法中执行耗时操作，然后在onPostExecute方法中处理结果。在主线程中可以调用get方法等待异步操作执行完毕。

public class MyAsyncTask extends AsyncTask<Void, Void, String> {

    @Override
    protected String doInBackground(Void... voids) {
        // 执行耗时操作，如网络请求等
        // 返回任务结果
        return "Hello, World!";
    }

    @Override
    protected void onPostExecute(String result) {
        // 处理任务执行完毕后的结果
        // 可以通过回调等方式将结果返回给调用者
        Log.d("AsyncTask", result);
    }
}

// 在需要异步转同步的地方调用
MyAsyncTask task = new MyAsyncTask();
task.execute();

5. 使用Future和Callable：可以在异步线程中使用Callable接口执行耗时操作，并返回Future对象。在主线程中可以调用Future的get方法等待异步操作执行完毕。

1. 创建一个Callable对象，该对象的call()方法中包含需要在异步线程中执行的逻辑。
2. 使用ExecutorService的submit()方法提交Callable对象，获得一个Future对象。
3. 调用Future对象的get()方法，该方法会阻塞当前线程，直到异步线程执行完成并返回结果。
4. 获取异步线程的执行结果，进行后续处理。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class AsyncToSyncExample {
    public static void main(String[] args) throws Exception {
        // 创建一个线程池
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        
        // 创建一个Callable对象
        Callable<String> callable = new MyCallable();
        
        // 提交Callable对象，获得一个Future对象
        Future<String> future = executorService.submit(callable);
        
        // 阻塞当前线程，直到异步线程执行完成并返回结果
        String result = future.get();
        
        // 打印结果
        System.out.println("异步线程执行结果：" + result);
        
        // 关闭线程池
        executorService.shutdown();
    }
}

class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        // 模拟耗时操作
        Thread.sleep(3000);
        
        return "Hello, World!";
    }
}

上述代码中，我们通过ExecutorService的submit()方法将MyCallable对象提交给线程池，获得一个Future对象。然后，我们调用Future对象的get()方法阻塞当前线程，直到异步线程执行完成并返回结果。最后，我们获取异步线程的执行结果并进行后续处理。 

以上几种方法都可以实现异步转同步，具体使用哪种方法取决于具体的需求和场景。