JUC -八锁现象

juc的八锁现象

8锁其实就是关于锁的8个问题

1. 问题一和问题二
   代码演示：

1.标准情况下，两个线程先打印 发短信和打电话
2.senMesg 延迟4秒，两个线程先打印 发短信和打电话
因为方法上有锁，锁的是phone这个类，所有会先发短信 再打电话
* */
public class Test1 {

    public static void main(String[] args) {

        Phone phone = new Phone();

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

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

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

    }
}

class Phone{

    //synchronized  锁的对象是方法的调用者
    public synchronized void senMesg(){

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

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

2.问题三：
代码演示

3.一个普通方法hello ，和一个同步方法，senMesg 先输出 hello 后发短信
* */
public class Test2 {

    public static void main(String[] args) {

        Phone1 phone = new Phone1();

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

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

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

    }
}

class Phone1{

    //synchronized  锁的对象是方法的调用者
    public synchronized void senMesg(){

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

        System.out.println("发短信");
    }

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

    //不受锁的影响
    public void hello(){
        System.out.println("hello");
    }

}

3.问题四
代码演示

4.两个对象 执行两个同步方法
* */
public class Test3 {

    public static void main(String[] args) {

        //两个对象，两把不同的锁
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();

        new Thread(()->{
            phone1.senMesg();
        },"A").start();

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

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

    }
}

class Phone2{

    //synchronized  锁的对象是方法的调用者
    public synchronized void senMesg(){

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

        System.out.println("发短信");
    }

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


}

4. 问题五 问题六（自行根据文字描述 进行测试）
   代码演示：

5. 两个静态同步方法 只有一个对象
6.两个对象，对象1 执行发短信 对象2执行 发短信，再电话
* */
public class Test4{

    public static void main(String[] args) {


        Phone3 phone1 = new Phone3();


        new Thread(()->{
            phone1.senMesg();
        },"A").start();

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

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

    }
}

//只有唯一的一个class 对象
class Phone3{

    //synchronized  锁的对象是方法的调用者
    // static 静态方法 类一加载就有了  Class 模板 锁的是class
    public static synchronized void senMesg(){

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

        System.out.println("发短信");
    }

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


}

5.问题七 和问题八（自行根据文字描述 进行测试）
代码演示：

7.一个静态的同步方法 和一个普通同步方法  先打电话 再发短信
8.两个对象 对象1 执行静态同步方法 对象2 执行同步方法 结果还是 先打电话再发短信
* */
public class Test5{

    public static void main(String[] args) {


        Phone4 phone1 = new Phone4();


        new Thread(()->{
            phone1.senMesg();
        },"A").start();

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

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

    }
}

//只有唯一的一个class 对象
class Phone4{

    //synchronized  锁的对象是方法的调用者
    // static 静态同步方法  锁的是class类模板
    public static synchronized void senMesg(){

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

        System.out.println("发短信");
    }

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


}

总结 ：
1.new 出来的对象 可以使用this 关键字进行指定，而对象可以通过new 创建多个对象 ，synchronized 就是将对象作为锁。
2.static 是静态关键字，修饰同步（synchronized 就是将对象作为锁，）方法的时候表示，锁的对象是 类模板 class 。 同一个类new 出来的对象可以有多个 但是他们都只有唯一的一个类模板。