八个例子彻底理解锁

于 2020-05-08 18:54:16 发布
阅读量269 收藏
点赞数 1
分类专栏： JUC并发编程 文章标签： lambda thread java proxy
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42369886/article/details/106000740
版权

例子一：一个对象，两个加锁方法
下面代码运行结果是先输出打电话还是发短信

public class Test1 {
    public static void main(String[] args) {
        Phone phone= new Phone();
         //这里的->是lambda表达式的写法
        new Thread(()-> {
            phone.sendMessage();
        },"A").start();

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

        new Thread(()->{
            phone.call();
        },"B").start();
    }
}
class Phone{
  public  synchronized  void sendMessage(){
      System.out.println("发短信");
  }

  public  synchronized  void call(){
      System.out.println("打电话");
  }
}

例子二：在例子一的基础上让第一个加锁方法睡眠4秒再执行
下面代码运行结果是先输出打电话还是发短信


public class Test1 {
    public static void main(String[] args) {
        Phone phone= new Phone();
         //这里的->是lambda表达式的写法
        new Thread(()-> {
            phone.sendMessage();
        },"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 sendMessage(){
      try {
      //睡眠4秒再执行
          TimeUnit.SECONDS.sleep(4);
      } catch (InterruptedException e) {
          e.printStackTrace();
      }
      System.out.println("发短信");
  }
 //synchronized 锁的对象是方法的调用者
  public  synchronized  void call(){
      System.out.println("打电话");
  }
}

例子三：一个普通方法hello和一个加锁的方法
下面代码运行结果是先输出你好还是发短信


public class Test2 {
    public static void main(String[] args) {
        Phone2 phone= new Phone2();
        //这里的->是lambda表达式的写法
        new Thread(()-> {
            phone.sendMessage();
        },"A").start();

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

        new Thread(()->{
            phone.hello();
        },"B").start();
    }
}
class Phone2{
    
    public  synchronized  void sendMessage(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

例子四：两个对象，两个加锁方法
下面代码运行结果是先输出打电话还是发短信

//两个对象，两个同步方法，先打电话后发短信
public class Test2 {
    public static void main(String[] args) {
        //两个对象
        Phone2 phone1= new Phone2();
        Phone2 phone2= new Phone2();
        //这里的->是lambda表达式的写法
        new Thread(()-> {
            phone1.sendMessage();
        },"A").start();

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

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

    public  synchronized  void sendMessage(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public  synchronized  void call(){
        System.out.println("打电话");
    }

 
}

例子五：一个对象，两个static加锁方法
下面代码运行结果是先输出打电话还是发短信


public class Test3 {
    public static void main(String[] args) {
        Phone3 phone= new Phone3();
        //这里的->是lambda表达式的写法
        new Thread(()-> {
            phone.sendMessage();
        },"A").start();

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

        new Thread(()->{
            phone.call();
        },"B").start();
    }
}
class Phone3{
   //static静态方法
    //类一加载就有了 锁的class类
    //所以此时锁的是同一个锁
    public static synchronized  void sendMessage(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public static synchronized  void call(){
        System.out.println("打电话");
    }


}

例子六：两个对象，两个static加锁方法
下面代码运行结果是先输出打电话还是发短信


public class Test3 {
    public static void main(String[] args) {
        //两个对象的class类模板只有一个，static锁的是class
        Phone3 phone1= new Phone3();
        Phone3 phone2= new Phone3();
        //这里的->是lambda表达式的写法
        new Thread(()-> {
            phone1.sendMessage();
        },"A").start();

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

        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}
class Phone3{
   //static静态方法
    //类一加载就有了 锁的class类
    //所以此时锁的是同一个锁
    public static synchronized  void sendMessage(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public static synchronized  void call(){
        System.out.println("打电话");
    }
}

例子七：一个对象，一个static加锁方法，一个普通加锁同步方法
下面代码运行结果是先输出打电话还是发短信


public class Test4 {
    public static void main(String[] args) {
        Phone4 phone= new Phone4();
        //这里的->是lambda表达式的写法
        new Thread(()-> {
            phone.sendMessage();
        },"A").start();

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

        new Thread(()->{
            phone.call();
        },"B").start();
    }
}
class Phone4{
    //静态同步方法，锁的类模板
    public static synchronized  void sendMessage(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    //普通同步方法，锁的调用方法
    public  synchronized  void call(){
        System.out.println("打电话");
    }


}

例子八：两个对象，一个static加锁方法，一个普通加锁同步方法
下面代码运行结果是先输出打电话还是发短信


public class Test4 {
    public static void main(String[] args) {

        Phone4 phone1= new Phone4();
        Phone4 phone2= new Phone4();
        //这里的->是lambda表达式的写法
        new Thread(()-> {
            phone1.sendMessage();
        },"A").start();

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

        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}
class Phone4{
    //静态同步方法，锁的类模板
    public static synchronized  void sendMessage(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    //普通同步方法，锁的调用方法
    public  synchronized  void call(){
        System.out.println("打电话");
    }


}

例子一运行结果：发短信 打电话
例子二运行结果：等待4秒后输出 发短信 打电话
例子三运行结果：先输出你好 后输出 发短信
例子四运行结果：先输出打电话 再发短信
例子五运行结果：先发短信后打电话
例子六运行结果：先发短信后打电话
例子七运行结果：先打电话，后发短信
例子八运行结果：先打电话，后发短信

小结

static synchronized 锁的是class
synchronized 锁的是对象
谁先获取到对象谁就先执行

声明：本文为学习狂神说java的juc并发编程所做的笔记，狂神说javajuc并发编程地址：https://www.bilibili.com/video/BV1B7411L7tE?p=11

Gebo
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值