【JUC】04-synchronized关键字

最新推荐文章于 2024-09-16 21:37:07 发布
最新推荐文章于 2024-09-16 21:37:07 发布
阅读量388 收藏 5
点赞数 4
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45722630/article/details/141105345
版权

1. 悲观锁与乐观锁

  • 悲观锁：认为自己在使用数据的时候一定会有别的线程来修改数据，因此在获取数据的时候会先加锁，确保数据不会被别的线程修改。synchroized和Lock的实现类都是
  • 乐观锁：认为自己在使用数据时不会有别的线程修改数据或资源，所以不会加锁。如果这个数据没有被更新，当前线程将自己修改的数据成功写入。如果数据已被修改，则根据自定义不同操作，比如放弃修改，重抢试锁。判断规则：1. 版本号机制Version、2. CAS算法，Java原子类中的递增操作就是通过CAS自旋实现

2. synchronized关键字

 synchronized锁的是整个资源类。同一时刻，只能有一个线程访问被synchronized修饰的方法。

// 线程操作资源类
class Phone{
    public synchronized void sendEmail() {
        System.out.println("sendEmail");
    }
    // 被synchronized修饰，同一时刻，只能允许一个线程访问类中的一个synchronized方法
    public synchronized void sendSMS() {
        System.out.println("sendSMS");
    }
    // 没有被synchronized修饰，多个线程可以同时访问
    public void hello() {
        System.out.println("Hello");
    }
}

public class demo02 {
    public static void main(String[] args) {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();
        new Thread(()->{
            phone1.sendEmail();
        }, "t1").start();

//        try {
//            TimeUnit.MILLISECONDS.sleep(200);
//        } catch (InterruptedException e) {
//            throw new RuntimeException(e);
//        }
        new Thread(()->{
            phone1.sendSMS();
            // phone2.hello();
            // phone1.sendSMS();
        }, "t2").start();
    }
}

 以下情况会先打印 Email ：

// 线程操作资源类
class Phone{
    public synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("sendEmail");
    }
    public synchronized void sendSMS() {
        System.out.println("sendSMS");
    }
}

public class demo02 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{
            phone.sendEmail();
        }, "t1").start();

        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        new Thread(()->{
            phone.sendSMS();
        }, "t2").start();
    }
}

 先打印 SMS ：

public static void main(String[] args) {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();
        new Thread(()->{
            phone1.sendEmail();
        }, "t1").start();

        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        new Thread(()->{
            // phone.sendSMS();
            // phone2.hello();
            phone2.sendSMS();
        }, "t2").start();
    }

 方法被static和synchronized修饰时，synchronized锁是类锁而不是实例锁，也即锁的是模板类。
 先打印 Email :

// 线程操作资源类
class Phone{
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("sendEmail");
    }

    public static synchronized void sendSMS() {
        System.out.println("sendSMS");
    }

    public void hello() {
        System.out.println("Hello");
    }
}

public class demo02 {
    public static void main(String[] args) {
        Phone phone1 = new Phone();
        // Phone phone2 = new Phone();
        new Thread(()->{
            phone1.sendEmail();
        }, "t1").start();

        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        new Thread(()->{
            // phone.sendSMS();
            // phone2.hello();
            phone1.sendSMS();
        }, "t2").start();
    }
}

public class demo02 {
    public static void main(String[] args) {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();
        new Thread(()->{
            phone1.sendEmail();
        }, "t1").start();

        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        new Thread(()->{
            // phone.sendSMS();
            // phone2.hello();
            phone2.sendSMS();
        }, "t2").start();
    }
}

  static synchronized锁的是Object模板类，synchronized锁是实例锁。两个不是同一把锁。
  打印SMS：

// 线程操作资源类
class Phone{
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("sendEmail");
    }

    public synchronized void sendSMS() {
        System.out.println("sendSMS");
    }

    public void hello() {
        System.out.println("Hello");
    }
}

public class demo02 {
    public static void main(String[] args) {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();
        new Thread(()->{
            phone1.sendEmail();
        }, "t1").start();

        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        new Thread(()->{
            // phone.sendSMS();
            // phone2.hello();
            phone2.sendSMS();
        }, "t2").start();
    }
}


    public static void main(String[] args) {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();
        new Thread(()->{
            phone1.sendEmail();
        }, "t1").start();

        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        new Thread(()->{
            // phone.sendSMS();
            // phone2.hello();
            phone1.sendSMS();
        }, "t2").start();
    }

在这里插入图片描述
 有两个monitorexit是为了防止出现异常，保证锁一定会被释放。代码中有抛异常的只会有一个monitorexit。
在这里插入图片描述

public class demo03 {
    Object o = new Object();
    Book book = new Book();

    // 一般来说，会有一个monitorenter和两个monitorexit。但在代码中，直接写throw异常，则只会有一个monitorenter和一个monitorexit
    public void test01() {
        /**
         * 任何一个对象都可以成为一个锁 class Book extends Object
         * 在HotSpot虚拟机中，monitor采用ObjectMonitor实现
         * 每个对象天生都带着一个对象监视器
         * 每一个被锁住的对象都会和 Monitor关系起来
         */
        synchronized (book) {
            System.out.println("Hello World");
        }
    }

    // 设置ACC_SYNCHRONIZED字段，会先持有锁，再执行方法
    public synchronized void test02() {
        System.out.println("Hello World");
    }

    // 设置ACC_STATIC, ACC_SYNCHRONIZED字段，判别是class锁，还是实例锁
    public static synchronized void test03() {
        System.out.println("Hello");
    }

    public static void main(String[] args) {
        System.out.println("Hello");
    }
}
CRE_MO
关注
多线程 - voliate 关键字
学无止境
04-06 1217
volatile 是 Java 中的关键字，用于修饰变量。它的作用是强制对被修饰的变量的写操作立即刷新到主存中，并强制对该变量的读操作从主存中读取最新的值，而不是使用缓存中的值。
JUC学习 - 线程安全和synchronized
TyuIn的博客
11-25 106
一、线程安全和synchronized 1、什么是线程安全？ 当多个线程去访问同一个类（对象或方法）的时候，该类都能表现出正常的行为（与自己预想的结果一致），那我们就可以所这个类是线程安全的。 看一段代码： public class ThreadSafeDemo { static int num = 0; public static void m1() { for (int i = 0; i < 10000; i++) { num++;
Java基础-Synchronized关键字
花明的博客
08-10 149
概述 Synchronized是Java中保证线程安全的使用较多的一个关键字 使用场景 修饰实例方法，对当前实例对象this加锁public class Synchronized { public synchronized void aaa(){ } } 修饰静态方法，对当前类的Class对象加锁public class Synchronized { public synchronized static aaa(){ } } 修饰代码块，指定一个加锁的对象，给对象
Java中的悲观锁机制----synchronized 关键字原理
m0_53327171的博客
03-16 1429
sychronized是Java原生的一个同步锁机制，可以保证在多线程并发的情况下，仅允许一个线程执行加锁的方法和代码块，保证了线程安全。在Java1.5之前，sychronized关键字实现的同步锁，底层是一种悲观锁的理念，在1.6版本后，Java对该关键字进行了优化，使得该锁在某些情况下呈现轻量锁的作用（这个后面介绍，先有个印象）
JUC---volatile关键字
qq_40823910的博客
05-18 185
volatile
多线程-synchronized关键字
b422761838的专栏
03-18 124
synchronized是java多线程很常用的关键字，可用它对线程jia加锁，在一个线程执行的时候，阻塞其他线程的访问，可用于类，变量和方法上，synchronized作用的是对象，如果使用不当的话，synchronized锁并不会生效，举个例子 package com.qingwei.springboot.juc; /** * Created by kongwc on 2020/3/...
JUC-synchronized
weixin_39248750的博客
05-12 256
Java采用synchronized关键字、以互斥同步的方式的解决线程安全问题，那么什么是线程安全呢？这里引用《Java并发编程实战》作者Brian Goetz给出的定义： “当多个线程同时访问一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替执行，也不需要进行额外的同步，或者在调用方进行任何其他的协调操作，调用这个对象的行为都可以获得正确的结果，那就称这个对象是线程安全的。”—— Brian Goetz 一、synchronized的使用 （一）使用方法 ......
juc尚硅谷-自学笔记
03-29
6. **Atomic类**：这些类提供了一种在不使用synchronized关键字的情况下实现原子操作的方法，如`AtomicInteger`、`AtomicLong`等，它们保证了在多线程环境下的数据一致性。 7. **ConcurrentHashMap**：它是线程安全...
Java 多线程与并发(14-26)-JUC集合- CopyOnWriteArrayList详解.pdf
07-27
与传统的`Vector`相比，它在并发环境下的性能更好，因为`Vector`的方法使用`synchronized`关键字来实现线程安全，这可能导致整个集合的锁定，从而降低并发效率。 - **性能优势**：虽然`CopyOnWriteArrayList`在写...
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1119
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
xiaocaij_icai的博客
09-15 157
");
基于SpringBoot的考研资讯平台设计与实现
linzhongshu的专栏
09-13 889
对于本次的系统开发来看，它主要是把我以前所学的知识进行了一次综合的应用。经过这次毕业设计的制作它主要是把我以前所学的理论知识应用到社会实践当中。通过这一次的考研资讯平台的设计与实现它能够有效把计算机知识与实际问题相互应用，通过计算机网络技术来解决学生生活当中的实际问题，从而提高我的编程能力。虽然在这次毕业设计当中我遇到了很多的问题和困难，但是通过不断的调试和老师的帮助让我圆满的完成了这次毕业设计。
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 926
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
spring security中几大组件的作用和执行顺序
阿信今天的代码没bug的博客
09-11 349
spirng security中的几大组件的差异和执行顺序
模拟面试后端开发复盘
Java小白的博客 致力分享每一天学到的知识
09-11 1210
一般来说系统的开发和设计思路的话，就是一般现在的项目基本上都是前后端分离架构来实现的，所以在项目的设计时，要分层次结构来划定。前后端分离架构中，前端一般是有专业的前端工程师来写的，因此我们步需要过分的关注前端，可以在github上找到相关的前端项目即可。
计算机毕业设计 网上书店系统 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-16 852
本文介绍了一款基于Java、SpringBoot和Vue.js技术的网上书店系统。该系统为管理员、用户和卖家提供了图书信息浏览、订单管理、个人中心管理等功能，旨在打造一个便捷、高效的在线购书平台。系统通过优化图书销售流程，提升用户体验，推动出版行业的数字化转型，促进知识传播和文化交流。
使用API有效率地管理Dynadot域名，查看域名服务器（NS）信息
Dynadot_tech的博客
09-12 1072
Dynadot是通过ICANN认证的域名注册商，自2002年成立以来，服务于全球108个国家和地区的客户，为数以万计的客户提供简洁，优惠，安全的域名注册以及管理服务。Dynadot.com提供的API是专为效率而构建的高级域名管理和获取工具包。使用Dynadot API，可以查看某一域名DNS设置的域名服务器（Name server）信息。
07_Python数据类型_集合
最新发布
fx_yzjy101的专栏
09-16 419
可以使用大括号 {} 或者 set() 函数来创建集合。如果使用大括号，则至少需要包含一个元素；如果使用 set()，则可以创建一个空集合。# 创建一个空集合# 创建一个包含一个元素的集合# 创建一个包含几个元素的集合。
"Java-JUC-多线程 进阶：遇见狂神说的JUC并发编程进阶版概要
与传统的synchronized关键字相比，Lock可以提供更高级的功能，例如可重入锁、读写锁等。Lock的使用可以避免线程之间的竞争条件，保证多线程程序的正确性和一致性。 然后，课程介绍了生产者和消费者模式。这是一种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

CRE_MO

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

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

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

打赏作者

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

抵扣说明：

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

余额充值