Java中的synchronized关键字：深入解析与实践

简介

在多线程编程的世界里，数据一致性和线程安全是至关重要的问题。Java中的synchronized关键字就是为了解决这些问题而设计的。它提供了一种机制，确保在同一时刻只有一个线程能够访问被该关键字修饰的代码块或方法，从而避免数据竞争和其他线程安全问题。本文将详细探讨synchronized关键字的基础概念、使用方法、常见实践以及最佳实践，帮助你全面掌握这一重要的Java特性。

目录

1. 基础概念
2. 使用方法
   • 修饰实例方法
   • 修饰静态方法
   • 修饰代码块
3. 常见实践
   • 实现线程安全的单例模式
   • 同步集合类操作
4. 最佳实践
   • 缩小同步范围
   • 避免死锁
   • 使用合适的锁对象
5. 小结
6. 参考资料

基础概念

synchronized关键字的核心作用是实现线程同步。当一个线程访问被synchronized修饰的代码块或方法时，它会自动获取一个锁（也称为监视器）。这个锁是一个互斥锁，意味着在同一时刻只有一个线程可以持有该锁。其他试图访问相同synchronized代码的线程将被阻塞，直到持有锁的线程释放锁。

这种机制确保了对共享资源的访问是线程安全的，因为在同一时间只有一个线程能够修改共享资源，从而避免了数据不一致的问题。

使用方法

修饰实例方法

当synchronized关键字修饰一个实例方法时，锁对象是调用该方法的实例对象。也就是说，对于同一个实例对象，同一时刻只能有一个线程可以调用该方法。

public class SynchronizedExample {
    private int count = 0;

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

    public int getCount() {
        return count;
    }
}

在上述代码中，increment方法被synchronized修饰。当多个线程同时调用increment方法时，只有一个线程能够进入该方法并执行count++操作，其他线程将被阻塞，直到当前线程执行完毕并释放锁。

修饰静态方法

当synchronized关键字修饰一个静态方法时，锁对象是该类的Class对象。这意味着对于整个类，同一时刻只能有一个线程可以调用该静态方法。

public class StaticSynchronizedExample {
    private static int count = 0;

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

    public static int getCount() {
        return count;
    }
}

在这个例子中，increment是一个静态方法，并且被synchronized修饰。所有调用StaticSynchronizedExample.increment()的线程都会竞争同一个Class对象的锁。

修饰代码块

synchronized关键字还可以用于修饰代码块。这种方式允许你更加细粒度地控制同步的范围。你可以指定一个锁对象，只有获取到该锁对象的线程才能执行代码块中的内容。

public class BlockSynchronizedExample {
    private int count = 0;
    private final Object lock = new Object();

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

    public int getCount() {
        return count;
    }
}

在上述代码中，increment方法中的synchronized代码块使用lock对象作为锁。只有获取到lock对象锁的线程才能进入代码块并执行count++操作。

常见实践

实现线程安全的单例模式

单例模式是一种常见的设计模式，确保一个类只有一个实例，并提供一个全局访问点。在多线程环境下，需要使用synchronized关键字来确保单例的创建是线程安全的。

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

在这个经典的单例模式实现中，getInstance方法被synchronized修饰，确保在多线程环境下只有一个线程能够创建单例实例。

同步集合类操作

在多线程环境下使用集合类时，需要注意线程安全问题。例如，ArrayList和HashMap是非线程安全的。可以使用synchronized关键字来确保对这些集合类的操作是线程安全的。

import java.util.ArrayList;
import java.util.List;

public class SynchronizedListExample {
    private List<Integer> list = new ArrayList<>();
    private final Object lock = new Object();

    public void addElement(int element) {
        synchronized (lock) {
            list.add(element);
        }
    }

    public int getElement(int index) {
        synchronized (lock) {
            return list.get(index);
        }
    }
}

在上述代码中，通过synchronized代码块来同步对list的添加和获取操作，确保在多线程环境下数据的一致性。

最佳实践

缩小同步范围

尽量缩小synchronized代码块或方法的范围，只将需要同步的关键代码放入其中。这样可以提高并发性能，因为其他不需要同步的代码可以被多个线程同时执行。

public class NarrowSynchronizationExample {
    private int count = 0;

    public void increment() {
        // 非关键代码，可以并发执行
        someNonCriticalOperation();

        synchronized (this) {
            count++;
        }

        // 非关键代码，可以并发执行
        someOtherNonCriticalOperation();
    }

    private void someNonCriticalOperation() {
        // 一些不需要同步的操作
    }

    private void someOtherNonCriticalOperation() {
        // 一些不需要同步的操作
    }
}

避免死锁

死锁是多线程编程中一个严重的问题，当两个或多个线程相互等待对方释放锁时就会发生死锁。为了避免死锁，需要遵循一些原则： - 尽量减少锁的嵌套使用。 - 按照相同的顺序获取锁。

// 错误示例，可能导致死锁
public class DeadlockExample {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();

    public void method1() {
        synchronized (lock1) {
            synchronized (lock2) {
                // 执行一些操作
            }
        }
    }

    public void method2() {
        synchronized (lock2) {
            synchronized (lock1) {
                // 执行一些操作
            }
        }
    }
}

// 正确示例，按照相同顺序获取锁
public class NoDeadlockExample {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();

    public void method1() {
        synchronized (lock1) {
            // 执行一些操作
        }
        synchronized (lock2) {
            // 执行一些操作
        }
    }

    public void method2() {
        synchronized (lock1) {
            // 执行一些操作
        }
        synchronized (lock2) {
            // 执行一些操作
        }
    }
}

使用合适的锁对象

选择合适的锁对象可以提高代码的可读性和维护性。尽量使用final对象作为锁对象，避免使用this作为锁对象（尤其是在可能被继承的类中）。

public class ProperLockObjectExample {
    private final Object lock = new Object();

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

小结

synchronized关键字是Java多线程编程中一个强大的工具，用于确保线程安全和数据一致性。通过修饰实例方法、静态方法或代码块，它提供了灵活的同步机制。在实际应用中，需要根据具体需求选择合适的使用方式，并遵循最佳实践，以提高并发性能并避免死锁等问题。希望本文的内容能帮助你更好地理解和使用synchronized关键字，编写出更加健壮的多线程程序。

参考资料

• Oracle Java Documentation - Concurrency Utilities
• Effective Java, 3rd Edition - Joshua Bloch
• Java Concurrency in Practice - Brian Goetz