线程与线程锁-CSDN博客

本文链接：https://blog.csdn.net/blue_msboy/article/details/146117629

线程和线程锁是并发编程中的核心概念。理解线程的工作原理以及如何使用线程锁来管理并发访问共享资源，对于编写高效、安全的并发程序至关重要。以下是线程与线程锁的机制原理与使用的详细说明。

1. 线程的基本概念

1.1 什么是线程？

线程是操作系统能够进行运算调度的最小单位，是进程中的一个执行单元。
一个进程可以包含多个线程，线程共享进程的内存空间和资源。

1.2 线程的生命周期

新建（New）：线程对象被创建，但尚未启动。
就绪（Runnable）：线程已经启动，等待 CPU 调度执行。
运行（Running）：线程正在执行。
阻塞（Blocked）：线程因为某些原因（如等待锁、I/O 操作）暂时停止执行。
终止（Terminated）：线程执行完毕或被强制终止。

1.3 创建线程的方式

继承 Thread 类：

class MyThread extends Thread {
    public void run() {
        System.out.println("Thread is running");
    }
}

MyThread thread = new MyThread();
thread.start();

实现 Runnable 接口：

class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Thread is running");
    }
}

Thread thread = new Thread(new MyRunnable());
thread.start();

实现 Callable 接口（配合 FutureTask 使用）：

class MyCallable implements Callable<String> {
    public String call() {
        return "Task result";
    }
}

FutureTask<String> futureTask = new FutureTask<>(new MyCallable());
Thread thread = new Thread(futureTask);
thread.start();
String result = futureTask.get(); // 获取任务执行结果

2. 线程锁的机制原理

2.1 为什么需要线程锁？

在多线程环境下，多个线程可能同时访问和修改共享资源，导致数据不一致或竞态条件（Race Condition）。
线程锁用于确保同一时刻只有一个线程可以访问共享资源，从而保证数据的一致性。

2.2 线程锁的类型

内置锁（Synchronized）：

使用 synchronized 关键字实现。
可以修饰方法或代码块。

示例：

public synchronized void method() {
    // 同步代码
}

public void method() {
    synchronized (this) {
        // 同步代码块
    }
}

显式锁（ReentrantLock）：
- 使用 java.util.concurrent.locks.ReentrantLock 实现。
- 提供了比 synchronized 更灵活的锁机制，如可中断锁、公平锁等。
- 示例：
```
ReentrantLock lock = new ReentrantLock();
lock.lock();
try {
    // 同步代码
} finally {
    lock.unlock();
}
```

2.3 锁的机制

可重入性：
- 同一个线程可以多次获取同一个锁，避免死锁。
- synchronized 和 ReentrantLock 都是可重入锁。
公平性：
- 公平锁按照线程请求锁的顺序分配锁，避免线程饥饿。
- ReentrantLock 可以通过构造函数指定是否为公平锁。

条件变量：

使用 Condition 对象可以实现线程的等待和唤醒机制。

示例：

ReentrantLock lock = new ReentrantLock();
Condition condition = lock.newCondition();

lock.lock();
try {
    condition.await(); // 线程等待
    condition.signal(); // 唤醒等待的线程
} finally {
    lock.unlock();
}

3. 线程锁的使用场景

3.1 同步方法

使用 synchronized 修饰方法，确保同一时刻只有一个线程可以执行该方法。

示例：

public synchronized void increment() {
    count++;
}

3.2 同步代码块

使用 synchronized 修饰代码块，确保同一时刻只有一个线程可以执行该代码块。

示例：

public void increment() {
    synchronized (this) {
        count++;
    }
}

3.3 显式锁

使用 ReentrantLock 实现更灵活的锁机制。

示例：

ReentrantLock lock = new ReentrantLock();
public void increment() {
    lock.lock();
    try {
        count++;
    } finally {
        lock.unlock();
    }
}

3.4 读写锁

使用 ReentrantReadWriteLock 实现读写分离，提高并发性能。

示例：

ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
public void read() {
    lock.readLock().lock();
    try {
        // 读操作
    } finally {
        lock.readLock().unlock();
    }
}

public void write() {
    lock.writeLock().lock();
    try {
        // 写操作
    } finally {
        lock.writeLock().unlock();
    }
}