类锁

* 对象锁（synchronized method{}）和类锁（static sychronized method{}）的区别

     - 对象锁也叫实例锁，对应synchronized关键字，当多个线程访问多个实例时，它们互不干扰，每个对象都拥有自己的锁，如果是单例模式下，那么就是变成和类锁一样的功能。

     - 对象锁防止在同一个时刻多个线程访问同一个对象的synchronized块。如果不是同一个对象就没有这样子的限制。

     - 加锁静态方法，即类锁。可以换个方向理解，静态方法其实就是类方法，所以加锁静态方法，即类锁。类锁的范围是整个实体类，即全局锁。

• 代码实例

  ``

    package com.shige.Thread;
      /*
        类锁，类锁只有一个
       */
  public class ThreadTest12 {
      public static void main(String[] args) throws InterruptedException {
  
          //创建线程
          Thread thread=new Thread(new Precossor_12());
          thread.setName("t1");
          Thread thread1=new Thread(new Precossor_12());
          thread1.setName("t2");
  
          //启动线程
          thread.start();
  
          //延迟保证thread先执行
          Thread.sleep(1000);
          thread1.start();
  
      }
  
  
  }
  
  class Precossor_12 implements Runnable{
  
      @Override
      public void run() {
         if("t1".equals(Thread.currentThread().getName())){
             MyClass.m1();
         }
  
          if("t2".equals(Thread.currentThread().getName())){
              MyClass.m2();
          }
      }
  }
  
  class MyClass{
      //synchronized 添加到静态方法上，线程执行到此方法后，会去找类锁
     public synchronized static void m1(){
         try {
             Thread.sleep(5000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println("m1..............");
     }
  
      // 该方法不会等m1结束在执行，有哪位它没有被synchronized修饰，如果使用synchronized修饰，那么就一定会等m1结束再执行
      public  static void m2(){
          System.out.println("m2..............");
  
      }
  }