关于8锁问题详细介绍

于 2020-05-18 23:09:50 发布
阅读量1.6k 收藏 3
点赞数 1
分类专栏： java 文章标签： 并发编程 多线程 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43275467/article/details/106203840
版权

关于8锁问题

1、两个同步方法，一个对象调用。乌龟先跑？还是兔子先跑？ 答：乌龟先跑

/**
 * @Description:
 * @Package: com.cp.lock8
 * @ClassName: Lock2
 * @Author: cp
 * @Date: 2020/5/18 21:50
 * @Version: 1.0
 */
public class Lock1 {
    public static void main(String[] args) {
        Animal1 animal1=new Animal1();
        new Thread(()->{
            animal1.wuGui();
        }).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            animal1.tuZi();
        }).start();
    }
}

class Animal1{
    public synchronized void wuGui(){
        System.out.println("乌龟先跑");
    }
    public synchronized void tuZi(){
        System.out.println("兔子先跑");
    }
}

原因：synchronized 锁的是方法的调用者，也就是对象锁。两个方法持有的是同一把锁，因此谁先拿到锁谁先执行。

2、两个同步方法，两个对象调用。乌龟先跑？还是兔子先跑？ 答：兔子先跑

/**
 * @Description:乌龟沉睡3秒
 * @Package: com.cp.lock8
 * @ClassName: Lock2
 * @Author: cp
 * @Date: 2020/5/18 21:50
 * @Version: 1.0
 */
public class Lock1 {
    public static void main(String[] args) {
        Animal1 animal1=new Animal1();
        Animal1 animal2=new Animal1();
        new Thread(()->{
            animal1.wuGui();
        }).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            animal2.tuZi();
        }).start();
    }
}

class Animal1{
    public synchronized void wuGui(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("乌龟先跑");
    }
    public synchronized void tuZi(){
        System.out.println("兔子先跑");
    }
}

原因：synchronized 锁的是方法的调用者，也就是对象锁。两个对象分别调用两个方法持有的是两把把锁，兔子不需要等待。

3、一个同步方法，一个普通方法，一个对象调用，乌龟先跑？还是老虎先跑？ 答：老虎先跑

/**
 * @Description:乌龟沉睡3秒
 * @Package: com.cp.lock8
 * @ClassName: Lock2
 * @Author: cp
 * @Date: 2020/5/18 21:50
 * @Version: 1.0
 */
public class Lock2 {

    public static void main(String[] args) {
        Animal2 animal1=new Animal2();
 
        new Thread(()->{
            animal1.wuGui();
        }).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            animal1.Laohu();
        }).start();
    }


}

class Animal2{
    public synchronized void wuGui(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("乌龟先跑");
    }
    public synchronized void tuZi(){
        System.out.println("兔子先跑");
    }
    public void Laohu(){
        System.out.println("老虎先跑");
    }
}

原因：普通方法没有锁，不需要竞争锁。

4、两个同步方法，一个对象调用，乌龟沉睡3秒，乌龟先跑？还是兔子先跑？ 答：乌龟先跑

/**
 * @Description:乌龟沉睡3秒
 * @Package: com.cp.lock8
 * @ClassName: Lock2
 * @Author: cp
 * @Date: 2020/5/18 21:50
 * @Version: 1.0
 */
public class Lock2 {

    public static void main(String[] args) {
        Animal2 animal1=new Animal2();
     
        new Thread(()->{
            animal1.wuGui();
        }).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            animal1.tuZi();
        }).start();
    }
}

class Animal2{

    public synchronized void wuGui(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("乌龟先跑");
    }
    public synchronized void tuZi(){
        System.out.println("兔子先跑");
    }
}

原因：synchronized 锁的是方法的调用者，也就是对象锁。两个方法持有的是同一把锁，因此谁先拿到锁谁先执行。

5、两个静态同步方法，一个对象调用，乌龟先跑？还是兔子先跑？ 答：乌龟先跑

/**
 * @Description:乌龟先跑沉睡3秒
 * @Package: com.cp.lock8
 * @ClassName: Lock3
 * @Author: cp
 * @Date: 2020/5/18 22:03
 * @Version: 1.0
 */
public class Lock3 {

    public static void main(String[] args) {
        Animal3 animal1=new Animal3();
      
        new Thread(()->{
            animal1.wuGui();
        }).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            animal1.tuZi();
        }).start();
    }
}

class Animal3{
    public synchronized void wuGui(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("乌龟先跑");
    }

    public synchronized void tuZi(){
        System.out.println("兔子先跑");
    }
}

原因：static方法类一加载就执行，synchronized 锁的是Class对象即类所，所以两个方法持有一把锁，谁先得到谁先执行。

6、 两个静态同步方法，两个对象调用，乌龟先跑？还是兔子先跑？ 答：乌龟先跑

/**
 * @Description:乌龟先跑沉睡3秒
 * @Package: com.cp.lock8
 * @ClassName: Lock3
 * @Author: cp
 * @Date: 2020/5/18 22:03
 * @Version: 1.0
 */
public class Lock3 {

    public static void main(String[] args) {
        Animal3 animal1=new Animal3();
        Animal3 animal2=new Animal3();

        new Thread(()->{
            animal1.wuGui();
        }).start();

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

        new Thread(()->{
            animal2.tuZi();
        }).start();
    }
}

class Animal3{

    public synchronized void wuGui(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("乌龟先跑");
    }
    public synchronized void tuZi(){
        System.out.println("兔子先跑");
    }
}

原因：static方法类一加载就执行，synchronized 锁的是Class对象即类所，所以两个方法持有一把锁，谁先得到谁先执行。

7、一个静态同步方法，一个普通同步方法，一个对象调用，乌龟先跑？还是兔子先跑？ 答：兔子先跑

**
 * @Description:乌龟先跑沉睡3秒
 * @Package: com.cp.lock8
 * @ClassName: Lock3
 * @Author: cp
 * @Date: 2020/5/18 22:03
 * @Version: 1.0
 */
public class Lock4 {

    public static void main(String[] args) {
        Animal4 animal1=new Animal4();

        new Thread(()->{
            animal1.wuGui();
        }).start();

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

        new Thread(()->{
            animal1.tuZi();
        }).start();
    }
}

class Animal4{

    public static synchronized void wuGui(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("乌龟先跑");
    }
    public synchronized void tuZi(){
        System.out.println("兔子先跑");
    }
}

原因：静态同步方法和普通同步方法分别是类锁和对象锁，相当于两把锁，普通同步方法不要等待。

8、一个静态同步方法，一个普通同步方法，两个对象调用，乌龟先跑？还是兔子先跑？ 答：兔子先跑

**
 * @Description:乌龟先跑沉睡3秒
 * @Package: com.cp.lock8
 * @ClassName: Lock3
 * @Author: cp
 * @Date: 2020/5/18 22:03
 * @Version: 1.0
 */
public class Lock4 {

    public static void main(String[] args) {
        Animal4 animal1=new Animal4();
        Animal4 animal2=new Animal4();

        new Thread(()->{
            animal1.wuGui();
        }).start();

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

        new Thread(()->{
            animal2.tuZi();
        }).start();
    }
}

class Animal4{

    public static synchronized void wuGui(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("乌龟先跑");
    }
    public synchronized void tuZi(){
        System.out.println("兔子先跑");
    }
}

原因：静态同步方法和普通同步方法分别是类锁和对象锁，相当于两把锁，普通同步方法不要等待。

评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值