【第四章】JUC之多线程锁Synchronized#8种应用场景浅析

最新推荐文章于 2024-07-12 09:30:00 发布
最新推荐文章于 2024-07-12 09:30:00 发布
阅读量415 收藏 1
点赞数
分类专栏： JUC&JVM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LINHONG_1994/article/details/102824878
版权
笔记大纲
  • 标准访问，先打印短信还是邮件(先短信后邮件)
  • 停4秒在短信方法内，先打印短信还是邮件(先短信后邮件)
  • 普通hello方法，先打印短信还是hello(先Hello后短信)
  • 现在有两部手机，先打印短信还是邮件（先邮件后短信）
  • 两个静态同步方法，1部手机，先打印短信还是邮件（先短信后邮件）
  • 两个静态同步方法，2部手机，先打印短信还是邮件（先短信后邮件）
  • 1个静态同步方法，1个普通同步方法，1部手机，先打印短信还是邮件（先邮件后短信）
  • 1个静态同步方法，1个普通同步方法，2部手机，先打印短信还是邮件（先邮件后短信）
  • 总结Synchronized锁范围

例举Synchronized锁8种应用场景，主要目的是为了更好理解Synchronized锁范围。

一、标准访问，先打印短信还是邮件(先短信后邮件)
//先短信后邮件
import java.util.concurrent.TimeUnit;
class Phone {
    public synchronized void sendSMS() throws InterruptedException {
        System.out.println("==========sendSMS短信======");

    }

    public synchronized void sendEmail() throws InterruptedException {
        System.out.println("==========sendEmail邮件======");

    }
}
public class Lock_Problem8 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }, "AA").start();
        
		 Thread.sleep(200);//睡眠0.2S,区别线程谁先谁后
        
        new Thread(() -> {
            try {
                phone.sendEmail();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "BB").start();
    }
}
二、停4秒在短信方法内，先打印短信还是邮件(先短信后邮件)
//先短信后邮件
class Phone {
    public synchronized void sendSMS() throws InterruptedException {
        TimeUnit.SECONDS.sleep(4);  //睡眠4s
        System.out.println("==========sendSMS======");

    }
    public synchronized void sendEmail() throws InterruptedException {
        System.out.println("==========sendEmail======");

    }
}
三、普通hello方法，先打印短信还是hello(先Hello后短信)
//先Hello后短信
import java.util.concurrent.TimeUnit;
class Phone {
    public synchronized void sendSMS() throws InterruptedException {
        TimeUnit.SECONDS.sleep(4);  //睡眠4s
        System.out.println("==========sendSMS======");
    }
    //没有锁（非同一把锁），不受影响
    public void getHello() {
        System.out.println("==========hello,lindaxia======");
    }
    public static class Lock_Problem8 {
        public static void main(String[] args) throws InterruptedException {
            Phone phone = new Phone();
            Phone phone2 = new Phone();
            new Thread(() -> {
                try {

                    phone.sendSMS();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }, "AA").start();
            Thread.sleep(200);//睡眠0.2S

            new Thread(() -> {
                try {
                    phone.getHello();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "BB").start();
        }
    }
}
四、 现在有两部手机，先打印短信还是邮件（先邮件后短信）
//先邮件（等4s）后短信--不是同一把锁
import java.util.concurrent.TimeUnit;
class Phone {
    public synchronized void sendSMS() throws InterruptedException {
        TimeUnit.SECONDS.sleep(4);  //睡眠4s
        System.out.println("==========sendSMS======");

    }
    public synchronized void sendEmail() throws InterruptedException {
        System.out.println("==========sendEmail======");
    }
    public static class Lock_Problem8 {
        public static void main(String[] args) throws InterruptedException {
            Phone phone = new Phone();
            Phone phone2 = new Phone();
            new Thread(() -> {
                try {
                    phone.sendSMS();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }, "AA").start();
            Thread.sleep(200);//睡眠0.2S

            new Thread(() -> {
                try {
                      phone2.sendEmail();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "BB").start();
        }
    }
}
五、两个静态同步方法，1部手机，先打印短信还是邮件（,先短信后邮件）
//等4S,先短信后邮件
//静态方法是类方法，锁的是Phone的Class，同一把锁
import java.util.concurrent.TimeUnit;
class Phone {
    public static  synchronized void sendSMS() throws InterruptedException {
        TimeUnit.SECONDS.sleep(4);  //睡眠4s
        System.out.println("==========sendSMS======");

    }
    public static synchronized void sendEmail() throws InterruptedException {
        //TimeUnit.SECONDS.sleep(4);
        System.out.println("==========sendEmail======");
    }
    public static class Lock_Problem8 {
        public static void main(String[] args) throws InterruptedException {
            Phone phone = new Phone();
            Phone phone2 = new Phone();
            new Thread(() -> {
                try {

                    phone.sendSMS();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }, "AA").start();
            Thread.sleep(200);//睡眠0.2S

            new Thread(() -> {
                try {

                    phone.sendEmail();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "BB").start();
        }
    }
}
六、两个静态同步方法，2部手机，先打印短信还是邮件（先短信后邮件）
//等4S,先短信后邮件--同一把锁
//静态方法是类方法，锁的是Phone的Class，同一把锁
class Phone {
    .....
        
        
    public static class Lock_Problem8 {
        public static void main(String[] args) throws InterruptedException {
            Phone phone = new Phone();
            Phone phone2 = new Phone();
            new Thread(() -> {
                try {
                    phone.sendSMS();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }, "AA").start();
            Thread.sleep(200);//睡眠0.2S

            new Thread(() -> {
                try {
                    phone2.sendEmail();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "BB").start();
        }
    }
}
七、1个静态同步方法，1个普通同步方法，1部手机，先打印短信还是邮件（先邮件后短信）
//先邮件(等4s)后短信
package com.lindaxia.gmall.jucdemo.jucdemo;

import java.util.concurrent.TimeUnit;

class Phone {
    public static  synchronized void sendSMS() throws InterruptedException {
        TimeUnit.SECONDS.sleep(4);  //睡眠4s
        System.out.println("==========sendSMS======");

    }
    public synchronized void sendEmail() throws InterruptedException {
        //TimeUnit.SECONDS.sleep(4);
        System.out.println("==========sendEmail======");

    }
    public static class Lock_Problem8 {
        public static void main(String[] args) throws InterruptedException {
            Phone phone = new Phone();
            new Thread(() -> {
                try {

                    phone.sendSMS();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }, "AA").start();
            Thread.sleep(200);//睡眠0.2S

            new Thread(() -> {
                try {
                    phone.sendEmail();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "BB").start();
        }
    }
}
八、1个静态同步方法，1个普通同步方法，2部手机，先打印短信还是邮件（先邮件后短信）
//先邮件(等4s)后短信
class Phone {
  .................
    }
    public static class Lock_Problem8 {
        public static void main(String[] args) throws InterruptedException {
            Phone phone = new Phone();
            Phone phone2 = new Phone();
            new Thread(() -> {
                try {

                    phone.sendSMS();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }, "AA").start();
            Thread.sleep(200);//睡眠0.2S

            new Thread(() -> {
                try {
                    phone2.sendEmail();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "BB").start();
        }
    }
}
总结：

   一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方法了，其它的线程都只能等待，换句话说，某一个时刻内，只能有唯一一个线程去访问这些synchronized方法锁的是当前对象this，被锁定后，其它的线程都不能进入到当前对象的其它的synchronized方法加个普通方法后发现和同步锁无关，换成两个对象后，不是同一把锁了，情况立刻变化。

   synchronized实现同步的基础：Java中的每一个对象都可以作为锁。具体表现为以下3种形式（锁范围）：
      对于普通同步方法，锁是当前实例对象this;
      对于静态同步方法，锁是当前类的Class对象(即同一把锁);
      对于同步方法块，锁是Synchonized括号里配置的对象 。

 ☝上述分享来源个人总结，如果分享对您有帮忙，希望您积极转载；如果您有不同的见解，希望您积极留言，让我们一起探讨，您的鼓励将是我前进道路上一份助力，非常感谢！我会不定时更新相关技术动态，同时我也会不断完善自己，提升技术，希望与君同成长同进步！

☞本人博客：https://coding0110lin.blog.csdn.net/  欢迎转载，一起技术交流吧！

CRUD_CODER_LIN
关注
专栏目录
[JDK] 多线程高并发探秘之“锁”
架构探险之道
01-28 418
目录[JDK] 多线程并发 之 “锁”1. 自旋锁2. 自旋锁的其他种类2.1 TicketSpinLock2.2 CLHLock & MCSLockREFERENCES更多 [JDK] 多线程并发 之 “锁” 锁作为并发共享数据，保证一致性的工具，在JAVA平台有多种实现(如 synchronized 和 ReentrantLock等等 ) 。这些已经写好提供的锁为我们开发提供了便利，...
多线程系列(十八) -AQS原理浅析
程序员志哥的博客
03-07 1283
在之前的文章中，我们介绍了 ReentrantLock、ReadWriteLock、CountDownLatch、CyclicBarrier、Semaphore、ThreadPoolExecutor 等并发工具类的使用方式，它们在请求共享资源的时候，都能实现线程同步的效果。
JUC使用案例
一切皆有可能！
04-23 922
文章目录前言ReentranLockCountDownLatchCyclicBarrierPhaserReadWriteLockSemaphoreExchanger总结 前言   JUC即java.util.concurrent包，这个包下面提供很多用于保证多线程安全的类，比如atomic包下面的原子类、locks包下面和锁相关的类以及其他类。在这篇文章中，我们将讲解一些常用的类的基本使用。 ReentranLock CountDownLatch CyclicBarrier Phaser ReadWrite
Java 并发包(JUC多线程)下面的工具类，在实际工作中都有哪些应用场景呢？
Java后端技术栈
11-09 851
下面可以主要分几类： 1. 线程间通信工具类，如Semaphore ,、CountDownLatch、Future等等，这种也经常用，特别是在写多线程高并发的程序时，结合通信工具和锁把线程编排的符合你的预期执行 2. 锁，JUC提供了各种在某些场景下比synchronized更合适的高级锁实现，包括读写锁，互斥锁等等，因其多数基于CAS这种乐观锁实现，性能一般要由于synchronized内置锁，而且结合Cdondition更灵活可控。 不过个人觉得，这些锁除了jdk以及一些知名框架中使用外，我们日常工
JUC并发工具类的应用场景详解
最新发布
qq_45061342的博客
07-12 1025
解决多线程竞争资源的问题，例如多个线程同时对同一个数据库进行写操作，可以使用ReentrantLock保证每次只有一个线程能够写入。实现多线程任务的顺序执行，例如在一个线程执行完某个任务后，再让另一个线程执行任务。实现多线程等待/通知机制，例如在某个线程执行完某个任务后，通知其他线程继续执行任务。限流：Semaphore可以用于限制对共享资源的并发访问数量，以控制系统的流量。资源池：Semaphore可以用于实现资源池，以维护一组有限的共享资源。
Java并发编程实用工具类JUC的各种场景应用全解
youhaitao_do的博客
09-08 3160
一、JUC 1、SaleTicketDemo.java import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * @author yht * @create 20:46 * * 题目：三个售票员 卖出 30张票 * 笔记：如何编写企业级的多线程代码 * 固定的编程套路+模板是什么？ * 1.在高内聚，低耦合的前提下
（并发编程学习04）JUC并发工具类的应用场景详解
a250029634的博客
07-17 634
JUC并发工具类的应用场景详解
源码解析：JUC及使用场景
yilvi的博客
02-28 1445
本文当用于帮助读者从功能性上理解JUC的功能场景 * 阅读之前请先确定了解集合相关的基础知识 * 一、Collections工具类 该类应用工厂及静态内部类的形式为已有数据结构进行加工，赋予dynamically(checked) 、empty 、immutable(singleton) 、synchronized.所有读写都加对象锁、unmodifiable view(unmodifiable).final修饰对象，写操作throw new UnsupportedOperationException.
面试题汇总二 Java 多线程篇
u013575592的博客
10-16 1290
前言 题目汇总来源史上最全各类面试题汇总，没有之一，不接受反驳 面试题汇总一 Java 语言基础篇 面试题汇总二 Java 多线程篇 面试题汇总三 Java 集合篇 面试题汇总四 JVM 篇 面试题汇总五 Spring 篇 面试题汇总六 数据库篇 面试题汇总七 计算机网络篇 目录 前言 多线程 开启线程的三种方式？ 什么是Callable和Future? 说说进程...
Java多线程5—ReentrantLock与Condition
clyss1234的博客
09-29 675
文章目录1. ReentrantLock重入锁1.1 ReentrantLock源码解析1.1.1 lock操作1.1.2 release操作2. synchronized和Reetrantlock的区别3. Condition及其介绍3.1 Condition的介绍3.2 Condition在AQS中的使用3.3 Condition在阻塞队列中的实现4. [阻塞和唤醒线程——LockSupport功能简介及原理浅析](https://www.cnblogs.com/takumicx/p/9328459.h
并发编程和多线程
why36910的博客
12-13 1015
文章目录并发编程和串行并发编程的目的：适合并发编程的场景并发编程的挑战之--频繁的上下文切换并发编程的挑战之--死锁并发编程的挑战--线程安全并发编程的挑战--资源的限制线程基础线程和进程的区别线程的状态及相互转换线程创建线程的挂起和恢复操作线程的中断操作(interrupt)线程的优先级守护线程 并发编程和串行 并发编程的目的： 让程序充分利用非计算机资源·、 加快程序响应速度（耗时任务、we...
并发编程之JUC并发工具类的应用场景详解
2201_75955594的博客
03-23 310
JUC并发工具类详解
java juc 包_Java 并发包(JUC)下面的工具类，在实际工作中都有哪些应用场景呢？...
weixin_39939510的博客
02-13 689
这下面可以主要分几类吧1. 线程间通信工具类，如Semaphore ,、CountDownLatch、Future等等，这种也经常用，特别是在写多线程高并发的程序时，结合通信工具和锁把线程编排的符合你的预期执行2. 锁，JUC提供了各种在某些场景下比synchronized更合适的高级锁实现，包括读写锁，互斥锁等等，因其多数基于CAS这种乐观锁实现，性能一般要由于synchronized内置锁，而...
【JUC系列第四篇】-CountDownLatch使用场景分析
测试0901-1
03-01 290
作者 : 毕来生 前言 ​ 在 java.util.concurrent 包中提供了多种并发容器类来改进同步容器 的性能。今天我们来聊一聊CountDownLatch 的使用场景。看看它到底是怎么玩耍的。 CountDownLatch 是干什么的？ ​ CountDownLatch 一个同步辅助类,在完成一组正在其他线程中执行的操作 之前,...
JUC并发系列(十)：超全透彻ReadWriteLock读写锁（应用场景+代码示例+关键代码剖析）
一颗剽悍的种子的博客
10-05 1011
一篇让你透彻什么是 ReadWriteLock读写锁!
JUC并发系列(九)：并发编程常用辅助类Semaphore（应用场景+例子+代码示例）
一颗剽悍的种子的博客
10-03 1676
除了常用辅助类CountDownLatch与CyclicBarrier，还有第三个常用限流的Semaphore信号量的常用辅助类
JUC并发编程——Synchronized锁和 Lock 锁
万里顾一程的博客
09-15 319
文章目录JUC并发编程——LOCK 锁1、传统的 Synchronize 锁2、LOCK 锁3、 Synchronize 和 Lock 的区别4、生产者消费者问题4.1、synchronize 版本生产者消费者问题4.2、Lock 版本生产者消费者问题 JUC并发编程——LOCK 锁 JUC JUC 是 java.util .concurrent 工具包的简称。这是一个处理线程的工具包。 并发包中包含了许多并发编程中需要用到的类。 JUC 是从JDK 1.5开始出现。 JUC 目的就是为了更好的支持高并
6、JUC并发工具类在大厂的应用场景详解
weixin_46825305的博客
07-17 1049
JUC 是 Java Util Concurrent 的缩写，意为 java.util.concurrent。这是 Java 标准库中专门用于处理多线程编程的库
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值