线程8锁机制

最新推荐文章于 2023-06-06 13:03:51 发布
最新推荐文章于 2023-06-06 13:03:51 发布
阅读量168 收藏
点赞数
分类专栏： JVM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48149536/article/details/106459768
版权

1 标准访问，先打印短信还是邮件

package com.dym.jvm;

class Phone
{

    public synchronized void sendSMS() throws Exception
    {

        System.out.println("------sendSMS");
    }
    public synchronized void sendEmail() throws Exception
    {
        System.out.println("------sendEmail");
    }

}

/**
 *
 * @Description: 8锁
 *
     1 标准访问，先打印短信还是邮件
 * ---------------------------------
 *
 */
public class Lock_8
{
    public static void main(String[] args) throws Exception
    {
        Phone phone = new Phone();

        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "AA").start();

        Thread.sleep(100);

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

2 停4秒在短信方法内，先打印短信还是邮件

package com.dym.jvm;

import java.util.concurrent.TimeUnit;

class Phone
{
    public  synchronized void sendSMS() throws Exception
    {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS");
    }

    public synchronized void sendEmail() throws Exception
    {
        System.out.println("------sendEmail");
    }
}

/**
 *
 * @Description: 8锁
 *
2 停4秒在短信方法内，先打印短信还是邮件
 *
 */
public class Lock_8
{
    public static void main(String[] args) throws Exception
    {

        Phone phone = new Phone();

        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "AA").start();

        Thread.sleep(100);

        new Thread(() -> {
            try {
                phone.sendEmail();
                //phone.getHello();
                //phone2.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "BB").start();
    }
}

3 新增普通的hello方法，是先打短信还是hello

package com.dym.jvm;

import java.util.concurrent.TimeUnit;

class Phone
{
    public  synchronized void sendSMS() throws Exception
    {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS");
    }
    public synchronized void sendEmail() throws Exception
    {
        System.out.println("------sendEmail");
    }

    public void getHello()
    {
        System.out.println("------getHello");
    }
}

/**
 *
 * @Description: 8锁
 *
3 新增普通的hello方法，是先打短信还是hello
 * ---------------------------------
 *
 */
public class Lock_8
{
    public static void main(String[] args) throws Exception
    {

        Phone phone = new Phone();

        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "AA").start();

        Thread.sleep(100);

        new Thread(() -> {
            try {
                phone.getHello();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "BB").start();
    }
}

4 现在有两部手机，先打印短信还是邮件

package com.dym.jvm;

import java.util.concurrent.TimeUnit;


class Phone
{

    public  synchronized void sendSMS() throws Exception
    {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS");
    }
    public synchronized void sendEmail() throws Exception
    {
        System.out.println("------sendEmail");
    }

    public void getHello()
    {
        System.out.println("------getHello");
    }

}

/**
 *
 * @Description: 8锁
 *
4 现在有两部手机，先打印短信还是邮件
 * ---------------------------------
 *
 */
public class Lock_8
{
    public static void main(String[] args) throws Exception
    {

        Phone phone = new Phone();
        Phone phone2 = new Phone();

        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "AA").start();

        Thread.sleep(100);

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

5 两个静态同步方法，1部手机，先打印短信还是邮件

package com.dym.jvm;

import java.util.concurrent.TimeUnit;

class Phone
{
    public static synchronized void sendSMS() throws Exception
    {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS");
    }
    public static synchronized void sendEmail() throws Exception
    {
        System.out.println("------sendEmail");
    }

    public void getHello()
    {
        System.out.println("------getHello");
    }

}

/**
 *
 * @Description: 8锁
 *
5 两个静态同步方法，1部手机，先打印短信还是邮件
 *
 */
public class Lock_8
{
    public static void main(String[] args) throws Exception
    {

        Phone phone = new Phone();
        Phone phone2 = new Phone();

        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "AA").start();

        Thread.sleep(100);

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

6 两个静态同步方法，2部手机，先打印短信还是邮件

package com.dym.jvm;

import java.util.concurrent.TimeUnit;

class Phone
{
    public static synchronized void sendSMS() throws Exception
    {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS");
    }
    public static synchronized void sendEmail() throws Exception
    {
        System.out.println("------sendEmail");
    }

    public void getHello()
    {
        System.out.println("------getHello");
    }

}

/**
 *
 * @Description: 8锁
 *
6 两个静态同步方法，2部手机，先打印短信还是邮件
 *
 */
public class Lock_8
{
    public static void main(String[] args) throws Exception
    {

        Phone phone = new Phone();
        Phone phone2 = new Phone();

        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "AA").start();

        Thread.sleep(100);

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

 7  1个静态同步方法,1个普通同步方法，1部手机，先打印短信还是邮件 

package com.dym.jvm;

import java.util.concurrent.TimeUnit;

class Phone
{
    public synchronized void sendSMS() throws Exception
    {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS");
    }
    public static synchronized void sendEmail() throws Exception
    {
        System.out.println("------sendEmail");
    }

    public void getHello()
    {
        System.out.println("------getHello");
    }

}

/**
 *
 * @Description: 8锁
 *
7 1个静态同步方法,1个普通同步方法，1部手机，先打印短信还是邮件
 *
 */
public class Lock_8
{
    public static void main(String[] args) throws Exception
    {

        Phone phone = new Phone();
        Phone phone2 = new Phone();

        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "AA").start();

        Thread.sleep(100);

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

8 1个静态同步方法,1个普通同步方法，2部手机，先打印短信还是邮件

package com.dym.jvm;

import java.util.concurrent.TimeUnit;

class Phone
{
    public synchronized void sendSMS() throws Exception
    {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS");
    }
    public static synchronized void sendEmail() throws Exception
    {
        System.out.println("------sendEmail");
    }

    public void getHello()
    {
        System.out.println("------getHello");
    }

}

/**
 *
 * @Description: 8锁
 *
8 1个静态同步方法,1个普通同步方法，2部手机，先打印短信还是邮件
 *
 */
public class Lock_8
{
    public static void main(String[] args) throws Exception
    {

        Phone phone = new Phone();
        Phone phone2 = new Phone();

        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "AA").start();

        Thread.sleep(100);

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

weixin_48149536
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程锁机制相关原理实例解析
08-18
主要介绍了Java多线程锁机制相关原理实例解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
深入理解线程池（详解）
weixin_44825912的博客
03-08 7525
线程池做的工作主要是控制运行的线程的数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量超出数量的线程排队等候，等其它线程执行完毕，再从队列中取出任务来执行。他的主要特点为：线程复用；控制最大并发数；管理线程。
多线程进阶（上）
qq_52655865的博客
07-10 238
目录使用线程池的原因：JDK的线程池的使用ThreaPoolExecute的核心方法：execute： submit：提交一个任务到线程池，线程池会派遣一个空闲的线程来执行该任务。shutdown（）/shutdownNow（）：销毁线程池 ， ThreadPoolExecutor子类的核心构造方法参数：线程池的工作流程： 固定大小线程池的源码缓存线程池：同步阻塞队列，两个线程池同时获取和抛出一个任务。同步阻塞队列 单一线程池：延迟线程池：采用锁的策略：1，乐观锁：2，悲观锁：3，读写锁（Reentrant
线程池基础
oZuoMoYanZuoYan的博客
07-18 88
线程池 工作原理 线程池执行所提交的任务过程： 先判断线程池中的核心线程池所有的线程是否都在执行任务。如果不是，则新创建一个线程执行刚提交的任务，否则，核心线程池中所有的线程都在执行任务，则进入第二步 判断当前阻塞队列是否已满，如果未满，则将提交的任务放置在阻塞队列中；否则，则进入第三步； 判断线程池中的所有的线程是否都在执行任务，如果没有，则创建一个新的线程来执行任务，否则，则交给饱和策略处理 线程池的分类 ThreadPoolExecutor：最常用线程池 newCachedThread
多线程之公平锁与非公平锁
qq_27581753的博客
05-29 212
公平与非公平锁:锁Lock分为"公平锁"和"非公平锁"，公平锁标识线程获取锁的顺序是按照线程加锁的顺序来分配的，即先来先得的FIFO先进先出顺序，而非公平锁就是一种获取锁的抢占机制，是随机获得锁的，和公平锁不一样的就是先来的不一定先得到锁，这个方式可能造成某些线程一直拿不到锁，结果就是不公平的了。 1.公平锁 package LockTest; import java.util.concurrent.locks.ReentrantLock; /** * @Author LiBinquan */ pu
java 锁 线程池
seaReal1的博客
05-09 187
https://www.cnblogs.com/aspirant/p/6930436.html
Java 多线程同步 锁机制与synchronized深入解析
09-05
从尺寸上讲，同步代码块比同步方法小。你可以把同步代码块看成是没上锁房间里的一块用带锁的屏风隔开的空间
JAVA多线程的锁机制和无锁并行.docx
最新发布
11-25
JAVA多线程的锁机制和无锁并行.docx
Java线程并发中常见的锁机制详细介绍
09-02
越来越多的互联网企业面临着用户量膨胀而带来的并发安全问题。接下来通过本文给大家介绍Java线程并发中常见的锁机制，感兴趣的朋友一起看看吧
详解python多线程、锁、event事件机制的简单使用
12-24
线程和进程 1、线程共享创建它的进程的地址空间,进程有自己的地址空间 2、线程可以访问进程所有的数据，线程可以相互访问 3、线程之间的数据是独立的 4、子进程复制线程的数据 5、子进程启动后是独立的 ，父进程...
多线程锁（synchronized 锁的执行顺序、公平锁和非公平锁）
qq_51985869的博客
06-06 442
非公平锁：效率高，但是线程容易饿死（所有的工作，有一个线程完成）公平锁：效率相对低 ，但是cpu 的利用高了。可以有多把同步锁，但只能有一把静态同步锁。多线程 多对象 多把对象锁，之间互不干扰。一个线程即一个对象，所以只有一把对象锁。同步锁间互不干扰，静态同步锁按顺序执行。一个线程即一个类，所以只有一把类锁。只能有一把同步锁，一把静态同步锁。多线程属于同个类，只有一把类锁。一个线程就一个对象，一个类。多线程即多个对象，同个类；对象级别，一个对象一把锁。两把锁，之间互不干扰。类级别，一个类一把锁。
Java多线程 各种锁（一篇全搞懂）
烟雨gps
03-02 3981
Java多线程 锁 文章目录Java多线程 锁1、乐观锁与悲观锁2、公平锁与非公平锁3、可重入锁与不可重入锁4、独享锁与共享锁5、自旋锁 VS 适应性自旋锁6、无锁 、 偏向锁、量级锁 和 重量级锁（难点） 1、乐观锁与悲观锁 （1）悲观锁 对于同一个数据的并发操作，悲观锁认为自己在使用数据的时候一定有别的线程来修改数据，因此在获取数据的时候会先加锁，确保数据不会被别的线程修改。Java中，syn...
Java源码学习之并发编程-锁-Java中8种锁机制
weixin_37627646的博客
07-14 757
​ 在ReentrantLock中包含了公平锁和非公平锁两种锁。 如果你用默认的构造函数来创建ReentrantLock对象，默认的锁策略就是非公平的。 ​ 多个线程按照申请锁的顺序去获得锁，线程会直接进入队列去排队，永远都是队列的第一位才能得到锁。 优点：所有的线程都能得到资源，不会饿死在队列中。 缺点：吞吐量会下降很多，队列里面除了第一个线程，其他的线程都会阻塞，cpu唤醒阻塞线程的开销会很大。 公平锁图示： 图示1： ​ 咱们重新回到第一张图，就是线程1刚刚释放锁之后，线程2还没来得及重新加锁的那个状
【多线程】锁机制详解
qq_34416331的博客
08-03 5669
一、锁概述 1.1 概述 在多线程环境下，为了让多线程安全地访问和使用共享变量，必须引入锁机制。锁机制即当一个线程持有锁后，其他线程只能进行等待，直到持有锁的线程释放锁，再次重新竞争锁。 1.2 三种锁的大类型 锁大致可以分为互斥锁、共享锁、读写锁 1.2.1 互斥锁(排它锁) 互斥锁，即只有一个线程能够访问被互斥锁保护的资源 在访问共享对象之前，对其进行加锁操作。在访问完成之后进行解锁操作。加锁后，其他试图加锁的线程会被阻塞，知道当前线程解锁。解锁后，原本等待状态的线程变为就绪状态，重.
juc并发编程学习笔记下(尚硅谷)
noob9527的博客
10-13 435
5 多线程锁 5.1锁的八个问题演示 class Phone { public static synchronized void sendSMS() throws Exception { //停留4秒 TimeUnit.SECONDS.sleep(4); System.out.println("------sendSMS"); } public synchronized void sendEmail() throw
JUC并发编程
liuyongheng1991的博客
07-31 476
JUC 并发编程 来源：【尚硅谷】大厂必备技术之JUC并发编程2021最新版 1 什么是 JUC 1.1 JUC 简介 在 Java 中，线程部分是一个重点，本篇文章说的 JUC 也是关于线程的。 JUC 就是 java.util .concurrent 工具包的简称。这是一个处理线程的工具包， JDK 1.5 开始出现的。 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xzXLRLL8-1627717457873)(assets2/1627185831660.png)]
尚硅谷JUC高并发编程学习笔记（2）线程通信与集合线程安全
exodus3的博客
02-02 2394
一、线程间通信 线程间通信的模型有两种：共享内存和消息传递 线程间的通信具体步骤：（涉及上中下部） 1、创建资源类，在资源类中船舰属性和操作方法 2、在资源类操作方法：判断、操作、通知 3、创建多个线程，调用资源类的操作方法 4、防止虚拟唤醒问题 1、synchronized案例 操作线程的时候，等待线程使用wait() 通知另外的线程操作用notify()、notifyAll() 假设有两个线程，该线程在执行过程中，判断值（不是该值等待，让其他线程抢），操作值，通知另外一个线程的调度。 通过使用两个线程对
JUC-01概述
Logan的博客
08-20 177
1 什么是 JUC 1.1 JUC 简介 在 Java 中，线程部分是一个重点，本篇文章说的 JUC 也是关于线程的。JUC就是 java.util .concurrent 工具包的简称。这是一个处理线程的工具包，JDK 1.5 开始出现的。 1.2 进程与线程 进程（Process） 是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。 在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。是计算
《尚硅谷高级技术之JUC高并发编程》学习笔记03—— 线程间通信
weixin_43301424的博客
11-26 435
文章目录synchronized 方案Lock 方案线程间定制化通信 线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。我们来基本一道面试常见的题目来分析。 synchronized 方案 /** * synchronized 关键字实现线程交替加减 */ public class TestSynchronized { /** * 交替加减 * @param args */ public static void main(S
C++多线程竞争 锁机制
05-23
在C++多线程编程中，锁是一种机制，用于控制对共享资源的访问。当多个线程同时读写同一个共享资源时，就会发生竞争条件（race condition）。为了避免这种情况，我们需要使用锁来确保每个线程都能按照预期方式访问...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值