3、多线程锁-8锁分析

1、8锁问题

1 标准访问，先打印短信还是邮件
短信
2 停4秒在短信方法内，先打印短信还是邮件
短信，因为synchronized修饰在方法中，属于同步方法，此时锁的是当前实例对象，此时线程先访问短信，得等起执行完成才释放锁，然后才运行邮件
3 普通的hello方法，是先打短信还是hello
hello
因为普通方法并没有锁住，不受影响
4 现在有两部手机，先打印短信还是邮件
邮件
因为synchronized修饰在方法中，属于同步方法，锁的是当前实例对象，此时两部手机（对象）,相互之间并不会受到影响
5 两个静态同步方法，1部手机，先打印短信还是邮件
短信
静态同步方法，锁是当前类的Class对象，不管你访问那个对象，都是当前的类，都会受到影响
6 两个静态同步方法，2部手机，先打印短信还是邮件
短信
7 1个静态同步方法（短信），1个普通同步方法，1部手机，先打印短信还是邮件
邮件
静态同步方法锁的是当前类的Class对象
普通同步方法锁的是当前实例对象
并不会受到影响
8 1个静态同步方法，1个普通同步方法，2部手机，先打印短信还是邮件
邮件

class Phone{
    public static synchronized void sendSms() throws InterruptedException {
        Thread.sleep(3000);
        System.out.println("====sendSms==短信====");
        
    }
    public static synchronized void sendEmail(){
        System.out.println("====sendEmail==邮件====");
    }
    /**
     * 普通方法
     */
    public void getHello(){
        System.out.println("====Hello====");
    }
}
public class ThreadLock8 {
    public static void main(String[] args) throws Exception {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();

        new Thread(()->{
            try {
                phone1.sendSms();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"AA").start();
        //TimeUnit.SECONDS.sleep(1);

        new Thread(()->{
//            phone1.sendEmail();
            phone1.sendEmail();
        },"BB").start();

        new Thread(()->{
            phone1.getHello();
        },"CC").start();
    }
}

2、分析

A 一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方法了，
其它的线程都只能等待，换句话说，某一个时刻内，只能有唯一一个线程去访问这些synchronized方法
锁的是当前对象this，被锁定后，其它的线程都不能进入到当前对象的其它的synchronized方法

加个普通方法后发现和同步锁无关
换成两个对象后，不是同一把锁了，情况立刻变化。

synchronized实现同步的基础：Java中的每一个对象都可以作为锁。
具体表现为以下3种形式。
对于普通同步方法，锁是当前实例对象。==>this
对于静态同步方法，锁是当前类的Class对象。==>class
对于同步方法块，锁是Synchonized括号里配置的对象

//静态同步方法
public static synchronized void sendSms(){
}
//普通同步方法
public synchronized void sendSms(){
}
//同步方法块
public void sendSms(){
    synchronized(this){
}
}

当一个线程试图访问同步代码块时，它首先必须得到锁，退出或抛出异常时必须释放锁。

也就是说如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁，
可是别的实例对象的非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁，
所以毋须等待该实例对象已获取锁的非静态同步方法释放锁就可以获取他们自己的锁。

所有的静态同步方法用的也是同一把锁——类对象本身，
这两把锁（this/class）是两个不同的对象，所以静态同步方法与非静态同步方法之间是不会有竞态条件的。
但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁，
而不管是同一个实例对象的静态同步方法之间，
还是不同的实例对象的静态同步方法之间，只要它们同一个类的实例对象！