synchronized和ReentrantLock锁住了谁？
一、synchronized
案例1：
public class LockDemo{ public static void main(String[] args) throws Exception { Human human = new Human(); new Thread(() -> { try { human.drink(); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } },"A").start(); Thread.sleep(100);//确保A线程先启动 new Thread(() -> { Human.sleep(); },"B").start(); } } class Human{ public void eat() { System.out.println(Thread.currentThread().getName()+ ": *****eat*****"); } public synchronized void drink() throws Exception { TimeUnit.SECONDS.sleep(3); System.out.println(Thread.currentThread().getName()+": *****drink*****"); } public synchronized static void sleep() { System.out.println(Thread.currentThread().getName()+": *****sleep*****"); } }
由于输出结果是动态的不好截图，是能口述输出结果：先输出B：******sleep*****，2.9秒后输出A：******drink*****
在main方法中，使用Thread.sleep(100)秒让主线程睡眠，确保A线程先于B线程拿到资源。首先，我们知道sleep方法并不会是释放锁对象，按理说输出结果应该是三秒后同时输出A：******drink*****和B：******sleep*****，怎么会出现上面的结果呢？原因很简单，dink方法上的synchronized和sleep方法上的synchronized锁的不是同一个资源！
当在非静态方法上加锁，锁的是类的实例对象。当在静态方法上加锁，所得就是类的对象。也就是说当线程A调用加锁方法drink后，其他线程不能再调用此方法的加锁资源，但是线程B之所以可以调用sleep方法，是因为线程B拿到的是类对象的锁，两者并不冲突，就好像两个人进两扇门，谁也不碍着谁。
案例2：
public class LockDemo{ public static void main(String[] args) throws Exception { Human human = new Human(); new Thread(() -> { try { human.drink(); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } },"A").start(); Thread.sleep(100);//确保A线程先启动 new Thread(() -> { human.eat(); },"B").start(); } } class Human{ public void eat() { System.out.println(Thread.currentThread().getName()+ ": *****eat*****"); } public synchronized void drink() throws Exception { TimeUnit.SECONDS.sleep(3); System.out.println(Thread.currentThread().getName()+": *****drink*****"); } public synchronized static void sleep() { System.out.println(Thread.currentThread().getName()+": *****sleep*****"); } }
输出结果是：先输出B：******eat*****，2.9秒后输出A：******drink*****
分析：首先不用多虑，A线程拿到资源后，锁住了贡献资源human对象，但是B线程访问的并不是加了锁的方法，而是普通方法，这就好像两个人去上厕所，一个人要蹲大号，一个人是小号，小号完成后，蹲大的才刚刚开始【如果你在吃饭，请你原谅我，实在想不出什么形象的案例】
过多的案例不再多举，只需要搞明白一点：锁是对象的一部分，而不是线程的一部分。线程只是暂时的持有锁，在线程持有锁的这段时间里，其他线程不能访问此对象的同步资源，可以访问此对象的费同步资源。
二、线程通信以及while
上面的案例中并未涉及到线程通信，然而现实的业务纷繁复杂，通常都是线程之间的协作完成业务的处理，最典型的就是———生产者消费者模式
实现复杂的业务需要更加灵活的锁——Lock，Lock接口有多个实现类，提供了更加灵活的结构，可以为同一把锁“配多把钥匙”。
案例1：
public class LockDemo{ public static void main(String[] args) throws Exception { Shop shop = new Shop(); new Thread(() -> { try { shop.produce(); } catch (Exception e) { e.printStackTrace(); } },"P_A").start(); new Thread(() -> { try { shop.produce(); } catch (Exception e) { e.printStackTrace(); } },"P_B").start(); new Thread(() -> { try { shop.consume(); } catch (Exception e) { e.printStackTrace(); } },"C_C").start(); new Thread(() -> { try { shop.consume(); } catch (Exception e) { e.printStackTrace(); } },"C_D").start(); } } class Shop{ int number = 1; public synchronized void produce() throws Exception { if(number != 0) { wait(); } number++; System.out.println(Thread.currentThread().getName()+": "+number); notifyAll(); } public synchronized void consume() throws Exception { if(number == 0) { wait(); } number--; System.out.println(Thread.currentThread().getName()+": "+number); notifyAll(); } }
输出：
C_C: 0 P_B: 1 P_A: 2 C_D: 1
灵魂质问：为什么会输出 2 ？
情况可以这样发生：当线程P_A抢到资源后，发现初始库存为1，于是进入wait状态，释放锁资源，此时线程C_C抢到资源，执行number--，输出C_C：0，然后唤醒所有线程，此时P_B抢到资源，发现number=0，于是执行number++，然后输出P_B：1，然后释放锁，唤醒其他线程，此时CPU转给了P_A，线程P_A先加载上下文，不会再去进行if判断，因为之前判断过了，于是执行number++，输出了P_A：2。问题就出在这个if，所以在同步方法的flag判断是否执行时，杜绝使用if，一律使用while。当使用了while后，当线程P_A加载完上下文继续执行时，会再执行一遍判断，只有当while循环条件不成立时，才会执行后续代码。
在这里再提一下notify和notifyAll的区别：当有多个线程时，notify会随机唤醒一个线程，被唤醒的线程百分百获得资源，但是具体唤醒哪一个是不确定的。而是用notifyAll时，会唤醒其实所有线程，所有线程再次抢占同步资源，谁抢到谁执行。
案例2：
上面的案例只是简答演示了，可以通过定义flag的方式，控制线程的执行。但是涉及到更加复杂情况时，还可以使用更加优秀的解决办法：组合使用Lock和Condition
public class LockDemo{ public static void main(String[] args) throws Exception { Shop shop = new Shop(); new Thread(() -> { try { for (int i = 0; i < 10; i++) { shop.superproduce(); } } catch (Exception e) { e.printStackTrace(); } },"P_A").start(); new Thread(() -> { try { for (int i = 0; i < 10; i++) { shop.produce(); } } catch (Exception e) { e.printStackTrace(); } },"P_B").start(); new Thread(() -> { try { for (int i = 0; i < 10; i++) { shop.consume(); } } catch (Exception e) { e.printStackTrace(); } },"C_C").start(); } } class Shop{ int number = 0; Lock lock = new ReentrantLock(); Condition c1 = lock.newCondition(); Condition c2 = lock.newCondition(); Condition c3 = lock.newCondition(); public void superproduce() throws InterruptedException{ lock.lock(); try { while(number != 0) { c1.await(); } number+=2; System.out.println(Thread.currentThread().getName()+": "+number); c2.signal(); } catch (Exception e) { e.printStackTrace(); }finally { lock.unlock(); } } public void produce() throws InterruptedException{ lock.lock(); try { while(number != 2) { c2.await(); } number++; System.out.println(Thread.currentThread().getName()+": "+number); c3.signal(); } catch (Exception e) { e.printStackTrace(); }finally { lock.unlock(); } } public void consume() throws InterruptedException{ lock.lock(); try { while(number != 3) { c3.await(); } number-=3; System.out.println(Thread.currentThread().getName()+": "+number); c1.signal(); } catch (Exception e) { e.printStackTrace(); }finally { lock.unlock(); } } }
本案例大概意思为：当库存为0时，加快生产，当库存为2时，普通生产，当库存为3时，提供给消费者消费，轮番十次。由于初始初始状态为0，就算是P_B和C_C线程先抢到了资源，由于条件不符合，也只能将执行权交给P_A，当P_A执行完成后，标记线程P_B的执行。
以此类推
