在Android中如何执行多个线程

西瓜本瓜@

于 2024-08-06 20:22:05 发布

阅读量281

点赞数 6

文章标签： android 开发语言 java

本文链接：https://blog.csdn.net/LLZjiayou/article/details/140965212

版权

方法 1: 使用 Thread 类

方法 2: 使用 Runnable 接口

方法 3: 使用 ExecutorService

方法 4: 使用 HandlerThread

方法 5: 使用 AsyncTask（已弃用）

总结

在Android中执行多个线程，可以使用Java提供的多线程机制。Android中常见的多线程实现方法包括使用Thread类、Runnable接口、ExecutorService、AsyncTask（已弃用）、HandlerThread等。以下是几种方法的详细Java代码示例，附带中文注释。

方法 1: 使用 `Thread` 类

使用 Thread 类直接创建并启动线程是最基础的方法。

public class MultiThreadExample {

    public static void main(String[] args) {
        // 创建第一个线程
        Thread thread1 = new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("Thread 1 - Count: " + i);
                    try {
                        Thread.sleep(1000); // 线程休眠1秒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };

        // 创建第二个线程
        Thread thread2 = new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("Thread 2 - Count: " + i);
                    try {
                        Thread.sleep(1500); // 线程休眠1.5秒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };

        // 启动线程
        thread1.start();
        thread2.start();
    }
}

方法 2: 使用 `Runnable` 接口

Runnable 接口常用于需要实现 run() 方法但不需要继承 Thread 类的场景。

public class MultiThreadExample {

    public static void main(String[] args) {
        // 创建第一个 Runnable 对象
        Runnable runnable1 = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("Runnable 1 - Count: " + i);
                    try {
                        Thread.sleep(1000); // 线程休眠1秒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };

        // 创建第二个 Runnable 对象
        Runnable runnable2 = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("Runnable 2 - Count: " + i);
                    try {
                        Thread.sleep(1500); // 线程休眠1.5秒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };

        // 使用 Thread 类启动线程
        Thread thread1 = new Thread(runnable1);
        Thread thread2 = new Thread(runnable2);

        // 启动线程
        thread1.start();
        thread2.start();
    }
}

方法 3: 使用 `ExecutorService`

ExecutorService 是一个更高级的线程池管理工具，可以更方便地管理多个线程。

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

public class MultiThreadExample {

    public static void main(String[] args) {
        // 创建一个具有固定线程数的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(2);

        // 创建第一个 Runnable 任务
        Runnable task1 = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("Task 1 - Count: " + i);
                    try {
                        Thread.sleep(1000); // 任务休眠1秒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };

        // 创建第二个 Runnable 任务
        Runnable task2 = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("Task 2 - Count: " + i);
                    try {
                        Thread.sleep(1500); // 任务休眠1.5秒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };

        // 提交任务给线程池执行
        executorService.submit(task1);
        executorService.submit(task2);

        // 关闭线程池（任务执行完毕后）
        executorService.shutdown();
    }
}

方法 4: 使用 `HandlerThread`

HandlerThread 是Android中特有的一种线程类，通常用于在后台线程中处理消息队列。

import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;

public class MultiThreadExample {

    public static void main(String[] args) {
        // 创建一个 HandlerThread
        HandlerThread handlerThread1 = new HandlerThread("HandlerThread-1");
        HandlerThread handlerThread2 = new HandlerThread("HandlerThread-2");

        // 启动 HandlerThread
        handlerThread1.start();
        handlerThread2.start();

        // 创建 Handler 与 HandlerThread 关联
        Handler handler1 = new Handler(handlerThread1.getLooper());
        Handler handler2 = new Handler(handlerThread2.getLooper());

        // 使用 Handler 在对应的线程上执行任务
        handler1.post(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("HandlerThread 1 - Count: " + i);
                    try {
                        Thread.sleep(1000); // 任务休眠1秒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        handler2.post(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("HandlerThread 2 - Count: " + i);
                    try {
                        Thread.sleep(1500); // 任务休眠1.5秒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        // 任务执行完毕后可以关闭 HandlerThread
        handlerThread1.quitSafely();
        handlerThread2.quitSafely();
    }
}

方法 5: 使用 `AsyncTask`（已弃用）

AsyncTask 在Android中的使用已被弃用，但在旧版中仍然可以用于执行简单的后台任务。推荐使用 ExecutorService 代替。

import android.os.AsyncTask;

public class MultiThreadExample {

    public static void main(String[] args) {
        // 创建并执行第一个异步任务
        new MyAsyncTask("Task 1").execute();

        // 创建并执行第二个异步任务
        new MyAsyncTask("Task 2").execute();
    }

    // 自定义的 AsyncTask 类
    private static class MyAsyncTask extends AsyncTask<Void, Void, Void> {
        private String taskName;

        public MyAsyncTask(String taskName) {
            this.taskName = taskName;
        }

        @Override
        protected Void doInBackground(Void... voids) {
            for (int i = 0; i < 5; i++) {
                System.out.println(taskName + " - Count: " + i);
                try {
                    Thread.sleep(1000); // 任务休眠1秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return null;
        }
    }
}

总结

在Android中执行多个线程，可以根据需求选择不同的实现方法。Thread 和 Runnable 是最基础的方法，而 ExecutorService 提供了更强大的线程池管理能力。HandlerThread 是Android中特有的，用于处理后台消息队列。AsyncTask 已被弃用，但在旧版中仍然可以使用。选择合适的方法可以更好地满足应用的需求和性能要求。