JUC的8锁现象

JUC的8锁现象

声明：本例题来自于B站，狂神说，传送门https://www.bilibili.com/video/BV1B7411L7tE

1、8锁问题 第一组

package com.study.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁问题   第一组
 * 1.phone中的两个方法被synchronized修饰，然后开启两个线程去调用，是先打电话还是先发短信
 * 2.TimeUnit.SECONDS.sleep(4);休眠4秒后是执行顺序是什么
 */
public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();

        new Thread(()->{
            phone.send();
        },"A").start();

        TimeUnit.SECONDS.sleep(4);

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

class Phone{

    // 发短信
    public synchronized void send(){
        System.out.println("发短信");
    }

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

2、8锁问题 第二组

package com.study.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁问题   第二组
 *  3、增加了一个普通方法后！先执行发短信还是Hello？ 普通方法  不受锁的影响，直接执行顺序即可
 *  4、 两个对象，两个同步方法， 发短信还是 打电话？  synchronized锁的是对象  两个对象不会去竞争锁
 */
public class Test2 {
    public static void main(String[] args) {
        Phone2 phone2 = new Phone2();
        Phone2 phone21 = new Phone2();

        new Thread(()->{
            phone2.send();
        },"A").start();

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

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

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

    public void hello(){
        System.out.println("say hello");
    }
}

3、8锁问题 第三组

package com.study.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁现象   第三组
 * 5、增加两个静态的同步方法，只有一个对象，先打印 发短信？打电话？   发短信   打电话
 * 6、两个对象！增加两个静态的同步方法， 先打印 发短信？打电话？
 */
public class Test3 {
    public static void main(String[] args) {
        Phone3 phone3 = new Phone3();
        Phone3 phone31 = new Phone3();
        new Thread(()->{
            phone3.send();
        },"A").start();

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

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

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

4、8锁问题 第四组

package com.study.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁现象  第四组
 * 7、1个静态的同步方法，1个普通的同步方法 ，一个对象，先打印 发短信？打电话？
 * synchronized 普通同步方法锁的是方法的调用着
 * 8、1个静态的同步方法，1个普通的同步方法 ，两个对象，先打印 发短信？打电话？
 */
public class Test4 {
    public static void main(String[] args) {
        // 两个对象的Class类模板只有一个，static，锁的是Class
        Phone4 phone4 = new Phone4();
        Phone4 phone41 = new Phone4();
        new Thread(()->{
            phone4.send();
        },"A").start();

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

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

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