synchronized关键字

synchronized是 Java 中的关键字，是一种同步锁。它修饰的对象有以下几种：

• 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；
• 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
  • 虽然可以使用 synchronized 来定义方法，但 synchronized 并不属于方法定义的一部分，因此，synchronized 关键字不能被继承。如果在父类中的某个方法使用了 synchronized 关键字，而在子类中覆盖了这个方法，在子类中的这个方法默认情况下并不是同步的，而必须显式地在子类的这个方法中加上 synchronized 关键字才可以。当然，还可以在子类方法中调用父类中相应的方法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，因此，子类的方法也就相当于同步了。
• 修饰一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
• 修改一个类，其作用的范围是 synchronized 后面括号括起来的部分，作用主的对象是这个类的所有对象。

售票案例

//第一步，创建资源类，定义属性和和操作方法
class Ticket {
    // 票数
    private int number = 30;
    // 操作方法：卖票
    public synchronized void sale() {
        // 判断：是否有票
        if(number > 0) {
            System.out.println(Thread.currentThread().getName()+" : 卖出："+(number--)+" 剩下："+number);
        }
    }
}

public class SaleTicket {
    //第二步，创建多个线程，调用资源类的操作方法
    public static void main(String[] args) {
        // 创建Ticket对象
        Ticket ticket = new Ticket();
        // 创建三个线程
        new Thread(() -> {
            // 调用卖票方法
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"AA").start();

        new Thread(() -> {
            // 调用卖票方法
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"BB").start();

        new Thread(() -> {
            // 调用卖票方法
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"CC").start();
    }
}

锁的对象

synchronized关键字意味着“给某个对象加锁”，实例方法的锁加在对象myClass上，静态方法的锁加在MyClass.class对象上。

示例代码：

public Class MyClass { 
  public void synchronized method1() { 
    // ... 
  }
  public static void synchronized method2() { 
    // ... 
  }
}

等价于

public class MyClass { 
  public void method1() { 
    synchronized(this) { 
      // ... 
    } 
  }
  public static void method2() { 
    synchronized(MyClass.class) 
    { 
      // ... 
    } 
  }
}

锁八问

锁八问，本质上只要对synchronized锁的对象有个清晰认知，都会很容易得到答案。

/**
 * 锁八问
 *
 * 1 标准访问（普通同步方法），先打印短信还是邮件
 * ------sendSMS
 * ------sendEmail
 *
 * 2 停4秒在短信方法内，先打印短信还是邮件
 * ------sendSMS
 * ------sendEmail
 *
 * 3 新增普通的hello方法，是先打短信还是hello
 * ------getHello
 * ------sendSMS
 *
 * 4 现在有两部手机，先打印短信还是邮件
 * ------sendEmail
 * ------sendSMS
 *
 * 5 两个静态同步方法，1部手机，先打印短信还是邮件
 * ------sendSMS
 * ------sendEmail
 *
 * 6 两个静态同步方法，2部手机，先打印短信还是邮件
 * ------sendSMS
 * ------sendEmail
 *
 * 7 1个静态同步方法,1个普通同步方法，1部手机，先打印短信还是邮件
 * ------sendEmail
 * ------sendSMS
 *
 * 8 1个静态同步方法,1个普通同步方法，2部手机，先打印短信还是邮件
 * ------sendEmail
 * ------sendSMS
 */

public class Lock_8 {
    public static void main(String[] args) throws Exception {

        Phone phone = new Phone();
        Phone phone2 = new Phone();

        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "AA").start();

        Thread.sleep(100);

        new Thread(() -> {
            try {
//             phone.sendEmail();
//             phone.getHello();
             phone2.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "BB").start();
    }
}

class Phone {

    public synchronized void sendSMS() throws Exception {
        // 停留4秒
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS");
    }

    public void sendEmail() throws Exception {
        System.out.println("------sendEmail");
    }

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

锁的本质

如果一份资源需要多个线程同时访问，那么需要给该资源加锁。加锁之后，可以保证同一时间只能有一个线程访问该资源。

资源可以是一个变量、一个对象或一个文件等。

锁是一个“对象”，作用如下：

• 这个对象内部得有一个标志位（state变量），记录自己有没有被某个线程占用。最简单的情况是这个state有0、1两个取值，0表示没有线程占用这个锁，1表示有某个线程占用了这个锁。
• 如果这个对象被某个线程占用，记录这个占用线程的thread ID。
• 这个对象维护一个thread id list，记录其他所有阻塞的、等待获取拿这个锁的线程。在当前线程释放锁之后从这个thread id list里面取一个线程唤醒。

要访问的共享资源本身也是一个对象，例如前面的对象myClass，这两个对象可以合成一个对象。代码就变成

synchronized(this) {
  //…
}

如果要访问的共享资源是对象a，锁加在对象a上（当然，也可以另外新建一个对象），代码变成

synchronized(obj1) {
  //…
}

这个时候，访问的共享资源是对象a，而锁加在新建的对象obj1上。资源和锁合二为一，这意味着这个对象既是共享资源，同时也具备“锁”的功能。也就是在Java里面，synchronized关键字可以加在任何对象的成员上面。

锁实现原理

在对象头里，有一块数据叫Mark Word。在64位机器上，Mark Word是8字节（64位）的，这64位中有2个重要字段：锁标志位和占用该锁的thread ID。

因为不同版本的JVM实现，对象头的数据结构会有各种差异。

此外，如果从反编译的字节码角度去看

• synchronized同步代码块，使用的是monitorenter和monitorexit指令实现
• synchronized普通同步方法，底层不像上面那样通过指令去控制，而是通过检查方法的ACC_SYNCHRONIZED访问标志是否被设置。
• synchronized静态同步方法，同样的通过检查方法的ACC_STATIC、ACC_SYNCHRONIZED访问标志是否被设置。

这里就不操作解析class文件了，详细见反解析class文件、class文件结构-访问标识