Java 详细讲解线程安全与同步附实例与注释

什么是线程安全？

线程安全是指多线程环境下，多个线程访问同一个对象时，不会产生冲突或者干扰，同时保证数据的正确性。

什么是同步？

同步是指在多线程环境下，对共享资源的访问被限定为一个线程访问，从而保证多线程下数据的一致性和正确性。

Java提供两种机制实现同步：synchronized关键字和Lock接口。

synchronized关键字

synchronized关键字可以在方法或代码块前使用，表示当前线程获取到锁所在对象的监视器之后才能执行代码，并且只有一个线程能够获取该对象的监视器。

示例

public class SynchronizedExample implements Runnable {
    private int count = 0;

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

    public void run() {
        for (int i = 0; i < 10000; i++) {
            increment();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        SynchronizedExample synchronizedExample = new SynchronizedExample();
        Thread thread1 = new Thread(synchronizedExample);
        Thread thread2 = new Thread(synchronizedExample);
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println(synchronizedExample.count);
    }
}

上面的代码中，SynchronizedExample类实现了Runnable接口，并且定义了一个increment方法，该方法前加上了synchronized关键字，保证了修改count变量的线程在获取到该对象的锁之后才执行。

在main方法中，新建了两个线程并启动，这两个线程同时修改了count变量，但是由于increment方法前加上了synchronized关键字，所以这两个线程在修改变量时只能互斥执行，因此最终结果输出的count值为20000，符合预期。

Lock接口

Lock接口是Java提供的另一个同步机制，其提供更加灵活的锁定方式，可以实现比synchronized更精细化的同步操作。

public class LockExample implements Runnable {
    private int count = 0;
    private Lock lock = new ReentrantLock();

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

    public void run() {
        for (int i = 0; i < 10000; i++) {
            increment();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        LockExample lockExample = new LockExample();
        Thread thread1 = new Thread(lockExample);
        Thread thread2 = new Thread(lockExample);
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println(lockExample.count);
    }
}

上面的代码中，LockExample类实现了Runnable接口，并定义了一个increment方法，该方法通过lock.lock()获取到锁，然后进行操作，并在finally中释放锁。

在main方法中，新建了两个线程并启动，这两个线程同时修改了count变量，但是由于increment方法前加了lock对象的锁，因此这两个线程在修改变量时只能互斥执行，最终的结果输出的count值为20000，符合预期。

总结

Java中的同步机制是操作多线程的核心部分，其中synchronized关键字和Lock接口是两种不同的实现方式，两者的区别在于synchronized是通过获取对象的锁来实现同步操作的，而Lock接口是通过获取Lock对象的锁实现的。开发人员可以根据需要选择不同的同步机制来保证多线程下数据的一致性和正确性。