8锁现象详解

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

对象、class   。

1.前两个问题

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问题

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

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个问题

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个问题

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");
        }

    }





}

加拓展 

8锁现象详解_第1张图片

你可能感兴趣的:(JUC,java,开发语言)