线程和进程

进程是独立的执行单元，是系统资源分配的基本单元；线程是进程内执行单元，是任务调度的基本单元进程切换开销大，线程开销相对小

根本区别：进程是操作系统资源分配的基本单位，而线程是任务调度和执行的基本单位

开销： 每个进程都有独立的代码和数据空间（程序上下文），程序之间的切换会有较大的开销；线程可以看做轻量级的进程，同一类线程共享代码和数据空间，每个线程都有自己独立的运行栈和程序计数器（PC），线程之间切换的开销小。
所处环境： 在操作系统中能同时运行多个进程（程序）；而在同一个进程（程序）中有多个线程同时执行（通过CPU调度，在每个时间片中只有一个线程执行）
内存分配： 系统在运行的时候会为每个进程分配不同的内存空间；而对线程而言，除了CPU外，系统不会为线程分配内存（线程所使用的资源来自其所属进程的资源），线程组之间只能共享资源。
包含关系： 没有线程的进程可以看做是单线程的，如果一个进程内有多个线程，则执行过程不是一条线的，而是多条线（线程）共同完成的；线程是进程的一部分，所以线程也被称为轻权进程或者轻量级进程。

进程

一个在内存中运行的应用程序。每个进程都有自己独立的一块内存空间，一个进程可以有多个线程，比如在Windows系统中，一个运行的xx.exe就是一个进程。

线程

进程中的一个执行任务（控制单元），负责当前进程中程序的执行。一个进程至少有一个线程，一个进程可以运行多个线程，多个线程可共享数据。

与进程不同的是同类的多个线程共享进程的堆和方法区资源，但每个线程有自己的程序计数器、虚拟机栈和本地方法栈，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。

public class MultiThread {
	public static void main(String[] args) {
		// 获取 Java 线程管理 MXBean
		ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
		// 不需要获取同步的 monitor 和 synchronizer 信息，仅获取线程和线程堆栈信息
		ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(false, false);
		// 遍历线程信息，仅打印线程 ID 和线程名称信息
		for (ThreadInfo threadInfo : threadInfos) {
			System.out.println("[" + threadInfo.getThreadId() + "] " + threadInfo.getThreadName());
		}
	}
}

上述程序输出如下（：

[6] Monitor Ctrl-Break //监听线程转储或“线程堆栈跟踪”的线程
[5] Attach Listener //负责接收到外部的命令，而对该命令进行执行的并且把结果返回给发送者
[4] Signal Dispatcher // 分发处理给 JVM 信号的线程
[3] Finalizer //在垃圾收集前，调用对象 finalize 方法的线程
[2] Reference Handler //用于处理引用对象本身（软引用、弱引用、虚引用）的垃圾回收的线程
[1] main //main 线程,程序入口

从上面的输出内容可以看出：一个 Java 程序的运行是 main 线程和多个其他线程同时运行。

进程与线程的区别

线程具有许多传统进程所具有的特征，故又称为轻型进程(Light—Weight Process)或进程元；而把传统的进程称为重型进程(Heavy—Weight Process)，它相当于只有一个线程的任务。在引入了线程的操作系统中，通常一个进程都有若干个线程，至少包含一个线程。

根本区别

进程是操作系统资源分配的基本单位，而线程是处理器任务调度和执行的基本单位

资源开销

每个进程都有独立的代码和数据空间（程序上下文），程序之间的切换会有较大的开销；线程可以看做轻量级的进程，同一类线程共享代码和数据空间，每个线程都有自己独立的运行栈和程序计数器（PC），线程之间切换的开销小。

包含关系

如果一个进程内有多个线程，则执行过程不是一条线的，而是多条线（线程）共同完成的；线程是进程的一部分，所以线程也被称为轻权进程或者轻量级进程。

内存分配

同一进程的线程共享本进程的地址空间和资源，而进程之间的地址空间和资源是相互独立的

影响关系

一个进程崩溃后，在保护模式下不会对其他进程产生影响，但是一个线程崩溃整个进程都死掉。所以多进程要比多线程健壮。

执行过程

每个独立的进程有程序运行的入口、顺序执行序列和程序出口。但是线程不能独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制，两者均可并发执行

异步任务与协程

异步任务（AsyncTask）曾是处理后台任务并更新 UI 的常用方式之一。通过继承 AsyncTask 抽象类，并重写 doInBackground 和 onPostExecute 等方法来实现。doInBackground 方法在后台线程执行耗时操作，例如网络请求、文件读取等，而 onPostExecute 则在主线程处理结果并更新 UI。

然而，当面临多个连续的异步操作时，AsyncTask 容易产生 “地狱回调” 问题。

以一个常见的场景为例，我们需要先从网络获取用户信息，再根据用户信息获取其文章列表

异步任务

// 模拟从网络获取用户信息的AsyncTask
class GetUserInfoTask(private val userId: String, private val callback: (User?) -> Unit) : AsyncTask<Void, Void, User?>() {
    override fun doInBackground(vararg params: Void?): User? {
        // 这里模拟耗时网络请求，实际中可能是通过HttpURLConnection等发起请求
        Thread.sleep(2000)
        return User(userId, "John Doe")
    }

    override fun onPostExecute(result: User?) {
        super.onPostExecute(result)
        callback(result)
    }
}

// 模拟根据用户ID获取该用户文章列表的AsyncTask
class GetUserArticlesTask(private val userId: String, private val callback: (List<Article>?) -> Unit) : AsyncTask<Void, Void, List<Article>?)() {
    override fun doInBackground(vararg params: Void?): List<Article>? {
        // 模拟网络请求获取文章列表，耗时操作
        Thread.sleep(2000)
        return listOf(Article("Article 1", "Content 1"), Article("Article 2", "Content 2"))
    }

    override fun onPostExecute(result: List<Article>?) {
        super.onPostExecute(result)
        callback(result)
    }
}

data class User(val id: String, val name: String)
data class Article(val title: String, val content: String)

使用上述 AsyncTask 实现获取用户信息以及对应的文章列表，代码如下：

GetUserInfoTask("123") { user ->
    if (user!= null) {
        GetUserArticlesTask(user.id) { articles ->
            if (articles!= null) {
                // 在这里处理获取到的用户文章列表，比如展示到UI等
                articles.forEach { article ->
                    println("文章标题: ${article.title}")
                }
            }
        }.execute()
    }
}.execute()

为了在获取用户信息后进一步获取其文章列表，不得不将获取文章列表的 AsyncTask 嵌套在获取用户信息的 AsyncTask 的回调中。如果后续还有更多基于文章列表的异步操作，例如获取文章的点赞数、评论数等，代码将会陷入更深层次的嵌套回调。这种嵌套结构使得代码的逻辑流程难以理解和维护，代码的可读性急剧下降，调试也变得困难重重，这就是 “地狱回调” 带来的困扰。

协程

协程是一种轻量级的异步编程模型，在 Kotlin 中得到了很好的支持。它通过挂起函数（suspend function）来实现异步操作，允许以顺序的代码风格编写异步逻辑，而无需复杂的回调嵌套。

// 模拟从网络获取用户信息的挂起函数
suspend fun getUserInfo(userId: String): User {
    // 模拟网络请求耗时，使用delay模拟
    delay(2000)
    return User(userId, "John Doe")
}

// 模拟根据用户ID获取该用户文章列表的挂起函数
suspend fun getUserArticles(userId: String): List<Article> {
    delay(2000)
    return listOf(Article("Article 1", "Content 1"), Article("Article 2", "Content 2"))
}

suspend fun getAndProcessUserData() = coroutineScope {
    val user = getUserInfo("123")
    val articlesDeferred = async(Dispatchers.IO) {
        getUserArticles(user.id)
    }
    val articles = articlesDeferred.await()
    articles.forEach { article ->
        println("文章标题: ${article.title}")
    }
}

getUserInfo 和 getUserArticles 函数被定义为挂起函数，使用 delay 模拟网络请求的耗时操作。getAndProcessUserData 函数则在协程作用域内，先顺序地调用 getUserInfo 获取用户信息，然后使用 async 函数并发地获取用户文章列表，并通过 await 等待结果，最后处理文章列表数据。

最后，在合适的协程作用域中调用 getAndProcessUserData 函数，例如在 Activity 的 onCreate 方法中（假设已配置好协程相关的生命周期感知）：

class MainActivity : AppCompatActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
		super.onCreate(savedInstanceState)

		val mainScope = MainScope()
		mainScope.launch {
			getAndProcessUserData()
		}
	}
}