重入锁和读写锁-蒲公英云

在java多线程中，我们知道可以用synchronize关键字来实现线程间的同步互斥工作，还有更加优秀的机制去实现同步互斥工作，Lock对象。重入锁和读写锁，他们具有比synchronize更加强大的功能，并且具有嗅探锁定，多路分支等功能。
一、ReentrantLock（重入锁）（详见JDK-API）

public class UseReentrantLock { 
    private Lock lock = new ReentrantLock();
    public void method1(){ 
        try { 
            lock.lock();
            System.out.println("当前线程:" + Thread.currentThread().getName() + "进入method1..");
            Thread.sleep(1000);
            System.out.println("当前线程:" + Thread.currentThread().getName() + "退出method1..");
            Thread.sleep(1000);
        } catch (InterruptedException e) { 
            e.printStackTrace();
        } finally { 
            lock.unlock();
        }
    }
    public void method2(){ 
        try { 
            lock.lock();
            System.out.println("当前线程:" + Thread.currentThread().getName() + "进入method2..");
            Thread.sleep(2000);
            System.out.println("当前线程:" + Thread.currentThread().getName() + "退出method2..");
            Thread.sleep(1000);
        } catch (InterruptedException e) { 
            e.printStackTrace();
        } finally { 
            lock.unlock();
        }
    }
    public static void main(String[] args) { 
        final UseReentrantLock ur = new UseReentrantLock();
        Thread t1 = new Thread(new Runnable() { 
            @Override
            public void run() { 
                ur.method1();
                ur.method2();
            }
        }, "t1");
        t1.start();
        try { 
            Thread.sleep(10);
        } catch (InterruptedException e) { 
            e.printStackTrace();
        }
        //System.out.println(ur.lock.getQueueLength());
    }
}

二、锁的等待与通知
在使用synchronize的时候，如果需要多线程之间进行协作工作，则需要Object的wait（）和notify（）,notifyAll( )方法进行配合工作。那么同样，我们在使用Lock的时候，可以使用一个新的等待通知类，它就是Condition，这个Condition一定是针对具体某一把锁的。也就是在只有锁的基础上才会产生Condition。

public class UseCondition { 
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    public void method1(){ 
        try { 
            lock.lock();
            System.out.println("当前线程：" + Thread.currentThread().getName() + "进入等待状态..");
            Thread.sleep(3000);
            System.out.println("当前线程：" + Thread.currentThread().getName() + "释放锁..");
            condition.await();    // Object wait
            System.out.println("当前线程：" + Thread.currentThread().getName() +"继续执行...");
        } catch (Exception e) { 
            e.printStackTrace();
        } finally { 
            lock.unlock();
        }
    }
    public void method2(){ 
        try { 
            lock.lock();
            System.out.println("当前线程：" + Thread.currentThread().getName() + "进入..");
            Thread.sleep(3000);
            System.out.println("当前线程：" + Thread.currentThread().getName() + "发出唤醒..");
            condition.signal();        //Object notify
        } catch (Exception e) { 
            e.printStackTrace();
        } finally { 
            lock.unlock();
        }
    }
    public static void main(String[] args) { 
        final UseCondition uc = new UseCondition();
        Thread t1 = new Thread(new Runnable() { 
            @Override
            public void run() { 
                uc.method1();
            }
        }, "t1");
        Thread t2 = new Thread(new Runnable() { 
            @Override
            public void run() { 
                uc.method2();
            }
        }, "t2");
        t1.start();
        t2.start();
    }
}

三、多Condition
我们可以通过一个Lock对象产生多个Condition进行多线程间的交互，非常的灵活。可以使得部分需要唤醒的线程唤醒，其他线程则继续等待通知。

public class UseManyCondition { 
    private ReentrantLock lock = new ReentrantLock();
    private Condition c1 = lock.newCondition();
    private Condition c2 = lock.newCondition();
    public void m1(){ 
        try { 
            lock.lock();
            System.out.println("当前线程：" +Thread.currentThread().getName() + "进入方法m1等待..");
            c1.await();
            System.out.println("当前线程：" +Thread.currentThread().getName() + "方法m1继续..");
        } catch (Exception e) { 
            e.printStackTrace();
        } finally { 
            lock.unlock();
        }
    }
    public void m2(){ 
        try { 
            lock.lock();
            System.out.println("当前线程：" +Thread.currentThread().getName() + "进入方法m2等待..");
            c1.await();
            System.out.println("当前线程：" +Thread.currentThread().getName() + "方法m2继续..");
        } catch (Exception e) { 
            e.printStackTrace();
        } finally { 
            lock.unlock();
        }
    }
    public void m3(){ 
        try { 
            lock.lock();
            System.out.println("当前线程：" +Thread.currentThread().getName() + "进入方法m3等待..");
            c2.await();
            System.out.println("当前线程：" +Thread.currentThread().getName() + "方法m3继续..");
        } catch (Exception e) { 
            e.printStackTrace();
        } finally { 
            lock.unlock();
        }
    }
    public void m4(){ 
        try { 
            lock.lock();
            System.out.println("当前线程：" +Thread.currentThread().getName() + "唤醒..");
            c1.signalAll();
        } catch (Exception e) { 
            e.printStackTrace();
        } finally { 
            lock.unlock();
        }
    }
    public void m5(){ 
        try { 
            lock.lock();
            System.out.println("当前线程：" +Thread.currentThread().getName() + "唤醒..");
            c2.signal();
        } catch (Exception e) { 
            e.printStackTrace();
        } finally { 
            lock.unlock();
        }
    }
    public static void main(String[] args) { 
        final UseManyCondition umc = new UseManyCondition();
        Thread t1 = new Thread(new Runnable() { 
            @Override
            public void run() { 
                umc.m1();
            }
        },"t1");
        Thread t2 = new Thread(new Runnable() { 
            @Override
            public void run() { 
                umc.m2();
            }
        },"t2");
        Thread t3 = new Thread(new Runnable() { 
            @Override
            public void run() { 
                umc.m3();
            }
        },"t3");
        Thread t4 = new Thread(new Runnable() { 
            @Override
            public void run() { 
                umc.m4();
            }
        },"t4");
        Thread t5 = new Thread(new Runnable() { 
            @Override
            public void run() { 
                umc.m5();
            }
        },"t5");
        t1.start();    // c1
        t2.start();    // c1
        t3.start();    // c2
        try { 
            Thread.sleep(2000);
        } catch (InterruptedException e) { 
            e.printStackTrace();
        }
        t4.start();    // c1
        try { 
            Thread.sleep(2000);
        } catch (InterruptedException e) { 
            e.printStackTrace();
        }
        t5.start();    // c2
    }

四 . Lock / Condition其他方法和用法
1.公平锁和非公平锁: Lock lock = new ReentrantLock ( boolean isFair);
lock的用法:
tryLock():尝试获得锁,获得结果用true/false返回.
tryLock():在给定的时间内尝试获得锁,获得结果用true/false返回.
isFair():是否是公平锁
isLocked():是否锁定
getHoldCount():查询当前线程保持此锁的个数,也就是调用lock()的次数
lockInterruptibly:优先响应中断的锁