第三章对象锁类锁

Synchronized的两个用法：
一、对象锁：
包括方法锁（默认锁对象为this当前实例对象）和同步代码块锁（自己指定锁对象）
Object instance = new Object();
public void synchronized hello(){}//锁对象默认当前this对象
synchronized(instance){}

二、类锁
指synchronized修饰静态的方法或指定锁为Class对象，Class对象其实也是一个Object对象。类锁在同一时刻只能被一个对象拥有，即便是不同的Runnable实例，线程所对应的类锁也只有一个。相同的Runnable实例，线程对应的对象锁只有一个。
1，把synchronized 加在static方法上
public static void synchronized hello(){}
2，synchronized(*.class)
static synchronized (Object.class){}

三、t1,t2两个线程抢一个锁的时候，如果t1抢到了，那么此时t1就变成RUNNABLE状态，t2就是BLOCKED状态。

四、两个线程两个锁

package com.xixi;

/**synchronized的使用
 * 对象所示例1，代码块形式 created by ccai6 on 02/07/2020
 */
public class SynchronizedObjectCodeBlock2 implements Runnable {

  private static SynchronizedObjectCodeBlock2 instance
      = new SynchronizedObjectCodeBlock2();
  //自己创建对象锁
  Object lock1 = new Object();
  Object lock2 = new Object();

  @Override
  public void run() {

//    synchronized (this) {
    synchronized (lock1) {
      System.out.printf("线程[%s]进入lock1\n", Thread.currentThread().getName());
      try {
        Thread.sleep(3000);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      System.out.printf("线程[%s]退出lock1\n", Thread.currentThread().getName());
    }
    synchronized (lock2) {
      System.out.printf("线程[%s]进入lock2\n", Thread.currentThread().getName());
      try {
        Thread.sleep(3000);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      System.out.printf("线程[%s]退出lock2\n", Thread.currentThread().getName());
    }
  }

  public static void main(String[] args) {

    Thread t1 = new Thread(instance);
    Thread t2 = new Thread(instance);
    t1.start();
    t2.start();
    while (t1.isAlive() || t2.isAlive()) {

    }

    System.out.println("finished");

  }
}

实际上t1进入lock2和t2进入lock1这两个是可以同时进行的。