1. 引言

在Java的多线程编程领域，掌握线程安全性是你代码成功运行的关键。当多线程同时涉及共享数据的读写时，隐患就像一把悬在头顶的利刃，可能导致程序行为的不可预测性。本文将为你揭示线程安全性的奥秘，并深入研究如何通过Java中强大的synchronized关键字实现线程的安全同步。让我们一同踏入这个精彩而关键的多线程世界。

【干货】探秘如何通过synchronized关键字实现线程同步

2. 线程安全性

2.1. 什么是线程安全性

线程安全性是指在多线程环境中，对共享数据的访问不会引起不一致或异常的状态。在多线程中，多个线程可能同时访问和修改相同的数据，因此确保线程安全性是至关重要的。

2.2. 为什么需要线程安全性

共享数据： 多个线程共享同一份数据。
竞态条件： 多个线程同时修改数据可能导致竞态条件，即结果依赖于执行的顺序。
数据一致性： 确保多线程环境下数据的一致性，防止脏读、幻读等问题。

3. synchronized关键字

3.1 概述

synchronized关键字是Java中用于实现线程同步的主要机制。它可以用于方法或代码块，确保在同一时刻只有一个线程执行被 synchronized修饰的部分。我们通常将其应用于三种不同类型的对象锁，以确保线程同步和避免并发问题。3.2节是这三种对象锁介绍以及适用场景说明。

3.2 三种对象锁

3.2.1 实例方法锁

当synchronized关键字用于实例方法时，它锁定的是当前实例对象。只有一个线程能够在同一时刻访问该实例对象的同步方法。

public class Example {
    public synchronized void instanceMethod() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + ": " + i);
            try {
                Thread.sleep(100); // 模拟耗时操作
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Example example = new Example();

        // 创建两个线程，分别调用同一个实例的 instanceMethod 方法
        Thread thread1 = new Thread(() -> {
            example.instanceMethod();
        }, "Thread-1");

        Thread thread2 = new Thread(() -> {
            example.instanceMethod();
        }, "Thread-2");

        // 启动线程
        thread1.start();
        thread2.start();
    }
}

3.2.2 静态方法锁

当synchronized关键字用于静态方法时，它锁定的是整个类的Class对象。这意味着只有一个线程能够在同一时刻访问该类的所有静态同步方法。

public class Example {
    public static synchronized void staticMethod() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + ": " + i);
            try {
                Thread.sleep(100); // 模拟耗时操作
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        // 创建两个线程，分别调用同一个类的 staticMethod 方法
        Thread thread1 = new Thread(Example::staticMethod, "Thread-1");

        Thread thread2 = new Thread(Example::staticMethod, "Thread-2");

        // 启动线程
        thread1.start();
        thread2.start();
    }
}

3.2.3 同步代码块锁

当synchronized关键字用于代码块时，需要指定一个对象作为锁。只有获取了该对象的锁的线程能够执行该代码块。这样提供了更细粒度的控制。

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

    public void someMethod() {
        // 非线程安全的操作
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + ": " + i);
            try {
                Thread.sleep(100); // 模拟耗时操作
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        synchronized (lock) {
            // 同步代码块线程安全的操作
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + ": " + i);
                try {
                    Thread.sleep(100); // 模拟耗时操作
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        Example example = new Example();

        // 创建两个线程，分别调用同一个实例的 someMethod 方法
        Thread thread1 = new Thread(() -> {
            example.someMethod();
        }, "Thread-1");

        Thread thread2 = new Thread(() -> {
            example.someMethod();
        }, "Thread-2");

        // 启动线程
        thread1.start();
        thread2.start();
    }
}

这三种对象锁分别应用于实例方法、静态方法和代码块，提供了不同层次的锁定粒度。选择合适的对象锁类型取决于具体的应用场景和需求。

实例方法锁锁定的是当前实例对象
静态方法锁锁定的是整个类
同步代码块锁允许更灵活地选择锁定的对象

通过合理应用这些对象锁，可以实现对共享资源的有效保护，确保程序在多线程环境中的稳定性和正确性。

4. synchronized的优缺点

4.1. 优点

简单易用： 使用简便，无需手动管理锁。
内置支持： Java内置的关键字，方便使用。

4.2. 缺点

细粒度不足： 可能导致过度同步，影响性能。
效率相对较低： 某些情况下，采用更精细的锁可能提高效率。

5. 替代方案与并发包

5.1. Lock接口

使用Lock接口及其实现类提供更灵活的锁定机制。

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

public class LockExample {
    private final Lock lock = new ReentrantLock();

    public void someMethod() {
        lock.lock();
        try {
            // 线程安全的操作
        } finally {
            lock.unlock();
        }
    }
}

5.2 ConcurrentHashMap

多线程环境下的高效Map实现。

import java.util.concurrent.ConcurrentHashMap;
import java.util.Map;

public class ConcurrentHashMapExample {
    private final Map<String, Integer> concurrentMap = new ConcurrentHashMap<>();

    public void addToMap(String key, int value) {
        concurrentMap.put(key, value);
    }
}

5.3 AtomicInteger等原子类

提供原子操作，避免了使用synchronized的需要。

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicExample {
    private final AtomicInteger counter = new AtomicInteger(0);

    public void increment() {
        counter.incrementAndGet();
    }
}

5.4 java.util.concurrent包提供的工具类

包含一系列用于并发编程的工具和数据结构。

import java.util.concurrent.CountDownLatch;

public class ConcurrentExample {
    private final CountDownLatch latch = new CountDownLatch(1);

    public void someMethod() throws InterruptedException {
        // 非线程安全的操作

        latch.await(); // 等待其他线程完成某个操作
    }
}