八种情况下分析Sychronized锁的执行

目录

情况1+2、两个方法锁一个对象(有无sleep)

情况3、一个对象，二个方法(一个带锁的方法，一个普通方法)

情况4、两个对象，两个同步方法

情况5+6、两个静态同步方法(一个对象/两个对象)

情况7+8、一个静态同步方法一个同步方法(一或二个对象)

总结

---

 

 

原理：

1.如果两个方法是由同一个锁对象调用的，则会按照main线程执行顺序执行

2.如果使用方法上为static synchronized代表锁的是类模板，多个对象调用多个static synchronized方法，本质上都在用同一个类模板，还是看main线程的执行顺序

3.如果两个线程，一个锁对象是类模板，一个是普通的对象，则两个线程互不影响。一般谁先执行完谁先打印

 

情况1+2、两个方法锁一个对象(有无sleep)

public class Test1 {
    //两个锁线程，正常情况下，谁先执行？  一定是发短信先执行，再执行打电话
    //我们让发短信线程睡上4s，哪个线程先执行？ 一定还是发短信先执行
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{
            phone.sendSms();
        },"A").start();

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

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

class Phone{
    //两个方法用Synchronized锁的是同一个对象，谁先拿到谁执行，执行完毕释放锁另一个再执行
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

 

情况3、一个对象，二个方法(一个带锁的方法，一个普通方法)

没有sleep的情况下，带锁的方法会先执行，有sleep的情况下普通方法会先于带锁的方法执行。原因在于锁方法对普通方法无效，如果没有sleep，带锁方法由于在main方法中被调用的位置靠上，会先进入JVM执行，位置靠下的普通方法会后进入JVM执行

package com.lt.lock8;

import java.util.concurrent.TimeUnit;

public class Test2 {
    public static void main(String[] args) {
        Phone2 phone = new Phone2();
        new Thread(()->{
            phone.sendSms();
        },"A").start();

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

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

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

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

 

情况4、两个对象，两个同步方法

两个锁互不影响，同时开始执行，谁先执行完谁会显示在控制台上

package com.lt.lock8;

import java.util.concurrent.TimeUnit;

public class Test2 {
    //两个锁线程，正常情况下，谁先执行？  一定是发短信先执行，再执行打电话
    //我们让发短信线程睡上4s，哪个线程先执行？ 一定还是发短信先执行
    public static void main(String[] args) {
        Phone2 phone = new Phone2();
        Phone2 phone1 = new Phone2();

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

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

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

class Phone2{
    //两个方法用Synchronized锁的是同一个对象，谁先拿到谁执行，执行完毕释放锁另一个再执行
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

 

情况5+6、两个静态同步方法(一个对象/两个对象)

static修饰的静态同步方法锁的是类，由于只有一个类，因此无论是否有sleep，有几个对象，永远是main方法中最上面的语句先执行。

package com.lt.lock8;

import java.util.concurrent.TimeUnit;

public class Test3 {
    //两个锁线程，正常情况下，谁先执行？  一定是发短信先执行，再执行打电话
    //我们让发短信线程睡上4s，哪个线程先执行？ 一定还是发短信先执行
    public static void main(String[] args) {
        Phone3 phone = new Phone3();
        Phone3 phone1 = new Phone3();

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

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

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

class Phone3{
    //两个方法用Synchronized锁的是同一个对象，谁先拿到谁执行，执行完毕释放锁另一个再执行
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

 

情况7+8、一个静态同步方法一个同步方法(一或二个对象)

一个锁的是类模板，一个锁的是对象，二者互相不影响。main函数进入虚拟机时，一个条没走完，不影响第二个线继续走，谁先执行成功先打印谁。

package com.lt.lock8;

import java.util.concurrent.TimeUnit;

public class Test4 {
    //两个锁线程，正常情况下，谁先执行？  一定是发短信先执行，再执行打电话
    //我们让发短信线程睡上4s，哪个线程先执行？ 一定还是发短信先执行
    public static void main(String[] args) {
        Phone4 phone = new Phone4();
        Phone4 phone1 = new Phone4();

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

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

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

class Phone4{
    //两个方法用Synchronized锁的是同一个对象，谁先拿到谁执行，执行完毕释放锁另一个再执行
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

 

总结

new this 的是一个具体的手机对象

static Class是唯一的一个模板