synchronized详解

系统管理员 2024-03-17 20:01 37阅读 0赞

在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][]

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

[Java Concurrency in Practice]: https://www.amazon.com/Java-Concurrency-Practice-Brian-Goetz/dp/0321349601