高并发处理之Synchronized学习(五)

最新推荐文章于 2023-04-16 23:48:47 发布
最新推荐文章于 2023-04-16 23:48:47 发布
阅读量148 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/G_whang/article/details/101858447
版权

访问同步方法的7种情况
1.两个线程同时访问一个对象的同步方法
两个不同的实例，访问同一个对象的同步方法，所运用的锁默认使用的是this，以this对象作为他的锁，所以说，他们使用的是同一把锁，在争抢同一把锁的时候，他们必然要相互等待，因为只能有一个方法持有锁
代码如下：

package com.gwh.lock.test;

/**
 * 对象锁 实例2 方法锁形式
 * 1.两个线程同时访问一个对象的同步方法
 */
public class SynchronizedObjectMethod3 implements  Runnable{
    public static SynchronizedObjectMethod3 objectMethod3=new SynchronizedObjectMethod3();
    @Override
    public void run() {
        method();
    }
    public synchronized void  method(){
        System.out.println("我是对象锁的方法修饰符形式，我叫"+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"执行结束");
    }

    public static void main(String[] args) {
        try {
            Thread t1=new Thread(objectMethod3);
            Thread t2=new Thread(objectMethod3);
            t1.start();
            t2.start();
            while (t1.isAlive()||t2.isAlive()){

            }
            System.out.println("finished");

        }catch (Exception e){
            e.printStackTrace();
        }
    }


}

结果如下
在这里插入图片描述
2.两个线程访问的是两个对象的同步方法
两个线程访问的是两个对象的同步方法，他们之间是不会受到干扰的，原因是，他们真正所使用的锁对象不是同一个，所以不敢扰
代码如下：

package com.gwh.lock.test;

/**
 * 对象锁实例1 代码块形式
 * 2.两个线程访问的是两个对象的同步方法
 */
public class SychronizedObjectCodeBlock2 implements  Runnable{
    public static SychronizedObjectCodeBlock2 objectCodeBlock2=new SychronizedObjectCodeBlock2();
    //不是用this是因为，可能在同一段代码中，会有多个synchronized代码块，他们不会ishi同时一个执行其他的不执行，所以我们新建一个锁对象
    Object lock1=new Object();
    Object lock2=new Object();

    @Override
    public void run() {
        //使用锁的对象不同会对执行的结果带来不同的影响
        synchronized (lock1){
            try {
                System.out.println("我是对象锁1的代码块形式，我叫"+Thread.currentThread().getName());
                Thread.sleep(3000);
                System.out.println(Thread.currentThread().getName()+"对象锁1执行结束");
            }catch (Exception e){
                e.printStackTrace();
            }
        }
      /* synchronized (lock2){
           try {
               System.out.println("我是对象锁2的代码块形式，我叫"+Thread.currentThread().getName());
                Thread.sleep(3000);
                System.out.println(Thread.currentThread().getName()+"对象锁2执行结束");
           }catch (Exception e){
               e.printStackTrace();
            }
       }
*/
    }

    public static void main(String[] args) {
        try {
            Thread t1=new Thread(objectCodeBlock2);
            Thread t2=new Thread(objectCodeBlock2);
            t1.start();
            t2.start();
            while (t1.isAlive()||t2.isAlive()){

            }

            System.out.println("finished");

        }catch (Exception e){
            e.printStackTrace();
        }
    }

}

结果如下：
在这里插入图片描述
3.两个线程访问的是Synchronized的静态方法
他们会一个一个的执行，锁生效
代码如下：

package com.gwh.lock.test;

/**
 * 类锁的第一种形式，static形式
 * 3.两个线程访问的是Synchronized的静态方法
 */
public class SynchronizedClassStatic4 implements  Runnable{

    public static SynchronizedClassStatic4 classStatic4=new SynchronizedClassStatic4();
    public static SynchronizedClassStatic4 classStatic5=new SynchronizedClassStatic4();

    @Override
    public void run() {
        method();
    }

    public  static synchronized void method(){ System.out.println("我是类锁的第一种形式：static形式，我叫"+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"执行结束");


    }

    public static void main(String[] args) {
        try {
            Thread t1=new Thread(classStatic4);
            Thread t2=new Thread(classStatic5);
            t1.start();
            t2.start();
            while (t1.isAlive()||t2.isAlive()){

            }
            System.out.println("finished");

        }catch (Exception e){
            e.printStackTrace();
        }
    }

}

结果如下：
在这里插入图片描述
4.同时访问同步和非同步方法
非同步方法不会受到影响
因为synchronized这个关键字，只会作用于你修饰的一个方法中，他不会影响到没加修饰符的方法
代码如下：

package com.gwh.lock.test;

/**
 * 4.同时访问同步和非同步方法
 */
public class SynchronizedYesAndNo6 implements  Runnable{
  public static SynchronizedYesAndNo6 yesAndNo6=new SynchronizedYesAndNo6();

    @Override
    public void run() {
        if(Thread.currentThread().getName().equals("Thread-0")){
            method1();
        }else {
            method2();
        }

    }

    public synchronized void method1(){
        System.out.println("我是加锁的方法，我叫"+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"执行结束");
    }

    public void method2(){
        System.out.println("我是没加锁的方法，我叫"+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"执行结束");
    }

    public static void main(String[] args) {
        try {
            Thread t1=new Thread(yesAndNo6);
            Thread t2=new Thread(yesAndNo6);
            t1.start();
            t2.start();
            while (t1.isAlive()||t2.isAlive()){

            }
            System.out.println("finished");

        }catch (Exception e){
            e.printStackTrace();
        }
    }

}

结果如下
在这里插入图片描述
5.访问一个对象的不同的普通同步方法（非static）
synchronized虽然没有明确指定使用哪个锁对象，但是他本质上是指定了this作为他的锁，所以对于同一个实例来讲，这两个方法所使用的this是一样的，所以这两个方法没法同时运行
代码如下：

package com.gwh.lock.test;

/**
 * 访问一个类的不同的普通同步方法
 */
public class synchronizedDifferentMethod7 implements  Runnable{
    public static synchronizedDifferentMethod7 differentMethod7=new synchronizedDifferentMethod7();
    @Override
    public void run() {
        if(Thread.currentThread().getName().equals("Thread-0")){
            method1();
        }else {
            method2();
        }

    }

    public synchronized void method1(){
        System.out.println("我是加锁的方法，我叫"+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"执行结束");
    }

    public synchronized void method2(){
        System.out.println("我是加锁的方法，我叫"+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"执行结束");
    }

    public static void main(String[] args) {
        try {
            Thread t1=new Thread(differentMethod7);
            Thread t2=new Thread(differentMethod7);
            t1.start();
            t2.start();
            while (t1.isAlive()||t2.isAlive()){

            }
            System.out.println("finished");

        }catch (Exception e){
            e.printStackTrace();
        }
    }


}

结果如下：
在这里插入图片描述
6.同时访问静态Synchronized和非静态Synchronized方法
两个方法会同时运行，原因是：他们所指定的锁对象，不是同一个锁
代码如下：

package com.gwh.lock.test;

/**
 * 同时访问静态Synchronized和非静态Synchronized方法
 */
public class SynchronizedStaticAndNormal8  implements  Runnable{
    public static SynchronizedStaticAndNormal8 staticAndNormal8=new SynchronizedStaticAndNormal8();
    @Override
    public void run() {
        if(Thread.currentThread().getName().equals("Thread-0")){
            method1();
        }else {
            method2();
        }

    }

    public synchronized static void method1(){
        System.out.println("我是静态加锁的方法1，我叫"+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"执行结束");
    }

    public synchronized void method2(){
        System.out.println("我是非静态的加锁的方法2，我叫"+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"执行结束");
    }

    public static void main(String[] args) {
        try {
            Thread t1=new Thread(staticAndNormal8);
            Thread t2=new Thread(staticAndNormal8);
            t1.start();
            t2.start();
            while (t1.isAlive()||t2.isAlive()){

            }
            System.out.println("finished");

        }catch (Exception e){
            e.printStackTrace();
        }
    }

}

结果如下：
在这里插入图片描述
7.方法抛出异常后，会释放锁
Synchronized修饰的类，抛出异常后会释放锁，lock类抛出异常后，不会释放锁
代码如下：

package com.gwh.lock.test;

/**
 * 方法抛出异常后，会释放锁。展示不抛出异常前，和抛出异常后的对比
 * 一旦抛出了异常，第二个线程会立刻进入同步方法，意味着锁已经释放
 */
public class SynchronizedException9 implements  Runnable{
    public static SynchronizedException9 exception9=new SynchronizedException9();
    @Override
    public void run() {
        if(Thread.currentThread().getName().equals("Thread-0")){
            method1();
        }else {
            method2();
        }

    }

    public synchronized  void method1(){
        System.out.println("我是方法1，我叫"+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
            throw new Exception();
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"执行结束");
    }

    public synchronized void method2(){
        System.out.println("我是方法2，我叫"+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"执行结束");
    }

    public static void main(String[] args) {
        try {
            Thread t1=new Thread(exception9);
            Thread t2=new Thread(exception9);
            t1.start();
            t2.start();
            while (t1.isAlive()||t2.isAlive()){

            }
            System.out.println("finished");

        }catch (Exception e){
            e.printStackTrace();
        }
    }


}

结果如下： 在这里插入图片描述 总结： 1.一把锁只能同时被一个线程获取，没有拿到锁的线程必须等待
2.每个实例都对应有自己的一把锁，不同实例之间互不影响；例外：锁对象是*.class以及Synchronized修饰的是static方法的时候，所有对象共用同一把类锁
3.无论是方法正常执行完毕或者是方法抛出异常，都会释放锁

问题：如果说，我在一个被Synchronized所修饰的方法中，访问一个不被Synchronized修饰的方法时，此时是线程安区的吗？
线程不安全，因为被访问的方法没有被Synchronized所修饰，所以他是会被多个线程共同访问的

智航云科技
关注
专栏目录
Java高并发编程实战4，synchronized与Lock底层原理
学Java，找哪吒
09-23 4888
Java高并发编程实战系列，打造精品专栏。
并发编程系列之Synchronized实现原理
Nicky's blog
04-10 1130
并发编程系列之Synchronized实现原理。偏向锁：当一个线程获取到锁后，这把锁就是偏向锁，偏向锁是在锁对象的对象头中记录一个线程id,然后该线程再次获取锁时，直接获取就可以 轻量级锁：如果有第二个线程来竞争锁，这时就会升级为轻量级锁，轻量级锁是不会阻塞线程的，其底层是通过自旋实现的。自旋是通过CAS获取一个预期的标识，如果没获取到，就会一直循环获取，获取到标识，也就标识获取到锁 重量级锁：如果轻量级锁一直自旋也获取不到锁，才会升级为重量级锁，重量锁是会阻塞线程的，也称之为重锁
synchronized并发讲解
gaston的博客
03-16 440
syncronized的作用：能够保证在同一时刻最多只有一个线程执行该段代码，以达到保证并发安全的效果。 syncronized的地位： 1.synchronized是java的关键字，被java语言原生支持 2.是最基本的互斥同步手段 3.是并发编程中的元老级角色，是并发编程的必学内容 在这里先模拟如果不使用synchronized的原始错误，模型：开启两个线程对一个变量i从0开始i+...
并发解决方案synchronized同步锁
最新发布
m0_37938849的博客
04-16 310
管程是管理共享变量以及对共享变量的操作过程，让它们支持并发。目前比较广泛使用的管程模型是MESI模型，另外的Hasen模型、Hoare模型可以适当了解，这里主要介绍MESI模型。MSEI模型通过入口等待队列、多个条件等待队列来解决线程间的同步问题。具体分析：当多个线程共同访问共享变量时，只能有一个线程获取到锁，那没有获取到锁的线程会进入到同步等待队列中，当获取锁的线程执行完业务逻辑，释放锁后会唤醒同步等待队列中的线程来获取锁，从而执行业务逻辑。
Java并发处理：synchronized关键字
ruoxiyun的博客
10-08 142
synchronized关键字，它包括两种用法：synchronized方法和synchronized块。 1. synchronized 方法：通过在方法声明中加入 synchronized关键字来声明synchronized 方法。如：public synchronized void accessVal(int newVal)；synchronized方法控制对类成员变量的访问：每个...
并发-synchronized详解
yz_ylfc的博客
04-17 488
并发-synchronized详解设计同步器的意义如何解决线程并发安全问题？同步器的本质就是加锁synchronized原理详解synchronized底层原理Monitor监视器锁什么是monitor？对象的内存布局对象头锁的膨胀升级过程偏向锁轻量级锁自旋锁锁消除逃逸分析 设计同步器的意义 多线程编程中，有可能会出现多个线程同时访问同一个共享、可变资源的情况，这个资源我们称之其为临界资源；这种资源可能是：对象、变量、文件等。 共享：资源可以由多个线程同时访问 可变：资源可以在其生命周期内被修改 引出的
高并发处理之Synchronized学习（一）
G_whang的博客
10-01 217
Synchronized的作用 官方介绍： 同步方法支持一种简单的策略来防止线程干扰和内存一致性错误：如果一个对象对多个线程可见，则对该对象变量的所有读取和写入都是通过同步方法完成的。 用一句话说出Synchronized的作用： 能够保证在同一时刻最多只有一个线程执行该段代码，以达到保证并发安全的效果。 如果说一段代码被Synchronized所修饰，那么被修饰的这段代码，就会以原子的方式执行，...
JUC代码收集，java高并发多线程学习
03-31
本资源"JUC代码收集，java高并发多线程学习"显然是一个专注于探讨和学习JUC库的资料包。 JUC库包含多个子包，如`concurrent`, `atomic`, `locks`等，每个子包都有其特定的功能和用途： 1. **concurrent**：这是JUC...
Java并发编程与高并发解决方案-学习笔记.pdf
03-16
并发编程与高并发解决方案的学习笔记中，首先对并发与高并发进行了基本概念的介绍。并发指的是同时存在多个执行单元，但并不一定同时发生；而高并发是指系统能够同时处理很多的请求，这对于互联网分布式系统架构设计...
高并发多线程处理demo-java.rar
07-10
在Java编程领域，高并发和多线程是关键的技术之一，尤其在服务器端应用和大数据处理中至关重要。这个"高并发多线程处理demo-java.rar"压缩包提供了一个实际的Java实现，展示了如何构建一个并发队列来接收数据，并...
高并发处理之Synchronized学习（三）
G_whang的博客
10-01 164
第二个用法：类锁 概念：java类可能有很多个对象，但只有1个class对象 对于任何一个java类来讲，他都有很多实例，比如student类,可以创建很多实例，如：小明同学，小张同学，小王同学。。。 但是对于Class对象来说只有一个，所以不管是对于小明同学，还是小张同学。。这些实例，都会有一个对应的这个类的对象，而这个类对象，只有一个。 本质：所谓的类锁，不过是class对象的锁而已 不同的实...
【JavaEE】多线程之线程安全（synchronized篇），死锁问题
weixin_69417428的博客
01-16 2284
多线程的线程安全问题，以及死锁问题的详细讲解~~
深入理解synchronized锁和使用场景
iloveoverfly的博客
02-28 1139
synchronized使用场景 在java中，提供了synchronized实现共享对象的并发访问。当一个线程试图访问同步代码块时，它首先必须得到锁，退出或抛出异常时必须释放锁。通常有三种使用方式，如下： 对于普通同步方法，锁是当前实例对象。 对于静态同步方法，锁是当前类的Class对象。 对于同步方法块，锁是Synchonized括号里配置的对象。 线程安全类 在java8源码中，提供...
synchronized原理、流程、异常处理
心比天高，仗剑走天涯，保持热爱，奔赴向梦想！
11-02 2696
讲述synchronized原理，和工作流程，为什么是重量级锁就慢，为什么是不公平锁，在那些情况下不要使用锁，遇到异常是否会导致锁意外释放
Java 锁机机制——浅析 Synchronized
IT小小鸟～～
07-23 9361
剖析 SynchronizedSynchronized 介绍Synchronized 方面的文章网上有很多了。它主要是用来进行同步操作。也被称为重量级的锁，它的同步包括： 对于普通方法同步，锁是当前实例对象 对于静态方法同步，锁是当前类的 Class 对象 对于方法块同步，锁是 Synchronized 括号里的对象 那么如何理解锁是“对象”。Java 编程语言中号称一切皆对象。当我们 new 一个
面经手册 · 第15篇《码农会锁，synchronized 解毒，剖析源码深度分析！》
bugstack虫洞栈
10-29 2183
作者：小傅哥 博客：https://bugstack.cn 沉淀、分享、成长，让自己和他人都能有所收获！???? 一、前言 感觉什么都不会，从哪开始呀！ 这是最近我总能被问到的问题，也确实是。一个初入编程职场的新人，或是一个想重新努力学习的老司机，这也不会，那也不会，总会犯愁从哪开始。 讲道理，毕竟 Java 涉及的知识太多了，要学应该是学会学习的能力，而不是去背题、背答案，拾人牙慧是不会有太多收益的。 学习的过程要找对方法，遇到问题时最好能自己想想，你有哪些方式学会这些知识。是不感觉即使让你去百度搜，
Java并发编程系列之十：synchronized（1）
rhwayfun专栏
04-03 4076
在多线程并发访问资源（这类资源称为临街资源）的时候，由于割裂来了原子操作，所以会导致数据不一致的情况。为了避免这种情况，需要使用同步机制，同步机制能够保证多线程并发访问数据的时候不会出现数据不一致的情况。一种同步机制是使用synchronized关键字，这种机制也称为互斥锁机制，这就意味着同一时刻只能有一个线程能够获取到锁，获得的锁也被称为互斥锁。其他需要获取该互斥锁的线程只能被阻塞，直到获取到该锁
异常与锁的释放（synchronized ）
走马观花
10-16 6266
http://wangxinchun.iteye.com/blog/1801057 synchronized 获取的锁，在方法抛出异常的时候会自动解锁 Java代码   package com.horizon.thread.synchronize;     /**   * function:主要演示了 synchronized 获取的锁，在方法抛出异常的时候会自动解
深入解析Java并发：Synchronized与锁机制
"这份资料主要涵盖了Java高并发与多线程领域的面试重点，包括Synchronized、ReentrantLock以及Java线程池和内存模型的相关问题。它旨在帮助面试者准备相关面试，深入理解并发编程的核心概念和技术。" 在Java并发...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值