Java内置锁和简单用法

一、简单的锁知识

关于内置锁

Java具有通过synchronized关键字实现的内置锁，内置锁获得锁和释放锁是隐式的，进入synchronized修饰的代码就获得锁，走出相应的代码就释放锁。

java内置锁是一个互斥锁，这就是意味着最多只有一个线程能够获得该锁，当线程A尝试去获得线程B持有的内置锁时，线程A必须等待或者阻塞，直到线程B释放这个锁，如果B线程不释放这个锁，那么A线程将永远等待下去。

对象锁和类锁

这其实也是Java的内置锁。

对象锁是用于对象实例方法，或者一个对象实例上的，类锁是用于类的静态方法或者一个类的class对象上的。我们知道，类的对象实例可以有很多个，但是每个类只有一个class对象，所以不同对象实例的对象锁是互不干扰的，但是每个类只有一个类锁。但是有一点必须注意的是，其实类锁只是一个概念上的东西，并不是真实存在的，它只是用来帮助我们理解锁定实例方法和静态方法的区别的。

二、synchronized所代表的内置锁的使用方法

1.synchronized修饰普通方法

class A {
　　public synchronized void test() {

　　}
　　public void test2() {

　　}
}

这种情况下，用的其实是这个方法所在的类的实例对象的锁，也就是A的一个实例的对象锁。意思是，比如A a = new A();，如果两个线程同时调用了a的这个test方法，那么先调用的那个线程，就先拿到这个实例a的对象锁，而另一个线程呢，就要只能等拿到a锁的那个线程运行完这个test方法后，把锁放了，然后再抢到实例a对象锁后才能运行这个test方法。

注意，虽然说锁的是这个方法所在类的实例对象，但其他线程是可以自由访问这个对象中的非同步方法的。比如这个A类中还有另一个方法叫test2，是不同步的，那么即使线程1抢到对象锁，在进行test方法中，线程2是可以同时访问运行test2方法的，因为这是个不同步的方法。

2.同步块（对象锁）

class A {
    public void test() {
        synchronized(this) {//也可以锁其他对象
            xxx
        }
    }
}

这个锁的也是某个对象的实例。

3.类锁（同步块）

class A {
    public void test() {
        synchronized(A.class) {
            xxx
        }
    }
}

其实一鬼样的，就是之前锁的是实例对象，现在锁的是一个类，或者说是一个类对象（Class Object），类锁只是抽象出来的一个概念，而且因为类的Class Object或者说加载的类信息只有一个，所有抽象出来个类锁。

4.类锁之——修饰static方法

class A {
    public static synchronized void test() {

    }
}

synchronized修饰static的方法的时候，也是类锁，锁的也是这个类，或者说是这个类的Class Object，因为静态方法是所有对象实例共有的，一个类只有一个，static方法也是在类加载的时候就加载了，所以synchronized修饰static方法的时候，锁也是唯一的，所以也是类锁哦。

三、关于类锁和对象锁的注意：

看下这个例子：

public class TestSynchronized
{
    public synchronized void test1()
    {
              int i = 5;
              while( i-- > 0)
              {
                   System.out.println(Thread.currentThread().getName() + " : " + i);
                   try
                   {
                        Thread.sleep(500);
                   }
                   catch (InterruptedException ie)
                   {
                   }
              }
    }
    public static synchronized void test2()
    {
         int i = 5;
         while( i-- > 0)
         {
              System.out.println(Thread.currentThread().getName() + " : " + i);
              try
              {
                   Thread.sleep(500);
              }
              catch (InterruptedException ie)
              {
              }
         }
    }
    public static void main(String[] args)
    {
         final TestSynchronized myt2 = new TestSynchronized();
         Thread test1 = new Thread(  new Runnable() {  public void run() {  myt2.test1();  }  }, "test1"  );
         Thread test2 = new Thread(  new Runnable() {  public void run() { TestSynchronized.test2();   }  }, "test2"  );
         test1.start();
         test2.start();
//         TestRunnable tr=new TestRunnable();
//         Thread test3=new Thread(tr);
//         test3.start();
    }
}

test1 : 4
test2 : 4
test1 : 3
test2 : 3
test2 : 2
test1 : 2
test2 : 1
test1 : 1
test1 : 0
test2 : 0

上面代码synchronized同时修饰静态方法和实例方法，但是运行结果是交替进行的，这证明了类锁和对象锁是两个不一样的锁，控制着不同的区域，它们是互不干扰的。同样，线程获得对象锁的同时，也可以获得该类锁，即同时获得两个锁，这是允许的。

其实这个也很显然，一个锁的是类的实例，一个是类的Class Object，这两个都不是一个东西hh。

四、synchronized中条件判断用while而不是用if

例子见这篇文章：https://www.cnblogs.com/heyboom/p/9147469.html