Android Java 创建新线程

在 Android 开发中，处理多线程是一个非常重要的课题，因为 UI 线程会阻塞用户交互，如果执行耗时操作（如网络请求、文件读写等）在主线程中，会导致应用响应迟钝、甚至 ANR（Application Not Responding）。为了解决这些问题，Android 提供了多种方式来创建和管理线程。本文将详细介绍如何在 Android 中创建新线程，配合示例代码与类图进行讲解。

线程基础

在 Java 中，线程是并发执行的基本单位。每个线程都可以独立地执行任务。创建线程的方式有两种：继承 Thread 类或实现 Runnable 接口。在 Android 开发中，通常推荐使用 Runnable 接口，这样可以更好地与其他类配合。

1. 继承 Thread 类

通过继承 Thread 类，可以重写 run 方法，并在此方法中定义线程执行的任务。

public class MyThread extends Thread {
    @Override
    public void run() {
        // 执行的任务
        for (int i = 0; i < 5; i++) {
            System.out.println("MyThread: " + i);
            try {
                Thread.sleep(1000); // 暂停1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.

在主线程中创建并启动这个线程：

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        MyThread myThread = new MyThread();
        myThread.start(); // 启动新线程
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
2. 实现 Runnable 接口

实现 Runnable 接口是更为灵活的方案，它允许将任务作为参数传递给 Thread 类的构造函数。

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("MyRunnable: " + i);
            try {
                Thread.sleep(1000); // 暂停1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.

然后在主线程中创建并启动：

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Thread thread = new Thread(new MyRunnable());
        thread.start(); // 启动新线程
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
3. 使用 AsyncTask（已被弃用）

在 Android 中，AsyncTask 是一种便捷的创建和管理线程的方式，然而它从 Android 11 开始被弃用，使用时需注意。

public class MyAsyncTask extends AsyncTask<Void, Void, Void> {
    @Override
    protected Void doInBackground(Void... voids) {
        // 在此进行耗时操作，如网络请求
        for (int i = 0; i < 5; i++) {
            System.out.println("MyAsyncTask: " + i);
            try {
                Thread.sleep(1000); // 暂停1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    @Override
    protected void onPostExecute(Void aVoid) {
        // 任务完成后在UI线程更新UI
        System.out.println("任务完成");
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.

在主线程中启动 AsyncTask：

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        new MyAsyncTask().execute(); // 执行 AsyncTask
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
4. 使用 ExecutorService

ExecutorService 提供了一种更高级别的线程管理方式，可以管理线程池。

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

public class MainActivity extends AppCompatActivity {
    private ExecutorService executorService;

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

        // 创建一个固定大小的线程池
        executorService = Executors.newFixedThreadPool(2);
        
        // 提交任务
        executorService.submit(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("ExecutorService: " + i);
                try {
                    Thread.sleep(1000); // 暂停1秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }
    
    @Override
    protected void onDestroy() {
        super.onDestroy();
        executorService.shutdown(); // 关闭线程池
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.

类图

下面是创建新线程的类图，展示了不同线程实现方式的关系：

MainActivity +onCreate(Bundle savedInstanceState) +onDestroy() MyThread +run() MyRunnable +run() MyAsyncTask +doInBackground(Void... voids) +onPostExecute(Void aVoid) ExecutorService +submit(Runnable task) +shutdown()

总结

在 Android 中创建新线程是为了避免阻塞 UI 线程，提高用户体验。我们可以选择不同的方法来实现多线程，如继承 Thread 类、实现 Runnable 接口、使用 AsyncTask（虽然已被弃用）和 ExecutorService。每种方法都有其优缺点，开发者可以根据具体的需求与场景选择合适的方案。

通过本文的介绍，相信你已经对如何在 Android 应用中创建和管理线程有了更清晰的认识。希望能在你的 Android 开发中助你一臂之力！