synchronized 锁的介绍

最新推荐文章于 2022-07-31 23:00:12 发布
最新推荐文章于 2022-07-31 23:00:12 发布
阅读量214 收藏
点赞数
分类专栏： thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014636209/article/details/106758250
版权

文章目录

线程的安全性问题<-并发编程带来的问题

问题演示

package com.gaoxinfu.demo.jdk.rt.java.lang.thread.synchronize;

/**
 * @Description: 并发编程问题demo
 * @Author: gaoxinfu
 * @Date: 2020-06-13 16:02
 */
public class SynchronizedQuestionDemo {

    public static Integer COUNT=0;

    public static void add(){
        try {
            Thread.currentThread().sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        COUNT++;
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i=1;i<=100;i++){
            Thread thread=new Thread(new SynchronizedQuestionThread(),"Thread"+i);
            thread.start();
        }
        Thread.currentThread().sleep(3000);

        System.out.println(COUNT);
    }
}

class SynchronizedQuestionThread implements Runnable{
    @Override
    public void run() {
        SynchronizedQuestionDemo.add();
    }
}

控台输出

91

Process finished with exit code 0

运行了100次，但是结果并不是100，而是显示了91，说明我们线程在运行的过程中，对于共享资源COUNT变量并不是线程安全的

1.由于我们启动了100个线程，在执行的线程的过程中，
  在每一个线程的进行add方法中的COUNT++的过程中，实际上COUNT++在JVM内存中的运算是分好几步的
  所以导致有的线程没有拿到COUNT值，但是还没有进行计算，其他线程使用它拿到的COUNT值做了计算
  在各个线程之间处理的过程中，最终导致了COUNT值并不是预期的100
  这个就是并发线程开发的过程中的共享变量

https://blog.csdn.net/u014636209/article/details/104400529

锁的本质

解决线程安全性问题的方式

synchronized

synchronized修饰的锁的类型

对象实例锁
同一个对象实例对象
package com.gaoxinfu.demo.jdk.rt.java.lang.thread.synchronize;

import org.junit.Test;

import java.util.concurrent.TimeUnit;

/**
 * @Description: Synchronized对对象实例进行加锁
 * @Author: gaoxinfu
 * @Date: 2020-06-13 17:27
 */
public class SynchronizedInstanceDemo {

    void add() {
        synchronized (this) {
            System.out.println("大家好，我是线程 = " + Thread.currentThread().getName()+",执行需要耗时5s,请稍等");
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {

        SynchronizedInstanceDemo synchronizedInstanceDemo=new SynchronizedInstanceDemo();

        Thread thread1=new Thread(()->{
            synchronizedInstanceDemo.add();
        },"thread-1");
        thread1.start();
        Thread thread2=new Thread(()->{
            synchronizedInstanceDemo.add();
        },"thread-2");
        thread2.start();
    }
}

控台输出

大家好，我是线程 = thread-1,执行需要耗时5s,请稍等
大家好，我是线程 = thread-2,执行需要耗时5s,请稍等

Process finished with exit code 0


1.由于thread-1和thread-2两个线程，执行的对象实例都是synchronizedInstanceDemo，
  在执行add()方法的时候由于 synchronized (this) 中对象实例synchronizedInstanceDemo，被锁住
  因此thread-2是一定会等thread-1线程执行完毕之后，才会去执行的;
不同一个对象实例对象
   public static void main(String[] args) {

        SynchronizedInstanceDemo synchronizedInstanceDemo=new SynchronizedInstanceDemo();
        //新增对象实例synchronizedInstanceDemo1
        SynchronizedInstanceDemo synchronizedInstanceDemo1=new SynchronizedInstanceDemo();

        Thread thread1=new Thread(()->{
            synchronizedInstanceDemo.add();
        },"thread-1");
        thread1.start();
        Thread thread2=new Thread(()->{
            //然后线程2在执行的过程中对象是synchronizedInstanceDemo1 与线程1的对象不一致
            synchronizedInstanceDemo1.add();
        },"thread-2");
        thread2.start();
    }

控台输出

大家好，我是线程 = thread-1,执行需要耗时5s,请稍等
大家好，我是线程 = thread-2,执行需要耗时5s,请稍等

Process finished with exit code 0

1.两个线程的执行，先后等待的问题，因为相互锁定的对象是不同的
静态方法锁
package com.gaoxinfu.demo.jdk.rt.java.lang.thread.synchronize;

import java.util.concurrent.TimeUnit;

/**
 * @Description:
 * @Author: gaoxinfu
 * @Date: 2020-06-13 18:22
 */
public class SynchronizedStaticMethodDemo {

   synchronized static void add() {
        System.out.println("大家好，我是线程 = " + Thread.currentThread().getName()+",执行需要耗时5s,请稍等");
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        SynchronizedStaticMethodDemo synchronizedStaticMethodDemo1=new SynchronizedStaticMethodDemo();
        SynchronizedStaticMethodDemo synchronizedStaticMethodDemo2=new SynchronizedStaticMethodDemo();

        Thread thread1=new Thread(()->{
            synchronizedStaticMethodDemo1.add();
        },"thread-1");
        thread1.start();
        Thread thread2=new Thread(()->{
            synchronizedStaticMethodDemo2.add();
        },"thread-2");
        thread2.start();
    }
}

控台输出

大家好，我是线程 = thread-1,执行需要耗时5s,请稍等
大家好，我是线程 = thread-2,执行需要耗时5s,请稍等

Process finished with exit code 0

备注说明

1.对于JVM的编译，静态方法是存储在方法区(只有一份)
  所以对于SynchronizedStaticMethodDemo对象实例其本质方法add的访问都是一份
  由于synchronized修饰，线程只能顺序访问
2.关于类加载信息在jvm中的

synchronizedStaticMethodDemo1.add();跟SynchronizedStaticMethodDemo.add()调用是一样的

package com.gaoxinfu.demo.jdk.rt.java.lang.thread.synchronize;

import java.util.concurrent.TimeUnit;

/**
 * @Description:
 * @Author: gaoxinfu
 * @Date: 2020-06-13 18:22
 */
public class SynchronizedStaticMethodDemo {

   synchronized static void add() {
        System.out.println("大家好，我是线程 = " + Thread.currentThread().getName()+",执行需要耗时5s,请稍等");
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Thread thread1=new Thread(()->{
            SynchronizedStaticMethodDemo.add();
        },"thread-1");
        thread1.start();
        Thread thread2=new Thread(()->{
            SynchronizedStaticMethodDemo.add();
        },"thread-2");
        thread2.start();
    }
}
非静态方法锁
package com.gaoxinfu.demo.jdk.rt.java.lang.thread.synchronize;

import java.util.concurrent.TimeUnit;

/**
 * @Description:
 * @Author: gaoxinfu
 * @Date: 2020-06-14 10:13
 */
public class SynchronizedNonStaticMethodDemo {


    synchronized void add() {
        System.out.println("大家好，我是线程 = " + Thread.currentThread().getName()+",执行需要耗时5s,请稍等");
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        SynchronizedNonStaticMethodDemo SynchronizedNonStaticMethodDemo1=new SynchronizedNonStaticMethodDemo();
        SynchronizedNonStaticMethodDemo SynchronizedNonStaticMethodDemo2=new SynchronizedNonStaticMethodDemo();

        Thread thread1=new Thread(()->{
            SynchronizedNonStaticMethodDemo1.add();
        },"thread-1");
        thread1.start();
        Thread thread2=new Thread(()->{
            SynchronizedNonStaticMethodDemo2.add();
        },"thread-2");
        thread2.start();
    }
}

控台输出

大家好，我是线程 = thread-1,执行需要耗时5s,请稍等
大家好，我是线程 = thread-2,执行需要耗时5s,请稍等

Process finished with exit code 0

由于是非静态方法，只是对当前对象加锁，因此上面两个线程是互不影响的

对象锁
package com.gaoxinfu.demo.jdk.rt.java.lang.thread.synchronize;

import java.util.concurrent.TimeUnit;

/**
 * @Description:对象锁
 * @Author: gaoxinfu
 * @Date: 2020-06-13 18:53
 */
public class SynchronizedObjectDemo {

    void add() {
        synchronized (SynchronizedObjectDemo.class) {
            System.out.println("大家好，我是线程 = " + Thread.currentThread().getName()+",执行需要耗时5s,请稍等");
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {

        SynchronizedObjectDemo SynchronizedObjectDemo1=new SynchronizedObjectDemo();
        SynchronizedObjectDemo SynchronizedObjectDemo2=new SynchronizedObjectDemo();

        Thread thread1=new Thread(()->{
            SynchronizedObjectDemo1.add();
        },"thread-1");
        thread1.start();
        Thread thread2=new Thread(()->{
            SynchronizedObjectDemo2.add();
        },"thread-2");
        thread2.start();
    }
}

执行也是先将线程1执行完毕之后，再执行线程2 因为我们锁住的是整个对象，对象的所有实例的方法调用都会遵从顺序调用

大家好，我是线程 = thread-1,执行需要耗时5s,请稍等
大家好，我是线程 = thread-2,执行需要耗时5s,请稍等

Process finished with exit code 0

synchronized锁的范围

锁定代码块
    void add() {
        synchronized (this) {
                    System.out.println("大家好，我是线程 = " + Thread.currentThread().getName()+",执行需要耗时5s,请稍等");
                    try {
                        TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
锁定方法
synchronized void add() {
        System.out.println("大家好，我是线程 = " + Thread.currentThread().getName()+",执行需要耗时5s,请稍等");
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
东山富哥
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
nodejs中的锁——async-lock解析
weixin_33882443的博客
02-12 4366
概数 async-lock的npm地址 https://www.npmjs.com/package... 为什么是async-lock？ 因为我见其下载量比较大（在我发现的所有类似库中是最大的）且最近更新时间较近。 场景 在异步函数中，由于存在异步操作，对此函数的A，B两次执行会出现结束次序不可控。即A先执行，却比B后退出函数。 对于数...
Java并发 synchronized锁住的内容解析
08-25
主要介绍了Java并发 synchronized锁住的内容解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
（11）Node.js 核心模块fs – 同步函数（ synchronization ）
Java田根旺
01-05 589
一、介绍图 再执行程序1时，把1.1和1.2丢到事件队列中，去异步执行，这样提高了效率，让执行速度更快。 如果使用同步，需要等待程序1完全执行完成后，才能去执行程序2。 二、同步函数 • 在主程序中自上而下运行 • 例如：去火车站排队买票 三、异步函数 • 通过回调函数在事件队列中运行 • 例如：委托黄牛买票，票买好后通知我（无需等待，可以做其他事） 四、何时使用同步函数，何时使用异步函数？ 再考虑性能的时候，执行效率的时候，使用异步函数。如果不考虑效率，需要进行验证判断，成
Synchronized锁详解
lixiangchibang的博客
07-31 4663
Synchronized锁详解
java synchronized到底锁住的是什么
你究竟是想一辈子卖糖水，还是希望获得改变世界的机会？
04-19 9895
刚学java的时候，只知道synchronized一个线程锁，能够锁住代码，但是它真的能像我想的那样，能够锁住代码吗？ 在讨论之前先看一下项目中常见关于synchronized的用法： public synchronized void syncCurrentObject() { System.out.println(Thread.currentThread().ge
介绍一下Syncronized锁，如果用这个关键字修饰一个静态方法，锁住了什么？如果修饰成员方法，锁住了什么？
u014138443的博客
05-25 2148
synchronized修饰静态方法以及同步代码块的synchronized (类.class)用法锁的是类，线程想要执行对应同步代码，需要获得类锁。 synchronized修饰成员方法，线程获取的是当前调用该方法的对象实例的对象锁。 ...
Java Synchronized锁失败案例及解决方案
08-19
主要介绍了Java Synchronized锁失败案例及解决方案,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java synchronized锁升级jol过程详解
08-19
主要介绍了Java synchronized锁升级jol过程详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
技术分享-java synchronized锁机制.pptx
06-11
由浅入深解析synchronized锁的机制，各种锁的概念的介绍，膨胀过程，基于redis的分布式锁demo。
Java使用synchronized实现互斥锁功能示例
08-19
主要介绍了Java使用synchronized实现互斥锁功能,结合实例形式分析了Java使用synchronized互斥锁功能简单实现方法与操作技巧,需要的朋友可以参考下
nodeJs操作文件同步的方法合集
08-10
NodeJs 文件操作 同步执行库 提供了删除文件夹 修改文件所属用户(linux系统)
syncronized锁深入
zhaozhenzuo的专栏
08-20 1071
syncronized同步，有无锁，偏向锁状态，轻量级锁，重量级锁四个状态。   重量级锁，底层是使用操作系统monit enter及moniter exit原语进行同步，会导致线程阻塞。而轻量级锁则是优化当竞赛不激烈时，尝试cas自旋获取锁。   轻量级锁，在只有一个线程获取锁之后，第二次再进入同步块尝试获取锁后，还是会有一次cas替换操作。为了减少这步操作，引出了偏向锁。    线程第一
synchronized详解
三分恶的博客
02-10 6308
synchronized是Java多线程中元老级的锁，也是面试的高频考点，让我们来详细了解synchronized吧。
synchronized锁使用方式和实现原理
cbb
03-14 1145
前言 在java开发中,锁是我们常用的一种处理并发问题的方式.面试的时候 也会被问道锁的使用,一般都会涉及这两个的对比这里总结一下. 1. synchronized synchronized是java的一个关键字,它是jvm层上的,加锁方式有 方法锁，对象锁synchronized(this)，类锁synchronized(Demo.Class) 它的用法有 普通同步方法，锁是当前实例对象 静态同步方法，锁是当前类的class对象 同步方法块，锁是括号里面的对象 synchronized 锁是怎么实现
synchronized锁分析
xad707348125的专栏
07-19 5006
一、   引言 JAVA是一门极易入门的语言，这一点尤其表现在JAVA中对象锁的使用和多线程编程上。所谓对象锁，就是可以直接在JAVA的任意Object加锁（synchronized），也可以在通过任意Object进行线程的阻塞（Object.wait()）和唤醒（Object.notify() or Object.notifyAll()），这种面向对象的锁与C系中的Mutex和Semaphor
关键字面试题参考
a904763127的博客
03-09 252
● 请你讲讲Java里面的final关键字是怎么用的？ 考察点：关键字 参考回答：当用final修饰一个类时，表明这个类不能被继承。也就是说，如果一个类你永远不会让他被继承，就可以用final进行修饰。final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。“使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修...
一道面试题比较synchronized和读写锁
玩儿
05-24 408
一、科普定义 这篇博文的两个主角“synchronized”和“读写锁” 1）synchronized 这个同步关键字相信大家都用得比较多，在上一篇“多个线程之间共享数据的方式”中也详细列举他的应用，在这就不多说只做几点归纳： Java提供这个关键字，为防止资源冲突提供的内置支持。当任务执行到被synchronized保护的代码片段的时候，它检查锁是否可用，然后获取锁，执行代码，释放锁...
nodeJS实现方法的同步效果（去异步）
强者的博客
12-03 9860
转载至:http://www.jianshu.com/p/43fc67a0e526 nodeJS实现方法的同步效果（去异步） 前言： nodeJS最大的特点就是其异步操作，其后边方法的执行不会等到前边方法执行完才去运行，而是同时执行好几个方法，这种方式在给我们提高效率的同时也给开发多多少少带来了不便，有时候我们不要求有这种效果的出现，这时候就需要进行去异步操作。 node的去异步方
Synchronized锁总结
梦中注定的博客
07-06 714
Synchronized锁（内置锁）总结 1 概念 ​ 从1.0版本开始，Java中每一个对象都有一个内部锁。如果一个方法声明时有synchronized关键字，那么对象的锁将保护整个方法。也就是说要调用这个方法，线程必须获得内部对象锁。 先看一下几个方法的解释： void notifyAll():解除在这个对象上调用wait方法的那些线程的阻塞状态。该方法只能在同步方法或同步块中调用。如果当前线程不是对象锁的所有者，该方法会抛出一个异常。 void notify():随机选择一个在这个对象上调用wai
介绍一下synchronized锁升级
最新发布
03-07
Synchronized锁升级是指在Java虚拟机中，对于Synchronized锁的实现进行优化，以提高锁的性能和并发度。具体来说，Synchronized锁升级包括三个阶段：偏向锁、轻量级锁和重量级锁。在偏向锁阶段，锁对象被标记为偏向锁...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

东山富哥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值