Java多线程并发控制：使用synchronized关键字实现互斥访问

1. 理解多线程并发中的挑战

在多线程编程中，当多个线程同时访问或修改共享资源时，可能会出现竞态条件（race condition），导致数据不一致或操作中断。例如，一个线程正在执行一个多步操作（如打印一条完整的日志信息），而另一个线程突然插入并执行自己的操作，就会导致输出混乱或不完整。开发者有时会尝试通过设置线程优先级来解决这类问题，期望高优先级的线程能够优先完成其任务而不被中断。然而，线程优先级在java中通常不可靠，其行为高度依赖于底层操作系统和jvm实现，并不能保证严格的执行顺序或互斥访问。

2. 线程优先级的局限性

Java提供了Thread.setPriority()方法来设置线程的优先级，范围从Thread.MIN_PRIORITY到Thread.MAX_PRIORITY。理论上，高优先级的线程会比低优先级的线程获得更多的CPU时间片。然而，在实际应用中，线程优先级存在以下局限：

• 平台依赖性： 线程优先级在不同操作系统上的实现差异很大。某些操作系统可能完全忽略Java设置的优先级，或者只支持有限的优先级级别映射。
• 非确定性： 即使在支持优先级的系统上，也不能保证高优先级线程总是先于低优先级线程执行，或者不会被中断。它更多的是一种调度提示，而非严格的执行保证。
• 无法解决互斥问题： 优先级无法阻止两个线程同时进入临界区，从而无法解决竞态条件问题。它仅仅影响线程获取CPU时间的可能性，而不是对共享资源的访问控制。

因此，对于需要确保操作原子性或互斥访问共享资源的场景，线程优先级并非合适的解决方案。

3. 解决方案：使用synchronized关键字实现互斥访问

为了确保在多线程环境下对共享资源的访问是互斥的，Java提供了synchronized关键字。synchronized可以用于方法或代码块，它通过使用一个内部锁机制来保证在同一时间只有一个线程可以执行被synchronized保护的代码。

当一个线程进入一个synchronized代码块或方法时，它会尝试获取与该代码块或方法关联的锁。如果锁已被其他线程持有，当前线程就会被阻塞，直到锁被释放。一旦当前线程获取到锁，它就可以独占地执行synchronized代码，直到执行完毕并释放锁。

立即学习“Java免费学习笔记（深入）”；

3.1 synchronized代码块的用法

对于需要保护特定代码段免受并发访问的场景，通常使用synchronized代码块。它需要一个对象作为锁。

示例代码：

public class PrinterManager {

    // 定义一个共享的锁对象，通常声明为final，避免被重新赋值
    public static final Object MY_LOCK = new Object();

    public void printMessage1(String message) {
        // 使用MY_LOCK对象作为锁，确保printMessage1方法中的打印操作是互斥的
        synchronized (MY_LOCK) {
            System.out.print("[线程 " + Thread.currentThread().getName() + "] 开始打印: ");
            try {
                // 模拟打印过程中的耗时操作
                Thread.sleep(50);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            System.out.println(message + " (结束)");
        }
    }

    public void printMessage2(String message) {
        // 同样使用MY_LOCK对象作为锁，确保与printMessage1互斥
        synchronized (MY_LOCK) {
            System.out.print("[线程 " + Thread.currentThread().getName() + "] 开始打印: ");
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            System.out.println(message + " (结束)");
        }
    }

    public static void main(String[] args) {
        PrinterManager manager = new PrinterManager();

        // 创建并启动多个线程，它们将尝试同时调用printMessage方法
        for (int i = 0; i < 5; i++) {
            final int taskId = i;
            new Thread(() -> {
                manager.printMessage1("任务A-" + taskId);
            }, "Thread-" + i + "-A").start();

            new Thread(() -> {
                manager.printMessage2("任务B-" + taskId);
            }, "Thread-" + i + "-B").start();
        }
    }
}

在上述示例中：

腾讯智影-AI数字人

基于AI数字人能力，实现7*24小时AI数字人直播带货，低成本实现直播业务快速增增，全天智能在线直播

73

查看详情

• public static final Object MY_LOCK = new Object(); 定义了一个静态的、final的锁对象。静态确保所有PrinterManager实例共享同一个锁，final确保锁对象不会在运行时被替换。
• synchronized (MY_LOCK) { ... } 块表示任何线程在执行这段代码之前，都必须先获取MY_LOCK对象的锁。
• 由于printMessage1和printMessage2方法都使用了同一个MY_LOCK对象进行同步，因此在任何给定时间，只有一个线程能够执行这两个方法中被synchronized保护的代码段。这有效地防止了打印输出被其他线程中断，确保了每条消息的完整性。

3.2 synchronized方法的用法

当需要同步整个方法时，可以直接在方法声明上使用synchronized关键字。对于实例方法，锁是方法所属的实例对象（this）；对于静态方法，锁是方法所属的类的Class对象。

public class SynchronizedMethodExample {

    // 实例方法，锁是SynchronizedMethodExample的实例对象
    public synchronized void instanceMethod() {
        System.out.println("实例方法 - 线程: " + Thread.currentThread().getName());
        // ... 临界区代码 ...
    }

    // 静态方法，锁是SynchronizedMethodExample.class对象
    public static synchronized void staticMethod() {
        System.out.println("静态方法 - 线程: " + Thread.currentThread().getName());
        // ... 临界区代码 ...
    }
}

注意： 当使用synchronized方法时，需要确保所有需要互斥访问的方法都使用相同的锁（即同一个实例对象或同一个Class对象）。

4. 注意事项与最佳实践

• 选择合适的锁对象：

  • 对于实例方法或访问实例变量的临界区，通常使用this作为锁，或定义一个private final Object lock = new Object();作为成员变量锁。
  • 对于静态方法或访问静态变量的临界区，必须使用Class对象作为锁（例如MyClass.class），或定义一个private static final Object STATIC_LOCK = new Object();作为静态锁。
  • 避免使用可变对象作为锁，因为锁对象一旦改变，同步机制就会失效。
  • 避免使用String字面量作为锁，因为字符串常量池可能导致意外的死锁或同步问题。

• 锁的粒度： 锁的粒度应尽可能小，只保护真正需要同步的代码块。过大的锁粒度会降低并发性，因为线程会花费更多时间等待锁的释放。

• 避免死锁： 当两个或多个线程互相持有对方所需的锁时，就会发生死锁。设计同步机制时应仔细考虑锁的获取顺序，尽量保持一致。

• 性能考量： synchronized是Java提供的开箱即用的同步机制，使用方便。但在高并发场景下，其性能可能不如java.util.concurrent.locks.ReentrantLock等显式锁。ReentrantLock提供了更细粒度的控制，如公平锁、条件变量等，但使用起来也更复杂。

5. 总结

在Java多线程编程中，解决因并发访问共享资源导致的操作中断和数据不一致问题，应优先采用synchronized关键字或java.util.concurrent包下的锁机制。线程优先级并非用于实现严格的互斥或控制执行顺序的可靠方法。通过正确使用synchronized代码块和共享锁对象，我们可以有效地保护临界区，确保关键操作的原子性，从而构建健壮、可靠的多线程应用程序。

以上就是Java多线程并发控制：使用synchronized关键字实现互斥访问的详细内容，更多请关注php中文网其它相关文章！