8锁现象详解

如何判断锁的是谁!理解锁!锁到底锁的是谁!

对象、class 。

1.前两个问题

java 复制代码
package com.kuang.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁 ,就是关于锁的8个问题
 * 1、标准情况下,两个线程先打印  发短信还是打电话? 1/发短信 2/打电话
 * 2、sendSms 延迟4秒,两个线程先打印  发短信还是 打电话 ? 1/发短信 2/打电话
 */
public class Test1 {

    public static void main(String[] args) {
        Phone phone = new Phone();
     //锁的存在,才导致,它先执行。面试的适合,不能说是因为他先被调用,而是它先抢到了锁,所以它先打印!
        new Thread(()->{
            phone.sendSms();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        new Thread(()->{
            phone.call();
        },"B").start();

    }



}
class Phone{
    //synchronized 锁的对象是方法的调用者!  phone
    //两个方法用的是同一个锁,谁先拿到谁执行!
    public synchronized void  sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendSms");
    }
    public synchronized void call(){
        System.out.println("call");
    }





}

2.3-4问题

java 复制代码
package com.kuang.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁 ,就是关于锁的8个问题
 *
 * 3.增加了一个普通方法! 发短信还是Hello?   是hello.
 * 4. 两个对象,两个同步方法! 发短信还是打电话?   是打电话
 */
public class Test2 {

    public static void main(String[] args) {
       //两个对象 ,两个调用者 ,两把锁!
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();
     //锁的存在,才导致,它先执行。面试的适合,不能说是因为他先被调用,而是它先抢到了锁,所以它先打印!
        new Thread(()->{
            phone1.sendSms();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        new Thread(()->{
            phone2.hello();
        },"B").start();

    }



}
class Phone2{
    //synchronized 锁的对象是方法的调用者!  phone
    //两个方法用的是同一个锁,谁先拿到谁执行!
    public synchronized void  sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendSms");
    }
    public synchronized void call(){
        System.out.println("call");
    }

    //这里没有锁!不是同步方法,不受锁的影响!
   public void hello(){
       System.out.println("hello");
   }



}

3.5-6

java 复制代码
package com.kuang.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁 ,就是关于锁的8个问题
 *
 * 5.增加两个静态同步方法,只有一个对象,先打印,发短信?打电话? 打印发短信!!因为锁的都是同一个class对象
 * 6.增加两个对象,两个静态的同步方法,先打印,发短信?打电话? 打印发短信!!  因为锁的都是同一个class对象,与对象本身无关
 */
public class Test3 {

    public static void main(String[] args) {
       //两个对象的class 类模板只有一个,static,锁的是class
        Phone3 phone1 = new Phone3();
        Phone3 phone2 = new Phone3();


     //锁的存在,才导致,它先执行。面试的适合,不能说是因为他先被调用,而是它先抢到了锁,所以它先打印!
        new Thread(()->{
            phone1.sendSms();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        new Thread(()->{
            phone2.call();
        },"B").start();

    }



}
//Phone3唯一的一个Class对象
class Phone3{
    //synchronized 锁的对象是方法的调用者!  phone
    //两个方法用的是同一个锁,谁先拿到谁执行!
    //static  静态方法
    //类一加载就有了!锁的Class 锁的是模板
    public static synchronized void  sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendSms");
    }
    public static synchronized void call(){
        System.out.println("call");
    }





}

4.第7个问题

java 复制代码
package com.kuang.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁 ,就是关于锁的8个问题
 *
 * 7. 1个静态的同步方法,1个普通的同步方法,1个对象 ,先打印发短信?还是打电话? 打电话,因为锁的不是同一个东西,而打电话的睡眠时间少,所以打电话先打印
 *
 */
public class Test4 {

    public static void main(String[] args) {
       //两个对象的class 类模板只有一个,static,锁的是class
        Phone4 phone = new Phone4();



     //锁的存在,才导致,它先执行。面试的适合,不能说是因为他先被调用,而是它先抢到了锁,所以它先打印!
        new Thread(()->{
            phone.sendSms();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        new Thread(()->{
            phone.call();
        },"B").start();

    }



}
//Phone3唯一的一个Class对象
class Phone4{
  //静态的同步方法
    public static synchronized void  sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendSms");
    }
    //普通的同步方法
    public synchronized void call(){
        System.out.println("call");
    }





}

5.8-9个问题

java 复制代码
package com.kuang.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁 ,就是关于锁的8个问题
 *
 * 8. 1个静态的同步方法,1个普通的同步方法,2个对象 ,先打印发短信?还是打电话? 打电话,因为锁的不是同一个东西,而打电话的睡眠时间少,所以打电话先打印
 * 9. 如何让静态方法与 普通方法实现同步,用 synchronized 在普通方法里 锁住 字节码对象,就可以实现同步  然后就是发短信先打印了
 *
 */
public class Test5 {

    public static void main(String[] args) {
       //两个对象的class 类模板只有一个,static,锁的是class
        Phone5 phone1 = new Phone5();
        Phone5 phone2 = new Phone5();



     //锁的存在,才导致,它先执行。面试的时候,不能说是因为他先被调用,而是它先抢到了锁,所以它先打印!
        new Thread(()->{
            phone1.sendSms();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        new Thread(()->{
            phone2.call();
        },"B").start();

    }



}
//Phone3唯一的一个Class对象
class Phone5{
  //静态的同步方法
    public static synchronized void  sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendSms");
    }
    //普通的同步方法
    public  void call(){
        synchronized(Phone5.class){
            System.out.println("call");
        }

    }





}

加拓展

相关推荐
苹果酱056724 分钟前
【Azure Redis 缓存】在Azure Redis中,如何限制只允许Azure App Service访问?
java·vue.js·spring boot·mysql·课程设计
我真的不会C33 分钟前
QT中的事件及其属性
开发语言·qt
Java致死1 小时前
单例设计模式
java·单例模式·设计模式
胡子发芽1 小时前
请详细解释Java中的线程池(ThreadPoolExecutor)的工作原理,并说明如何自定义线程池的拒绝策略
java
沫夕残雪1 小时前
Tomcat的安装与配置
java·tomcat
胡子发芽1 小时前
请解释Java中的NIO(New I/O)与传统I/O的区别,并说明NIO中的关键组件及其作用
java
柚个朵朵1 小时前
IDEA中使用Git
java·git·spring
2501_906314321 小时前
优化无头浏览器流量:使用Puppeteer进行高效数据抓取的成本降低策略
开发语言·数据结构·数据仓库
jerry6092 小时前
优先队列、堆笔记(算法第四版)
java·笔记·算法
让我们一起加油好吗2 小时前
【C++】类和对象(上)
开发语言·c++·visualstudio·面向对象