有关锁的8个问题

最新推荐文章于 2022-12-23 15:30:31 发布
最新推荐文章于 2022-12-23 15:30:31 发布
阅读量187 收藏
点赞数
分类专栏： 多线程 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gakkimarryme/article/details/113252013
版权

1.第1段代码

package com.zmh.multithread.juc;

class Phone {

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

/**
 *
 * @Description: 8锁
 * @author gakkimarryme
 *
 */
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();
    }
}

 输出结果：

------sendSMS
------sendEmail

原因:如果不加Thread.sleep(100)就不能确定谁先谁后，非静态同步方法的锁是当前对象this，一个类中的所有非静态方法都是同一个锁this,同一时刻只能有一个线程进入同步方法。Thread.sleep()写在哪里就阻塞在哪里，这里写在了main线程里，所以main线程下面的线程BB被阻塞，只能先执行线程AA。

第2段代码

package com.zmh.multithread.juc;

import java.util.concurrent.TimeUnit;

class Phone {

    public synchronized void sendSMS() throws Exception {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS"+"\t"+Thread.currentThread().getName());
    }
    public synchronized void sendEmail() throws Exception {
        System.out.println("------sendEmail"+"\t"+Thread.currentThread().getName());
    }
}

/**
 *
 * @Description: 8锁
 * @author gakkimarryme
 *
 */
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();
    }
}

 输出结果：

------sendSMS
------sendEmail

原因:sleep方法没有释放锁,睡醒了以后接着从以前的上下文的位置继续运行，所以还是先输出------sendSMS。

第3段代码

package com.zmh.multithread.juc;

import java.util.concurrent.TimeUnit;

class Phone {

    public synchronized void sendSMS() throws Exception {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS"+"\t"+Thread.currentThread().getName());
    }
    public synchronized void sendEmail() throws Exception {
        System.out.println("------sendEmail"+"\t"+Thread.currentThread().getName());
    }

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

/**
 *
 * @Description: 8锁
 * @author gakkimarryme
 *
 */
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.hello();
        } catch (Exception e) {
            e.printStackTrace();
        }
    },"BB").start();
    }
}

 输出结果：

hello world
------sendSMS    AA

原因:hello方法没有加锁线程可以访问。

第4段代码

package com.zmh.multithread.juc;

import java.util.concurrent.TimeUnit;

class Phone {

    public synchronized void sendSMS() throws Exception {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS"+"\t"+Thread.currentThread().getName());
    }
    public synchronized void sendEmail() throws Exception {
        System.out.println("------sendEmail"+"\t"+Thread.currentThread().getName());
    }

}

/**
 *
 * @Description: 8锁
 * @author gakkimarryme
 *
 */
public class Lock_8 {
    public static void main(String[] args) throws Exception{
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();
      new Thread(()->{
            try {
                phone1.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"AA").start();
      Thread.sleep(100);

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

 输出结果：

------sendEmail    BB
------sendSMS    AA

原因:非静态同步方法的锁是当前对象this，AA线程的锁对象是phone1，BB线程的锁对象是phone2。不是同一个锁，两个线程之间都锁不住对方。

第5段代码

package com.zmh.multithread.juc;

import java.util.concurrent.TimeUnit;

class Phone {

    public static synchronized void sendSMS() throws Exception {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS"+"\t"+Thread.currentThread().getName());
    }
    public static synchronized void sendEmail() throws Exception {
        System.out.println("------sendEmail"+"\t"+Thread.currentThread().getName());
    }

}

/**
 *
 * @Description: 8锁
 * @author gakkimarryme
 *
 */
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();
    }
}

 输出结果：

------sendSMS    AA
------sendEmail    BB

原因:静态同步方法的锁对象是当前类.Class对象，两个线程都是同一个类的对象（同一个对象）。即同一个类的同一个对象。是同一个锁。

第6段代码

package com.zmh.multithread.juc;

import java.util.concurrent.TimeUnit;

class Phone {

    public static synchronized void sendSMS() throws Exception {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS"+"\t"+Thread.currentThread().getName());
    }
    public static synchronized void sendEmail() throws Exception {
        System.out.println("------sendEmail"+"\t"+Thread.currentThread().getName());
    }

}

/**
 *
 * @Description: 8锁
 * @author gakkimarryme
 *
 */
public class Lock_8 {
    public static void main(String[] args) throws Exception{
        Phone phone1= new Phone();
        Phone phone2= new Phone();
      new Thread(()->{
            try {
                phone1.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"AA").start();
      Thread.sleep(100);

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

 输出结果：

------sendSMS    AA
------sendEmail    BB

原因:静态同步方法的锁对象是当前类.Class对象，两个线程的锁对象都是同一个类的对象（不同对象）。即同一个类的不同对象，但终归属于同一个类，是同一个锁。

第7段代码

package com.zmh.multithread.juc;

import java.util.concurrent.TimeUnit;

class Phone {

    public static synchronized void sendSMS() throws Exception {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS"+"\t"+Thread.currentThread().getName());
    }
    public synchronized void sendEmail() throws Exception {
        System.out.println("------sendEmail"+"\t"+Thread.currentThread().getName());
    }

}

/**
 *
 * @Description: 8锁
 * @author gakkimarryme
 *
 */
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();
    }
}

 输出结果：

------sendEmail    BB
------sendSMS    AA

原因:静态同步方法的锁对象是当前类.Class对象，非静态同步方法的锁对象是当前对象this，不是同一个锁，相互之间没有影响。好比this是厕所的门，类锁是学校的教室的锁，你锁住了教室，厕所是可以进的，你锁住厕所，教室是可以进的。

第8段代码

package com.zmh.multithread.juc;

import java.util.concurrent.TimeUnit;

class Phone {

    public static synchronized void sendSMS() throws Exception {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS"+"\t"+Thread.currentThread().getName());
    }
    public synchronized void sendEmail() throws Exception {
        System.out.println("------sendEmail"+"\t"+Thread.currentThread().getName());
    }

}

/**
 *
 * @Description: 8锁
 * @author gakkimarryme
 *
 */
public class Lock_8 {
    public static void main(String[] args) throws Exception{
        Phone phone1= new Phone();
        Phone phone2= new Phone();
      new Thread(()->{
            try {
                phone1.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"AA").start();
      Thread.sleep(100);

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

 输出结果：

------sendEmail    BB
------sendSMS    AA

原因:同上，也不是同一把锁。

gakkimarryme
关注
专栏目录
Java锁相关的问题总结
d303577562的博客
03-18 288
1.synchronized加锁的对象有哪些？ object对象（new 出来的对象） 场景：1.synchronized修饰非静态方法 2.synchronized(object)同步代码块传入的object对象 class单例对象 场景：1.synchronized修饰静态方法 2.synchronized(class)同步代码块传入的class对象 常量池对象 场景：synchronized(“123”)同步代码块传入的常量池对象 2.synchronized中的锁升级是否可逆？ 不可逆。sync
8锁，就是关于锁的8个问题
weixin_45752694的博客
09-17 268
synchronized 锁的对象是方法的调用者,经过8锁问题能更加理解这个概念
JUC关于锁的8个问题
追寻心的步伐
12-23 123
八锁现象主要是指 八种锁的情况，掌握了这八种情况我们以后碰到锁就能明白锁锁的是谁了锁是一种将资源私有化的的方式，在java中就是让某个类、变量、方法在同一个时刻只能被一个线程使用，保证数据的安全性，只要当使用锁的线程释放了这个锁，其它线程才能获取使用。到此为止关于8锁的问题已经分享完毕啦，其实八锁就是关于锁的在不同情况下输出结果的问题，搞懂了锁的是对象还是类模板的话我们就能清晰地知道输出以及运行的情况是怎样的。
关于锁的一些常见问题
回南山种豆的专栏
12-24 640
<br />调度：<br />调度室数据库的一个或者多个事物按时间排序的序列<br />　 <br />T1<br />T2<br />READ(A,t)<br />READ(A,s)<br />t := t + 100<br />s := s*2<br />WRITE(A,t)<br />WRITE(A,s)<br />READ(B,t)<br />READ(B,s)<br />t := t + 100<br />s := s*2<br />WRTIE(B,t)<br />WRITE(B,s)<br />
[JUC-04] 锁的8个问题
学哥斌的博客
08-11 261
分析锁是谁
三星s8 s8+ note8网络锁卡锁区域锁解锁教程
01-20
### 三星S8/S8+/Note8网络锁、卡锁及区域锁解锁教程 #### 一、网络锁概念与背景 手机网络锁是一种常见的限制措施，通常出现在与运营商捆绑销售的合约机上，尤其是国外市场。为了防止用户将手机转售至其他地区或...
JAVA基础及8个并发面试问题共2页.pdf.zip
11-21
这个标题表明了文档的主要内容，涵盖了Java编程的基础知识以及八个与并发编程相关的面试问题。Java是世界上最流行的编程语言之一，广泛应用于企业级应用、云计算、大数据处理等多个领域。对于Java开发者来说，扎实的...
Redis从入门到精通(八)Redis实战(五)分布式锁误删与原子性问题、Redisson 测试项目代码
最新发布
04-06
它确保在同一时刻只有一个节点可以持有锁并执行相关操作，从而避免并发冲突。Redis由于其高可用性和低延迟特性，成为实现分布式锁的理想选择。 然而，使用Redis实现分布式锁时，可能会遇到误删问题。例如，一个节点...
JUC多线程编程八锁你都知道了吗？关于锁的八个问题
不会编程的派大星的博客
04-21 140
关于锁的八个问题—八锁 前面的文章中留下一个疑问，到底什么是锁，锁到底锁的是谁？ 这里我们就用打电话和发短信的例子来距离说明八锁问题—>锁的是对象方法的调用者或者Class模板（.class） 1、标准情况下，两个线程先打印 发短信还是 先打印 打电话？ import java.util.concurrent.TimeUnit; /** * @program: juc * @description * @author: 不会编程的派大星 * @create: 2021-04-21 12:42
几个有关锁的问题
ziren的专栏
03-14 560
1 如何锁一个表的某一行 SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED SELECT * FROM table ROWLOCK WHERE id = 1 2 锁定数据库的一个表 SELECT * FROM table WITH (HOLDLOCK) 加锁语句：sybase:update 表 set col1=col1 where 1=0 ;MSS
锁的问题
thewebcode
04-01 147
锁的类型 1 . HOLDLOCK: 在该表上保持共享锁，直到整个事务结束，而不是在语句执行完立即释放所添加的锁。 2．NOLOCK：不添加共享锁和排它锁，当这个选项生效后，可能读到未提交读的数据或“脏数据”，这个选项仅仅应用于SELECT语句。 3．PAGLOCK：指定添加页锁（否则通常可能添加表锁）。　 4．READCOMMITTED用与运行在提交读隔离级别的事务相同的锁语义执行...
锁的问题总结
baidu_38176716的博客
12-26 182
所有的锁都有性能消耗，高并发下，锁带来上下文切换，资源同步等消耗非常可观。，线程在锁上消耗比线程本身还多，应该尽可能少用锁，如果不可避免，那就用非阻塞算法解决问题，但不是绝对的。 内部锁： java通过synchronized保持原子性，独占锁，锁请求互斥，跟高级锁（Lock/ReadWriteLock），synchronized简单，lock必须在finally代码里用，Lock的资源已经用到了...
20. 锁问题
monkeylvjava
08-20 151
锁是计算机协调多个进程或线程并发访问某一资源的机制，并发访问控制的基础。 1. MySQL锁概述 MySQL不同的存储引擎支持不同的锁机制。比如，MyISAM和MEMORY使用的是表级锁(table-level locking);BDB存储引擎采用的是页面锁（page-level locking），但也支持表级锁；InnoDB存储引擎既支持行级锁(row-level locking)，也支持表级锁，默认情况下采用的是行级锁。 MySQL锁的特性 表级锁：开销小，加锁快，无死锁，锁定粒度大，锁冲突概率最高，
锁的三种问题
hyunbar的博客
06-30 188
一、简介 　　通过锁机制可以实现事务的隔离性要求，使得事务可以并发地工作。锁提高了并发，但是却带来了问题。不过好在因为事务隔离性的要求，锁只会带来三种问题，如果可以防止这三种情况的发生，那将不会产生并发异常。 二、脏读 　　页和脏数据的区别：脏页是指在缓冲池中已经被修改的页，但是还没有刷新到磁盘中，即数据库实例内存中的页和磁盘中的页的数据不一致，当然在刷新到磁盘之前，日志都已近被写入到重做日...
【数据库】涉及锁的问题
Soldier49Zed的博客
09-20 428
如何并发访问数据库 加锁 说下数据库的锁机制，数据库中都有哪些锁 锁是一种并发控制技术，锁是用来在多个用户同时访问同一个数据的时候保护数据的。 一、有两种基本的锁类型 共享锁（S）：多个事务可封锁一个共享页；任何事务都不能修改该页；通常是该页被读取完毕，S锁立即被释放。在执行select语句的时候需要给操作对象（表或者一些记录）加上共享锁，但加锁之前需要检查是否有排它锁，如果没有，...
java-并发-解决锁竞争的问题
阿里Darker
07-21 4845
java锁的分类锁作为并发共享数据，保证一致性的工具。在java.util.lock中有一些不错的策略 1、自旋锁2、阻塞锁3、可重入锁4、读写锁5、互斥锁6、悲观锁7、乐观锁8、公平锁9、非公平锁10、偏向锁11、对象锁12、线程锁13、锁粗化14、轻量级锁15、锁消除16、锁膨胀17、信号量 竞争锁与无竞争锁的区别。如果一个线程尝试进入另一个线程正在执行的同步块或者方法时，便会出现锁竞争。第
并发编程隐患：11个常见问题与解决策略
本文主要探讨了在多线程编程中常见的11个并发问题及其解决方案，涉及了基本的并发概念、并发问题的抑制措施、实现安全性的一些模式以及相关的技术，如多线程和.NET Framework。文章指出，随着多核处理器的普及，并发...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值