《Java基础知识》Java锁详解（volatile，synchronized等）

已于 2022-06-20 18:03:44 修改
阅读量205 收藏
点赞数
分类专栏： java 文章标签： java jvm 开发语言
于 2022-06-20 18:03:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Limingmingaa/article/details/125377900
版权

volatile:

让变量每次在使用的时候，都从主存中取。

volatile具有synchronized关键字的“可见性”，但是没有synchronized关键字的“并发正确性”，也就是说不保证线程执行的有序性。

也就是说，volatile变量对于每次使用，线程都能得到当前volatile变量的最新值。但是volatile变量并不保证并发的正确性。

1. volatile的可见性：案例：

​



public class TestVolatile {

    private static boolean status = false;

    public static void main(String[] args) throws InterruptedException {

        new Thread(() -> {
            while (!status) {
            }
        }).start();

        Thread.sleep(100L);

        status = true;
        System.out.println("status is " + status);
    }
}



​

运行结果：status 状态已经打印，但是线程还在继续执行中。

原因是：每一个线程都会创建自己的变量副本存在寄存器中。主线程将值修改了，其他线程是不知道的。

要让status值变了，能够让其他线程都知晓，可以使用volatile.

将上述代码修改一下：

下面的代码

    private static boolean status = false;

改成

    private volatile static boolean status = false;

再次运行程序：线程就停止了。

添加一个额外知识：（困扰我好久的疑问）将上述代码进行修改：去掉volatile，再循环中加入一行：System.out.println("--------------");

​



public class TestVolatile {

    private static boolean status = false;

    public static void main(String[] args) throws InterruptedException {

        new Thread(() -> {
            while (!status) {
                System.out.println("--------------");
            }
        }).start();

        Thread.sleep(1L);

        status = true;
        System.out.println("status is " + status);
    }
}



​

运行：

线程正常停止了。  为什么？看了println源码：

​



public void println(String x) {
   synchronized (this) {
        print(x);
        newLine();
    }
}



​

发现关键字：synchronized。猜测和它有关。验证：（在循环里面增加了一个synchronized锁，其他都不变）

​



public class TestVolatile {

    static TestVolatile testVolatile = new TestVolatile();

    private static boolean status = false;

    public static void main(String[] args) throws InterruptedException {

        new Thread(() -> {
            while (!status) {
                synchronized (testVolatile){
                    
                }
            }
        }).start();

        Thread.sleep(100L);

        status = true;
        System.out.println("status is " + status);
    }
}



​

运行结果：

线程正常停止。

同时也证明了：synchronized 也有可见性。开心^-^!2.  volatile的非原子性：

​



public class Counter {
    private volatile int inc = 0;

    private void increase() {
        inc++;
    }

    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    counter.increase();
                }
            }).start();
        }

        Thread.sleep(3000L);

        System.out.println(counter.inc);
    }
}


​

运行结果：（每次运行结果不一样的）

原因是：虽然volatile有可见性，但是主存中的变量值和每一个线程寄存器中的变量在某一时刻存在不一致的情况。

图解：（volatile的变量会去主存中获取值，但不一定是最新的），得到结论，volatile不会导致线程阻塞。

synchronized：Java语言的关键字，当它采用修饰一个方法或一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。

​



public class MyLockTest implements Runnable {

    private static int index = 1000;

    @Override
    public void run() {
        while(true) {
            if(index > 0){
                try {
                    //为了让效果更佳明显
                    Thread.sleep(1L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                index--;
                System.out.println(Thread.currentThread().getName()+"; index = " + index);
            }else{
                break;
            }
        }
    }

    public static void main(String[] args) {
        MyLockTest test = new MyLockTest();
        for (int i = 0; i < 10; i++) {
            new Thread(test, "thread-" + i).start();
        }
        System.out.println("index = "+index);
    }
}


​

运行结果：

1. synchronized 原子性

​



public class MyLockTest implements Runnable {

    private static int index = 1000;

    @Override
    public void run() {
        while(true) {
            synchronized (this){
                if(index > 0){
                    try {
                        //为了让效果更佳明显
                        Thread.sleep(1L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    index--;
                    System.out.println(Thread.currentThread().getName()+"; index = " + index);
                }else{
                    break;
                }
            }
        }
    }

    public static void main(String[] args) {
        MyLockTest test = new MyLockTest();
        for (int i = 0; i < 10; i++) {
            new Thread(test, "thread-" + i).start();
        }
        System.out.println("index = "+index);
    }
}



​

运行结果：

synchronized 代码块中的代码就变成一个原子不可分割，必须全部执行完，才能让下一个线程调用。

从中发现执行速度下降非常明显，执行变得异常慢。

2. 可见性上面已经验证过：

3. 无序性，哪个线程执行，资源靠抢（案列中一直被3这个线程占着，每次效果不一）。

下面看看ReentrantLock 锁，可以做到有序，公平，每一个线程先到先得，效率更低。


ReentrantLock 锁

​



import java.util.concurrent.locks.ReentrantLock;

public class MyLockTest implements Runnable {

    private static int index = 1000;

    private ReentrantLock reentrantLock = new ReentrantLock(true);

    @Override
    public void run() {
        while(true) {
            reentrantLock.lock();
                if(index > 0){
                    try {
                        //为了让效果更佳明显
                        Thread.sleep(1L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    index--;
                    System.out.println(Thread.currentThread().getName()+"; index = " + index);
                }else{
                    break;
                }
            reentrantLock.unlock();
        }
    }

    public static void main(String[] args) {
        MyLockTest test = new MyLockTest();
        for (int i = 0; i < 10; i++) {
            new Thread(test, "thread-" + i).start();
        }
        System.out.println("index = "+index);
    }
}



​

运行结果：

总结：

可见性：volatile ，synchronized ，ReentrantLock

原子性：synchronized ，ReentrantLock

有序性：ReentrantLock

效率（高到低）：volatile ，synchronized ，ReentrantLock

Java中还有其他锁，后续有机会补充。

尚学堂给同学们带来全新的Java300集课程啦!java零基础小白自学Java必备优质教程_手把手图解学习Java，让学习成为一种享受_哔哩哔哩_bilibiliicon-default.png?t=M5H6https://www.bilibili.com/video/BV1qL411u7eE?spm_id_from=333.337.search-card.all.click&vd_source=3117718bf474f48fd81d26049c0c97ac

Limingmingaa
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java 关键字 volatile、synchronized、Lock
kangkang_style的博客
04-16 238
volatile： 简介： 用以声明变量的值可能随时会别的线程修改 使用volatile修饰的变量会强制将修改的值立即写入主存 主存中值的更新会使缓存中的值失效 特性： 1. 可见性 当多个线程访问同一个变量时，某一个线程修改了变量的值，其他线程能够立即读取到该变量修改后的值。 2. 有序性 即程序执行时按照代码书...
java-利用synchronized实现volatile的功能
i晨i曦520
04-23 497
“` /** * Created by Dev_yang on 2016/4/23. */ public class ThreadLock2 { public static void main(String[] args) { Service service = new Service(); ThreadA threadA = new Thr
Java面试之volatile和synchronized及Lock的区别
z123456789XDW的博客
04-10 875
面试中经常会遇到以下的问题：Java中的volatile和synchronized的区别？Java中的Lock和synchronized的区别？今天我们来深入聊聊vola...
Java关键字系列 — volatile、synchronized、lock
Gavin的前行之路
01-04 1220
volatile、synchronized和lock简单介绍
java中volatile、synchronized和lock解析
weixin_44956418的博客
06-16 746
java中volatile、synchronized和lock解析 1、概述 在研究并发程序时，我们需要了解java中关键字volatile和synchronized关键字的使用以及lock类的用法。 首先，了解下java的内存模型： （1）每个线程都有自己的本地内存空间（java栈中的帧）。线程执行时，先把变量从内存读到线程自己的本地内存空间，然后对变量进行操作。 （2）对该变量操作完成后，在某个时间再把变量刷新回主内存。 那么我们再了解下锁提供的两种特性：互斥（mutual exclusion） 和可
Java基础：volatile详解
xueping_wu的博客
05-03 3万+
Java基础：volatile1、volatile保证可见性1.1、JMM模型的引入1.2、volatile保证可见性的代码验证1.2.1、无可见性代码验证1.2.1、volatile保证可见性验证2、volatile不保证原子性 问：请谈谈你对volatile的理解？ 答：volatile是Java虚拟机提供的轻量级的同步机制，它有３个特性： １）保证可见性 ２）不保证原子性 ３）禁止指令重排 刚学完java基础，如果有人问你什么是volatile？它有什么作用的话，相信一定非常懵逼… 可能看了答案，也完
Java Synchronized的使用详解
08-18
下面是对Java Synchronized的使用详解的知识点总结： 1. 为什么要使用Synchronized？ 在并发编程中，存在线程安全问题的主要原因是共享数据和多线程共同操作共享数据。使用Synchronized可以解决这个问题，确保在...
详解Java关键字之 volatile
JavaMonsterr的博客
05-26 678
一、什么是Volatile volatile是Java提供的一种轻量级的同步机制。Java 语言包含两种内在的同步机制：同步块（或方法）和 volatile 变量，相比于synchronized（synchronized通常称为重量级锁），volatile更轻量级，因为它不会引起线程上下文的切换和调度。但是volatile 变量的同步性较差（有时它更简单并且开销更低），而且其使用也更容易出错。 Volatile 可以保证可见性，但不能保证原子性，一种线程同步的机制！很强大来看一道经典面试题~ 请你谈谈
Java 多线程与并发-Java并发知识体系详解.pdf
最新发布
07-11
总的来说，Java并发编程是一个复杂但重要的主题，需要深入理解线程基础、同步机制、并发工具类等知识，才能编写出高效、稳定的多线程程序。在实际开发中，应根据具体场景选择合适的并发控制手段，合理利用Java提供的...
JAVA基础技术框架详解二.pdf
06-11
本资源摘要信息中，我们将详细介绍 Java 相关技术框架的各种知识点，涵盖了 Java 语言基础、Java 虚拟机（JVM）、Java 集合框架、Java 并发编程、Java 网络编程、数据存储技术等方面的知识。 Java 语言基础 * Java...
Java基础-11-Lock，synchronized，volatile
YYbLQQ的博客
12-03 126
实现同步互斥访问的四种方式 synchronized： 同步代码块，修饰非静态的方法 修饰静态的方法 Lock： 必须在try-catch-finally块中进行 wait() / notify() / notifyAll() 方法 CAS Lock 和 synchronized的区别 Lock synchronized Lock是接口 synchronized是关键字，是内置语言实现 Lock发生异常时，如果没有主动通过unLock()释放锁，可能会死锁，因此使用L
JAVA并发理解之volatile、synchronized和lock解析
不行就改名
03-27 754
       谈到并发时候，离不开JAVA的几个关键字volatile、synchronized和lock类。下面就分别介绍一下它们的实现原理、用法以及使用场景。      首先先了解一下Java内存模型的抽象示意如图所示      *每个线程都有自己的本地内存空间（java栈中的帧）。线程执行时，先把变量从内存读到线程自己的本地内存空间，然后对变量进行操作。       * 对该变量操作完成后，...
Java多线程中的 Lock, synchronized 和 volatile
Theworldwillbegood的博客
11-28 717
Java 多线程编程中 Lock 的概念和synchronized、volatile关键字是经常遇到的内容或者说知识点，本文是我最近学习多线程的个人总结，会说明这三者涉及的一些基础概念，所以它们不是很全面。你可以浏览下目录来确定是否看下去，参考资料会在文章结尾给出。
Java并发编程之synchronized 与 volatile
潇歌的博客
08-22 311
本文简单的介绍下synchronized和volatile两大关键字的区别
Java中关键字volatile与synchronized的功能及区别?
qq_25073223的博客
06-14 154
volatile与synchronized的功能及区别说明
Java多线程synchronized && Lock && volatile，看完这一篇就够了
m0_46638350的博客
05-14 1359
对，你没看错，就是对变量加锁，没有对run（）方法加锁：因为当一个线程进入 synchronizer 代码块后，线程获取到锁，会清空本地内存，然后从主内存中拷贝共享变量的最新值到本地内存作为副本，执行代码，又将修改后的副本值刷新到主内存中，最后线程释放锁。静态代码块随着类加载而加载，有多个静态代码块的，按代码块前后顺序加载。然而，JMM 这样的规定可能会导致线程对共享变量的修改没有即时更新到主内存，或者线程没能够即时将共享变量的最新值同步到工作内存中，从而使得线程在使用共享变量的值时，该值并不是最新的。
Java多线程（三）---synchronized、Lock和volatile
u014311114的博客
02-24 675
JMM内存模型，synchronized、Lock和volatile等并发编程关键字讲解
java中sleep（）的用法
yihuliunian的博客
09-11 469
转载自品略图书馆http://www.pinlue.com/article/2019/03/2521/548409858821.html Thread.sleep(long millis)和Thread.sleep(long millis, int nanos)静态方法强制当前正在执行的线程休眠（暂停执行），以“减慢线程”。 当线程睡眠时，它睡在某个地方，在苏醒之前不会返回到可运行状态。 当睡眠时间到期，则返回到可运行状态。 线程睡眠的原因：线程执行太快，或者需要强制进入下一轮，因为Java规范不.
Java 中Sleep 用法
热门推荐
LANGZI7758521的专栏
11-09 4万+
Thread.sleep(long millis)和Thread.sleep(long millis, int nanos)静态方法强制当前正在执行的线程休眠（暂停执行），以“减慢线程”。 当线程睡眠时，它睡在某个地方，在苏醒之前不会返回到可运行状态。 当睡眠时间到期，则返回到可运行状态。线程睡眠的原因：线程执行太快，或者需要强制进入下一轮，因为Java规范不保证合理的轮换。睡眠的实现：调用静态
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值