java多线程编程必备volatile与synchronized深入理解

Volatile概述

Volatile是Java中的一种轻量级同步机制，用于保证变量的可见性和禁止指令重排。当一个变量被声明为Volatile类型时，任何修改该变量的操作都会立即被所有线程看到。也就是说，Volatile修饰的变量在每次修改时都会强制将修改刷新到主内存中，具有很好的可见性和线程安全性。

上图可以看到在多线程编程中，线程没有直接操作主内存，而是把主内存中的数据拷贝到工作内存中也就是共享变量副本的方式操作变量。当一个变量被多个线程共享时，如果其中一个线程修改了这个变量的值，另一个线程在读取这个变量时可能会得到过期的值。这是因为线程之间存在缓存不一致的问题。

使用 volatile 关键字可以解决这个问题。volatile 保证了对该变量的访问都是直接针对主内存中的变量进行的，而不是访问线程本地的缓存。因此，当一个线程修改了这个变量的值，其他线程能够立即看到这个变化，避免了缓存不一致的问题。

具体实现原理是，在使用 volatile 关键字修饰的变量进行读写操作时，会禁止 CPU 的缓存优化，每次操作都要直接读写主内存。同时，在进行读操作时，也会强制从主内存中读取最新的值，而不是使用线程本地的缓存。这样就可以保证多线程之间的变量访问是同步、可见的。

Synchronized概述

Synchronized是Java中的一种重量级同步机制，用于保证线程安全和排除数据竞争。当一个方法被声明为Synchronized时，同一时间只有一个线程可以访问该方法，其他线程必须等待。这样可以避免多个线程同时访问共享资源导致数据不一致的问题。

Volatile与Synchronized的区别

（1）Volatile是一种轻量级的同步机制，Synchronized是一种重量级的同步机制。

（2）Volatile用于保证变量的可见性和禁止指令重排，Synchronized用于排除数据竞争和保证线程安全。

（3）Volatile不能保证变量的原子性，Synchronized可以保证同步代码块的原子性。

（4）Volatile的性能远高于Synchronized，但只适用于变量的情况，而Synchronized则适用于任意类型的对象或代码块。

（5）volatile修饰变量，仅用于变量级（不会造成线程阻塞），线程读写时均刷新内存，只保证可见性。volatile还可以禁止指令重排。

（6）synchronized锁变量或代码段，锁级（会造成线程阻塞），能保证可见性与原子性

使用场景

1 Volatile的使用场景

由于Volatile的可见性和禁止指令重排的特点，其在一些特定的场景下非常有用，例如：

（1）用于控制线程的开关、状态标志、计数器等变量；

（2）用于发布一些不变的对象，例如单例模式中的实例；

（3）用于性能调优，避免锁竞争，例如CAS算法等。

以下是使用Java编写一个演示volatile关键字的简单示例：

    public class VolatileDemo {
        private volatile boolean isRunning = true;
        public void start() {
            System.out.println("Starting the thread...");
            new Thread(() -> {
                while (isRunning) {
                    // do some work here
                }
                System.out.println("Thread stopped.");
            }).start();
        }
        public void stop() {
            System.out.println("Stopping the thread...");
            isRunning = false;
        }
        public static void main(String[] args) throws InterruptedException {
            VolatileDemo demo = new VolatileDemo();
            demo.start();
            // wait for 3 seconds
            Thread.sleep(3000);
            demo.stop();
        }
    }

在上述示例中，我们创建了一个名为VolatileDemo的类，并声明了一个volatile变量isRunning。此变量用于指示线程是否应该继续运行。在start()方法中，我们启动了一个新线程，并在while循环中检查isRunning变量的值。由于isRunning变量是volatile类型的，因此在不同的线程之间更改它的值时，该值将始终保持同步。在stop()方法中，我们将isRunning变量的值设置为false，以便使线程停止运行。在main()方法中，我们创建了一个VolatileDemo对象并调用start()方法来开始线程的执行。然后，我们等待3秒钟，随后调用stop()方法来停止线程的执行。由于isRunning变量是volatile类型的，因此线程能够及时地检测到isRunning变量的更改，从而停止线程的执行。

2 Synchronized的使用场景

Synchronized机制由于其强制性的同步性，在保证线程安全和数据完整性的同时，也会带来一些性能上的开销。因此，在使用Synchronized时需要控制同步的范围和频率，适当使用Synchronized可以提高程序的效率和可靠性。使用Synchronized的场景包括：

（1）对共享变量的访问和修改，例如在多线程情况下对数据进行同步处理；

（2）对类实例化的构造函数进行同步，确保实例化过程中的线程安全；

（3）对静态变量和方法的访问和修改，例如在多线程情况下对静态变量进行同步。

以下是使用Java编写一个演示synchronized关键字的简单示例：

public class SynchronizedDemo {
    private int counter = 0;
    public synchronized void increment() {
        counter++;
    }
    public synchronized int getCounter() {
        return counter;
    }
    public static void main(String[] args) throws InterruptedException {
        SynchronizedDemo demo = new SynchronizedDemo();
        // create multiple threads to increment counter
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    demo.increment();
                }
            }).start();
        }
        // wait for all threads to finish
        Thread.sleep(5000);
        // print the final value of counter
        System.out.println("Final value of counter: " + demo.getCounter());
    }
}

在上述示例中，我们创建了一个名为SynchronizedDemo的类，并声明了一个私有变量counter。我们在increment()方法和getCounter()方法上加了synchronized关键字来确保每次只有一个线程可以访问这些方法。

在main()方法中，我们创建了10个线程来并发地执行increment()方法，每个线程将计数器增加1000次。由于increment()方法是同步的，因此在任何时候都只有一个线程可以访问它，从而避免了数据竞争和不一致性。

最后，我们等待所有线程完成后打印计数器的最终值。由于getCounter()方法也是同步的，所以它返回的值将始终是最新的和正确的。

注意事项

（1）使用Volatile时需要注意可见性和原子性，不能保证多个操作的原子性。

（2）使用Synchronized时需要注意同步块的范围和对象的锁定，避免死锁和性能问题。

（3）在多线程编程中，需要根据实际情况选择合适的同步机制或使用多种同步机制的组合，以保证程序的正确性和可靠性。

相关面试问题

• volatile 和 synchronized 有什么区别？

答：volatile 关键字只能保证变量的可见性，不能保证原子性以及同步性，而 synchronized 关键字既能保证原子性和同步性，也能保证变量的可见性。

• volatile 能否替代 synchronized？

答：不能。虽然 volatile 可以保证变量的可见性，但是它无法保证原子性和同步性，而 synchronized 能够保证这三种特性。

• synchronized 与 volatile 的实现机制有何不同？

答：synchronized 是通过对对象或类进行加锁来保证同步性和原子性的，其效率相对较低；而 volatile 是通过禁止 CPU 缓存优化来保证变量的可见性，其开销相对较小，但不能保证同步性和原子性。

• 在什么情况下需要使用 volatile？

答：当一个变量被多个线程访问时，可能存在缓存不一致的问题，此时需要使用 volatile 来保证变量的可见性。

• synchronized 和 volatile 的适用场景分别是什么？

答：synchronized 适用于保证临界区代码的原子性和同步性，而 volatile 适用于保证变量的可见性。因此，如果需要进行复杂的操作并且需要保证原子性和同步性时，应该使用 synchronized；而如果只需要保证变量的可见性时，可以使用 volatile。

以上就是java多线程编程必备volatile与synchronized深入理解的详细内容，更多关于java多线程volatile synchronized的资料请关注编程网其它相关文章！