java 锁 访问普通方法_Java内置锁和简单用法

一、简单的锁知识

关于内置锁

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

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

对象锁和类锁

这其实也是Java的内置锁。

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

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

1.synchronized修饰普通方法

class A {

public synchronized voidtest() {

}

public void test2() {

}

}

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

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

2.同步块(对象锁)

classA {public voidtest() {synchronized(this) {//也可以锁其他对象

xxx

}

}

}

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

3.类锁(同步块)

classA {public voidtest() {synchronized(A.class) {

xxx

}

}

}

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

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

classA {public static synchronized voidtest() {

}

}

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

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

看下这个例子：

public classTestSynchronized

{public synchronized voidtest1()

{int i = 5;while( i-- > 0)

{

System.out.println(Thread.currentThread().getName()+ " : " +i);try{

Thread.sleep(500);

}catch(InterruptedException ie)

{

}

}

}public static synchronized voidtest2()

{int i = 5;while( i-- > 0)

{

System.out.println(Thread.currentThread().getName()+ " : " +i);try{

Thread.sleep(500);

}catch(InterruptedException ie)

{

}

}

}public static voidmain(String[] args)

{final TestSynchronized myt2 = newTestSynchronized();

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 :4test2 :4test1 :3test2 :3test2 :2test1 :2test2 :1test1 :1test1 :0test2 :0

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

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

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

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