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

目录
  • Volatile概述
  • Synchronized概述
  • Volatile与Synchronized的区别
  • 使用场景
    • 1 Volatile的使用场景
    • 2 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的资料请关注我们其它相关文章!

(0)

相关推荐

  • java Volatile与Synchronized的区别

    引言 在研究并发程序时,我们可能都知道volatile和synchronized是用于多线程中,用于线程安全和变量可见性的,但是具体两者怎么使用,有何区别可能还是稀里糊涂一知半解,在此就自己简单的理解总结一下二者的区别,和大家一块儿学习!我们需要了解java中关键字volatile和synchronized关键字的使用以及lock类的用法. 首先,了解下java的内存模型: java的线程内存模型中定义了每个线程都有一份自己的共享变量副本(本地内存),里面存放自己私有的数据,其他线程不能直接访问

  • java并发编程关键字volatile保证可见性不保证原子性详解

    目录 关于可见性 关于指令重排 volatile关键字可以说是Java虚拟机提供的最轻量级的同步机制,但对于为什么它只能保证可见性,不保证原子性,它又是如何禁用指令重排的,还有很多同学没彻底理解 相信我,坚持看完这篇文章,你将牢牢掌握一个Java核心知识点 先说它的两个作用: 保证变量在内存中对线程的可见性禁用指令重排 每个字都认识,凑在一起就麻了 这两个作用通常很不容易被我们Java开发人员正确.完整地理解,以至于许多同学不能正确地使用volatile 关于可见性 不多bb,码来 public

  • 详解java并发编程(2) --Synchronized与Volatile区别

    1 Synchronized 在多线程并发中synchronized一直是元老级别的角色.利用synchronized来实现同步具体有一下三种表现形式: 对于普通的同步方法,锁是当前实例对象. 对于静态同步方法,锁是当前类的class对象. 对于同步方法块,锁是synchronized括号里配置的对象. 当一个代码,方法或者类被synchronized修饰以后.当一个线程试图访问同步代码块的时候,它首先必须得到锁,退出或抛出异常的时候必须释放锁.那么这样做有什么好处呢? 它主要确保多个线程在同一

  • volatile保证可见性及重排序方法

    目录 一.JMM的内存可见性保证 二.volatile的内存语义 1.volatile的特性 2.volatile可见性实现原理 三.指令重排序 一.JMM的内存可见性保证 按程序类型,Java程序的内存可见性保证可以分为下列3类: 单线程程序:单线程程序不会出现内存可见性问题.编译器.runtime和处理器会共同确保单线程程序的执行结果与该程序在顺序一致性模型中的执行结果相同. 正确同步的多线程程序:正确同步的多线程程序的执行将具有顺序一致性(程序的执行结果与该程序在顺序一致性内存模型中的执行

  • java多线程中的volatile和synchronized用法分析

    本文实例分析了java多线程中的volatile和synchronized用法.分享给大家供大家参考.具体实现方法如下: 复制代码 代码如下: package com.chzhao; public class Volatiletest extends Thread { private static int count = 0; public void run() {         count++;     } public static void main(String[] args) {  

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

    目录 Volatile概述 Synchronized概述 Volatile与Synchronized的区别 使用场景 1 Volatile的使用场景 2 Synchronized的使用场景 注意事项 相关面试问题 Volatile概述 Volatile是Java中的一种轻量级同步机制,用于保证变量的可见性和禁止指令重排.当一个变量被声明为Volatile类型时,任何修改该变量的操作都会立即被所有线程看到.也就是说,Volatile修饰的变量在每次修改时都会强制将修改刷新到主内存中,具有很好的可见

  • 深入分析java并发编程中volatile的实现原理

    引言 在多线程并发编程中synchronized和Volatile都扮演着重要的角色,Volatile是轻量级的synchronized,它在多处理器开发中保证了共享变量的"可见性".可见性的意思是当一个线程修改一个共享变量时,另外一个线程能读到这个修改的值.它在某些情况下比synchronized的开销更小,本文将深入分析在硬件层面上Inter处理器是如何实现Volatile的,通过深入分析能帮助我们正确的使用Volatile变量. 术语定义 术语 英文单词 描述 共享变量 在多个线

  • JAVA多线程编程实例详解

    本文实例讲述了JAVA多线程编程.分享给大家供大家参考,具体如下: 进程是系统进行资源调度和分配的一个独立单位. 进程的特点 独立性:进程是系统中独立存在的实体,拥有自己的独立资源和私有空间.在没有经过进程本身允许的情况下,不能直接访问其他进程. 动态性:进程与程序的区别在于,前者是一个正在系统中活动的指令,而后者仅仅是一个静态的指令集合 并发性:多个进程可以在单个处理器上并发执行,而不受影响. 并发性和并行性的区别: 并行性:在同一时刻,有多条指令在多个处理器上同时执行(多个CPU) 并发性:

  • Java多线程编程小实例模拟停车场系统

    下面分享的是一个Java多线程模拟停车场系统的小实例(Java的应用还是很广泛的,哈哈),具体代码如下: Park类 public class Park { boolean []park=new boolean[3]; public boolean equals() { return true; } } Car: public class Car { private String number; private int position=0; public Car(String number)

  • java多线程编程学习(线程间通信)

    一.概要 线程是操作系统中独立的个体,但这些个体如果不经过特殊的处理就不能成为一个整体,线程间的通信就是成为整体的必用方案之一.可以说,使线程进行通信后,系统之间的交互性会更强大,在大大提高cpu利用率的同时还会使程序员对各线程任务在处理过程中进行有效的把控和监督. 二.等待/通知机制 1."wait/notify"机制:等待/通知机制,wait使线程暂停运行,而notify 使暂停的线程继续运行.用一个厨师和服务员的交互来说明: (1) 服务员取到菜的时间取决于厨师,所以服务员就有&

  • java多线程编程技术详解和实例代码

     java多线程编程技术详解和实例代码 1.   Java和他的API都可以使用并发. 可以指定程序包含不同的执行线程,每个线程都具有自己的方法调用堆栈和程序计数器,使得线程在与其他线程并发地执行能够共享程序范围内的资源,比如共享内存,这种能力被称为多线程编程(multithreading),在核心的C和C++语言中并不具备这种能力,尽管他们影响了JAVA的设计. 2.   线程的生命周期 新线程的生命周期从"新生"状态开始.程序启动线程前,线程一直是"新生"状态:

  • java多线程编程实例

    一.相关知识: Java多线程程序设计到的知识: (一)对同一个数量进行操作 (二)对同一个对象进行操作 (三)回调方法使用 (四)线程同步,死锁问题 (五)线程通信 等等 二.示例一:三个售票窗口同时出售20张票; 程序分析: 1.票数要使用同一个静态值 2.为保证不会出现卖出同一个票数,要java多线程同步锁. 设计思路: 1.创建一个站台类Station,继承Thread,重写run方法,在run方法里面执行售票操作!售票要使用同步锁:即有一个站台卖这张票时,其他站台要等这张票卖完! 2.

  • 浅谈java多线程编程

    一.多线程的优缺点 多线程的优点: 1)资源利用率更好 2)程序设计在某些情况下更简单 3)程序响应更快 多线程的代价: 1)设计更复杂 虽然有一些多线程应用程序比单线程的应用程序要简单,但其他的一般都更复杂.在多线程访问共享数据的时候,这部分代码需要特别的注意.线程之间的交互往往非常复杂.不正确的线程同步产生的错误非常难以被发现,并且重现以修复. 2)上下文切换的开销 当CPU从执行一个线程切换到执行另外一个线程的时候,它需要先存储当前线程的本地的数据,程序指针等,然后载入另一个线程的本地数据

  • 教你如何使用Java多线程编程LockSupport工具类

    LockSupport类 用于创建锁和其他同步类的基本线程阻塞原语,此类与使用它的每个线程关联一个许可.如果获得许可,将立即返回对park的调用,并在此过程中消耗掉它:否则may会被阻止.调用unpark可使许可证可用(如果尚不可用).(不过与信号量不同,许可证不会累积.最多只能有一个.) 方法park和unpark提供了有效的阻塞和解阻塞线程的方法,这些线程不会遇到导致已弃用的方法Thread.suspend和Thread.resume无法用于以下问题:由于许可,在调用park的一个线程与试图

随机推荐