synchronized详解

在Java中，多线程编程是一项常见的任务。在多线程环境下，为了保证数据的一致性和线程安全，我们需要使用同步机制来控制线程的访问。其中，synchronized关键字是Java提供的一种最基本的同步机制。本文将详细讲解synchronized的使用方法和原理，并提供详细的Java示例来帮助读者更好地理解。

1. synchronized的基本概念

synchronized是Java中用于实现线程同步的关键字。它可以应用于方法和代码块，用于控制多个线程对共享资源的访问。当一个线程获取了某个对象的锁时，其他线程将被阻塞，直到该线程释放锁。

2. synchronized的使用方法

2.1 同步方法

我们可以使用synchronized修饰方法，使得该方法成为一个同步方法。当一个线程调用这个同步方法时，它将自动获取该方法所属对象的锁。

示例代码如下：

public class Counter {
    private int count;

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

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

在上面的代码中，increment和getCount方法都被修饰为synchronized，这意味着它们是线程安全的。在多个线程同时调用这些方法时，每个线程都会依次获取对象锁，保证了对count变量的操作的原子性和可见性。

2.2 同步代码块

除了修饰方法，我们还可以使用synchronized修饰代码块，实现更细粒度的同步控制。

示例代码如下：

public class Counter {
    private int count;
    private Object lock = new Object();

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

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

在上面的代码中，我们通过synchronized (lock)来创建一个同步代码块。当一个线程进入该代码块时，它将获取lock对象的锁，并执行代码块中的操作。其他线程在同一时间只能有一个线程进入该代码块。

3. synchronized的原理

synchronized的实现依赖于Java对象头中的一些标记位，主要包括对象的锁标记和线程等待队列。当一个线程尝试获取某个对象的锁时，如果锁标记为未被占用，则该线程获取锁并继续执行；如果锁标记为已被占用，则该线程将进入线程等待队列，等待锁的释放。

4. synchronized的特点和注意事项

4.1 互斥性

synchronized保证了同一时间只有一个线程可以执行被同步修饰的代码块或方法，从而保证了数据的一致性和线程安全。

4.2 可重入性

一个线程在获取了某个对象的锁后，可以再次获取该对象的锁，而不会被自己所持有的锁所阻塞。这种机制称为可重入性。

示例代码如下：

public class Counter {
    private int count;

    public synchronized void increment() {
        count++;
        // 调用另一个同步方法
        decrement();
    }

    public synchronized void decrement() {
        count--;
    }
}

在上面的代码中，increment方法中调用了decrement方法，由于它们都被修饰为synchronized，所以在increment方法中可以直接调用decrement方法而不会发生死锁。

4.3 锁的粒度

在使用synchronized时，应尽量减小锁的粒度，以提高并发性能。如果锁的粒度太大，那么在多线程环境下，线程的竞争将会增加，降低系统的吞吐量。

4.4 对象的锁和类的锁

在使用synchronized时，需要注意对象锁和类锁的区别。对象锁是针对对象实例的，不同的对象实例有不同的锁。而类锁是针对类的，不同的对象实例共享同一个类锁。

示例代码如下：

public class Counter {
    private static int count;

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

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

在上面的代码中，increment方法是对象锁，每个对象实例都有自己的锁；getCount方法是类锁，所有对象实例共享同一个锁。

5. synchronized的替代方案

除了使用synchronized，我们还可以使用Lock接口及其实现类来实现线程同步。Lock提供了更灵活的同步控制方式，例如可重入性、公平性等。在高度竞争的场景下，使用Lock可能比synchronized更加高效。

示例代码如下：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Counter {
    private int count;
    private Lock lock = new ReentrantLock();

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

    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

在上面的代码中，我们使用了ReentrantLock来实现线程同步。通过调用lock方法获取锁，然后在try-finally代码块中执行需要同步的操作，最后调用unlock方法释放锁。

6. 总结

本文详细讲解了synchronized的使用方法和原理，并提供了详细的Java示例帮助读者更好地理解。synchronized是Java中最基本的同步机制，通过它我们可以实现线程安全的操作。在多线程编程中，合理地使用synchronized可以保证数据的一致性和线程安全，提高系统的并发性能。

然而，除了synchronized，Java还提供了其他更高级的同步机制，例如Lock接口及其实现类。在实际开发中，我们应根据具体的需求选择合适的同步机制，以提高系统的性能和可维护性。

参考资料：

• Java Concurrency in Practice

公众号请关注"果酱桑", 一起学习,一起进步!