多线程问题（二）

两个线程分别调用同一个类的两个不同对象的不同普通synchronized方法

public class LockTest03 {
    public static void main(String[] args) throws InterruptedException {

        Phone phone1=new Phone();
        Phone phone2=new Phone();
        // 打电话
        new Thread(()->phone1.call()).start();
        // 睡眠1s
        TimeUnit.MILLISECONDS.sleep(1000L);
        // 发短信
        new Thread(()->phone2.sendMsg()).start();
    }
}

// 手机类
class Phone{
    // 打电话
    public synchronized void call()  {
        try {
            TimeUnit.MILLISECONDS.sleep(3000L);
            System.out.println("打电话");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

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

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

结果

synchronized方法，锁的是方法的调用者，这里是两个不同的对象，所以两个对象phone1和phone2都会加锁，执行时互不影响，但是由于phone1调用的call()方法会有休眠延迟打印，所以phone2的sendMsg方法先执行完毕，结果就是先发短信再打电话

两个线程分别调用同一个类的两个不同对象的不同静态synchronized方法

public class LockTest04 {
    public static void main(String[] args) throws InterruptedException {

        Phone phone1=new Phone();
        Phone phone2=new Phone();
        // 打电话
        new Thread(()->phone1.call()).start();
        // 睡眠1s
        TimeUnit.MILLISECONDS.sleep(1000L);
        // 发短信
        new Thread(()->phone2.sendMsg()).start();
    }
}

// 手机类
class Phone{
    // 打电话
    public static synchronized void call()  {
        try {
            TimeUnit.MILLISECONDS.sleep(3000L);
            System.out.println("打电话");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

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

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

结果

静态同步方法属于类，所以这里的synchronized锁的是Class,Class只有一个,当call()方法被调用时会加锁，调用sendMsg()方法的线程就需要等待了