25 并发编程之线程基础

在上一篇中，我们探讨了 Scala 中的异常处理，特别是如何创建自定义异常以增强代码的健壮性。在本篇中，我们将深入了解 Scala 的并发编程基础，特别是线程的使用。掌握线程的基本知识是学习并发编程的第一步，这将为我们下一篇关于并发工具的深入探讨打下基础。

1. 理解线程

1.1 什么是线程？

线程是操作系统能够进行运算调度的最小单元。一个进程可以包含多个线程，线程之间共享进程的资源，比如内存、文件等，因而可以更高效地执行任务。

1.2 在 Scala 中创建线程

Scala 通过 Thread 类来支持多线程编程。我们可以通过 new Thread 来创建一个新的线程。在线程中，我们通常会重写 run 方法，定义线程的执行任务。

1.3 创建线程的基本示例

下面是一个简单的例子，展示如何创建并启动一个线程：

object ThreadExample {
  def main(args: Array[String]): Unit = {
    // 创建一个线程
    val thread = new Thread(new Runnable {
      def run(): Unit = {
        for (i <- 1 to 5) {
          println(s"线程执行：$i")
          Thread.sleep(1000) // 模拟耗时操作
        }
      }
    })

    // 启动线程
    thread.start()

    // 主线程继续执行
    for (i <- 1 to 5) {
      println(s"主线程执行：$i")
      Thread.sleep(800)
    }

    // 等待线程结束
    thread.join()
    println("线程已结束")
  }
}

在这个示例中，我们创建了一个线程并在其中执行简单的循环，主线程同时也在执行自己的任务。我们使用 thread.join() 来确保主线程在子线程结束后才继续执行。

2. 线程的基本操作

在 Scala 中，线程对象提供了一些基本的方法，我们可以用来控制线程的执行。

2.1 启动线程

使用 start() 方法来启动线程。

2.2 线程休眠

通过 Thread.sleep(milliseconds) 方法，我们可以让当前线程休眠指定的毫秒数，从而模拟耗时的操作。

2.3 线程等待

使用 join() 方法可以等待某个线程完成。主线程会在调用 join() 的位置阻塞，直到被阻塞的线程执行完毕。

2.4 线程优先级

可以通过 setPriority(int) 方法设置线程的优先级（范围从 Thread.MIN_PRIORITY 到 Thread.MAX_PRIORITY），优先级高的线程会获得更多的 CPU 时间。

3. 线程安全

在并发编程中，我们常常面临数据竞争的问题，因此理解线程安全至关重要。以下是一些常见的方法来确保线程安全：

3.1 使用 synchronized

我们可以使用 synchronized 关键字来控制对共享资源的访问。示例如下：

class Counter {
  private var count = 0

  def increment(): Unit = synchronized {
    count += 1
  }

  def getCount: Int = synchronized {
    count
  }
}

在这个示例中，increment 和 getCount 方法都是线程安全的，任何时候只有一个线程能够执行这些方法。

3.2 使用 Atomic 类

Scala 和 Java 提供了一些原子操作类，比如 AtomicInteger，它们可以帮助我们处理基本的数据类型的线程安全问题。示例如下：

import java.util.concurrent.atomic.AtomicInteger

object AtomicExample {
  def main(args: Array[String]): Unit = {
    val counter = new AtomicInteger(0)

    val threads = (1 to 10).map(_ => new Thread(new Runnable {
      def run(): Unit = {
        for (_ <- 1 to 1000) {
          counter.incrementAndGet()
        }
      }
    }))

    // 启动所有线程
    threads.foreach(_.start())
    // 等待所有线程结束
    threads.foreach(_.join())

    println(s"最终计数：${counter.get()}")
  }
}

在这个例子中，我们使用 AtomicInteger 来安全地增加计数器的值。在 10 个线程中，每个线程增加 1000 次计数器，最终我们获取到的值应该是 10000。

4. 小结

在本篇中，我们学习了Scala中的线程基础，包括如何创建线程、基本线程操作和保证线程安全的方法。理解这些基础知识不仅能够帮助我们编写更高效的代码，也为后续的并发工具使用打下了坚实的基础。在下一篇中，我们将探讨更高级的并发工具，帮助我们更好地管理并发执行的复杂性。

请继续关注系列教程，掌握 Scala 的并发编程全貌。