菜单 学习猿地 - LMONKEY

VIP

开通学习猿地VIP

尊享10项VIP特权 持续新增

知识通关挑战

打卡带练!告别无效练习

接私单赚外块

VIP优先接,累计金额超百万

学习猿地私房课免费学

大厂实战课仅对VIP开放

你的一对一导师

每月可免费咨询大牛30次

领取更多软件工程师实用特权

入驻
397
0

关于锁的8个问题

原创
05/13 14:22
阅读数 16787

问题一:下面代码先执行打电话还是发短信      发短信

public class A {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();

        // 锁的存在
        new Thread(()->{
            try {
                phone.sendmsg();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();
        // 休息1s
        TimeUnit.SECONDS.sleep(1);

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

    }
}
@SuppressWarnings("all")
class Phone {

    // synchronized锁的对象是方法的调用者
    // 两个方法用的是同一个锁,谁先拿到谁执行
    public  synchronized void sendmsg() throws InterruptedException {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("发短信");
    }
    public synchronized void call() {
        System.out.println("打电话");
    }

}

 

 

 

问题二---如果变为两个对象,下面代码先执行打电话还是发短信?      打电话

public class A {
    public static void main(String[] args) throws InterruptedException {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();
        

        // 锁的存在
        new Thread(()->{
            try {
                phone1.sendmsg();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();
        // 休息1s
        TimeUnit.SECONDS.sleep(1);

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

    }
}
@SuppressWarnings("all")
class Phone {

    // synchronized锁的对象是方法的调用者
    // 两个方法用的是同一个锁,谁先拿到谁执行
    public  synchronized void sendmsg() throws InterruptedException {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("发短信");
    }
    public synchronized void call() {
        System.out.println("打电话");
    }

}

 

 

 

问题三---增加普通方法,先打印发短信还是hello?

public class B {
    public static void main(String[] args) throws InterruptedException {
        Phone2 phone = new Phone2();

        new Thread(()->{
            try {
                phone.sendmsg();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();
        // 休息1s
         TimeUnit.SECONDS.sleep(1);

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

    }
}
@SuppressWarnings("all")
class Phone2 {

    // synchronized锁的对象是方法的调用者
    // 两个方法用的是同一个锁,谁先拿到谁执行
    public  synchronized void sendmsg() throws InterruptedException {

        TimeUnit.SECONDS.sleep(4);
        System.out.println("发短信");
    }
    public synchronized void call() {
        System.out.println("打电话");
    }
    // 这里没有锁,不是同步方法,不受锁的影响
    public  void hello() {
        System.out.println("hello");
    }

}

 

 

 问题四---用不同对象去调用发短信和hello方法,执行结果?

public class B {
    public static void main(String[] args) throws InterruptedException {
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();

        new Thread(()->{
            try {
                phone1.sendmsg();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();
        // 休息1s
         TimeUnit.SECONDS.sleep(1);

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

    }
}
@SuppressWarnings("all")
class Phone2 {

    public  synchronized void sendmsg() throws InterruptedException {

        TimeUnit.SECONDS.sleep(4);
        System.out.println("发短信");
    }
    public synchronized void call() {
        System.out.println("打电话");
    }
    // 这里没有锁,不是同步方法,不受锁的影响
    public  void hello() {
        System.out.println("hello");
    }

}

 

 解释同上

 

问题5---当加了static关键字之后,执行结果是怎样的?

public class C {
    public static void main(String[] args) throws InterruptedException {
        Phone3 phone = new Phone3();
        new Thread(()->{
            try {
                phone.sendmsg();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();
        // 休息1s
        TimeUnit.SECONDS.sleep(1);

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

    }
}
@SuppressWarnings("all")
// phone3只有唯一的一个class对象 phone3.class(全局唯一)
class Phone3 {

    // synchronized锁的对象是方法的调用者
    // 两个方法用的是同一个锁,谁先拿到谁执行
    // static 静态方法,类一加载就有了,class 模板
    // 此时锁的就是class
    public  static synchronized void sendmsg() throws InterruptedException {

        TimeUnit.SECONDS.sleep(4);
        System.out.println("发短信");
    }
    public static synchronized void call() {
        System.out.println("打电话");
    }
}

 

 

 

问题6---当加了static关键字来修饰之后,用两个不同对象来调用,执行结果又是怎样?

public class C {
    public static void main(String[] args) throws InterruptedException {
        // 两个对象,但此时锁的是class,不关对象事。
        // 两个对象的class类模板只有一个
        Phone3 phone1 = new Phone3();
        Phone3 phone2 = new Phone3();


        new Thread(()->{
            try {
                phone1.sendmsg();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();
        // 休息1s
        TimeUnit.SECONDS.sleep(1);

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

    }
}
@SuppressWarnings("all")
// phone3只有唯一的一个class对象 phone3.class(全局唯一)
class Phone3 {

    // synchronized锁的对象是方法的调用者
    // 两个方法用的是同一个锁,谁先拿到谁执行
    // static 静态方法,类一加载就有了,class 模板
    // 此时锁的就是class
    public  static synchronized void sendmsg() throws InterruptedException {

        TimeUnit.SECONDS.sleep(4);
        System.out.println("发短信");
    }
    public static synchronized void call() {
        System.out.println("打电话");
    }
}

 

 

问题7--普通同步方法和静态同步方法放一起,执行顺序是怎样的?

public class D {
    public static void main(String[] args) throws InterruptedException {

        Phone4 phone = new Phone4();

        new Thread(()->{
            try {
                phone.sendmsg();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();
        // 休息1s
        TimeUnit.SECONDS.sleep(1);

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

    }
}
@SuppressWarnings("all")
// phone3只有唯一的一个class对象 phone3.class(全局唯一)
class Phone4 {


    // 静态同步方法
    public  static synchronized void sendmsg() throws InterruptedException {

        TimeUnit.SECONDS.sleep(4);
        System.out.println("发短信");
    }
    // 普通同步方法
    public  synchronized void call() {
        System.out.println("打电话");
    }


}

 

 分析:

 

 问题8:两个不同对象来调用,结果又是怎样?

public class D {
    public static void main(String[] args) throws InterruptedException {

        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();

        new Thread(()->{
            try {
                phone1.sendmsg();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();
        // 休息1s
        TimeUnit.SECONDS.sleep(1);

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

    }
}
@SuppressWarnings("all")
// phone3只有唯一的一个class对象 phone3.class(全局唯一)
class Phone4 {


    // 静态同步方法
    public  static synchronized void sendmsg() throws InterruptedException {

        TimeUnit.SECONDS.sleep(4);
        System.out.println("发短信");
    }
    // 普通同步方法
    public  synchronized void call() {
        System.out.println("打电话");
    }


}

结果:

 

发表评论

0/200
397 点赞
0 评论
收藏