跳转至

Java Synchronized：深入理解与高效应用

简介

在多线程编程的世界里，数据一致性和线程安全是至关重要的问题。Java 的 synchronized 关键字为我们提供了一种简单而有效的方式来处理这些问题。本文将深入探讨 synchronized 的基础概念、使用方法、常见实践以及最佳实践，帮助读者更好地掌握这一强大的工具。

目录

  1. 基础概念
  2. 使用方法
    • 修饰实例方法
    • 修饰静态方法
    • 修饰代码块
  3. 常见实践
    • 实现线程安全的单例模式
    • 保护共享资源
  4. 最佳实践
    • 减小锁的粒度
    • 避免死锁
  5. 小结
  6. 参考资料

基础概念

synchronized 关键字的主要作用是实现线程同步。它通过一种内置的锁机制来确保同一时刻只有一个线程可以访问被同步的代码块或方法，从而避免多线程环境下的数据竞争和不一致问题。

每个 Java 对象都有一个内置的锁（也称为监视器锁）。当一个线程访问被 synchronized 修饰的代码块或方法时，它首先需要获取该对象的锁。如果锁已经被其他线程持有，那么该线程将被阻塞，直到锁被释放。

使用方法

修饰实例方法

当 synchronized 修饰一个实例方法时，锁对象是调用该方法的实例对象。也就是说，同一时刻只有一个线程可以通过同一个实例对象调用这个被修饰的方法。

public class SynchronizedExample {
    public synchronized void instanceMethod() {
        // 方法体
        System.out.println(Thread.currentThread().getName() + " is accessing instance method.");
    }
}

修饰静态方法

当 synchronized 修饰一个静态方法时，锁对象是该类的 Class 对象。这意味着，同一时刻只有一个线程可以通过该类调用这个被修饰的静态方法。

public class SynchronizedStaticExample {
    public static synchronized void staticMethod() {
        // 方法体
        System.out.println(Thread.currentThread().getName() + " is accessing static method.");
    }
}

修饰代码块

synchronized 也可以修饰代码块，这种方式更加灵活。可以指定任意的对象作为锁对象。

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

    public void blockMethod() {
        synchronized (lock) {
            // 代码块
            System.out.println(Thread.currentThread().getName() + " is accessing synchronized block.");
        }
    }
}

常见实践

实现线程安全的单例模式

单例模式确保一个类只有一个实例，并提供一个全局访问点来访问这个实例。在多线程环境下，使用 synchronized 可以确保单例的创建是线程安全的。

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

保护共享资源

在多线程环境中，多个线程可能会同时访问和修改共享资源，这可能导致数据不一致。使用 synchronized 可以保护这些共享资源。

public class SharedResource {
    private int count = 0;

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

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

最佳实践

减小锁的粒度

尽量减小锁的作用范围，只在需要保护的关键代码段上使用 synchronized。这样可以提高并发性能，减少线程阻塞的时间。

public class FineGrainedLocking {
    private int count1 = 0;
    private int count2 = 0;

    private final Object lock1 = new Object();
    private final Object lock2 = new Object();

    public void incrementCount1() {
        synchronized (lock1) {
            count1++;
        }
    }

    public void incrementCount2() {
        synchronized (lock2) {
            count2++;
        }
    }
}

避免死锁

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

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

    public void method1() {
        synchronized (lock1) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lock2) {
                // 代码
            }
        }
    }

    public void method2() {
        synchronized (lock2) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lock1) {
                // 代码
            }
        }
    }
}

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

    public void method1() {
        synchronized (lock1) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lock2) {
                // 代码
            }
        }
    }

    public void method2() {
        synchronized (lock1) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lock2) {
                // 代码
            }
        }
    }
}

小结

Java synchronized 关键字是多线程编程中实现线程同步和确保数据一致性的重要工具。通过合理使用 synchronized，我们可以有效地解决多线程环境下的各种问题。在实际应用中，需要深入理解其基础概念，掌握不同的使用方法，并遵循最佳实践，以提高程序的性能和稳定性。

参考资料