【java总结】多线程进阶篇之locks包

Java.util.concurrent.locks包提供了一系列关于锁的抽象的类，主要的锁为ReentrantLock，ReentrantReadWriteLock。

ReentrantLock（可重入锁）

它与synchronized有着相同作用，且功能更加强大。它的构造函数可以传入一个boolean类型的公平因子，当传入true时，在多个线程竞争下将倾向于等待时间最长的线程。默认情况下传入false，此时无法保证任何顺序。

A、trylock()方法：如果获取了锁立即返回true，如果别的线程正持有锁，立即返回false；

B、tryLock(long timeout, TimeUnit timeUnit)方法：如果获取了锁定立即返回true，如果别的线程正持有锁，会等待参数给定的时间，在等待的过程中，如果获取了锁定，就返回true，如果等待超时，返回false；

C、lockInterruptibly()方法：它允许在获取锁的等待过程中由其它线程调用等待线程的Thread.interrupt方法来中断等待线程的等待而直接返回，这时不用获取锁，而会抛出一个InterruptedException。

D、lock()方法：尝试获取锁，获取不到会一直等待。

E、unlock()方法：释放锁，与lock()方法配对。

在进入代码块之前调用lock()方法，在退出代码块之前调用unlock()方法，即可完成对代码块的锁，这是ReentrantLock的常见用法。

public class User implements Runnable { 
    private String name;//用户名 
    private MyCount myCount;//所要操作的账户 
    private int iocash; 
    private Lock myLock=new ReentrantLock();  //执行操作所需的锁对象 
    public User(String name, MyCount myCount, int iocash, Lock myLock) { 
            this.name = name; 
            this.myCount = myCount; 
            this.iocash = iocash; 
            this.myLock = myLock; 
    } 

    public void run() { 
            try{
            	//获取锁 
            	myLock.lock(); 
            	//执行现金业务 
                System.out.println(name + "正在操作" + myCount + "账户，金额为" + iocash + "，当前金额为" + myCount.getCash()); 
                myCount.setCash(myCount.getCash() + iocash); 
                System.out.println(name + "操作成功，金额为" + iocash + "，当前金额为" + myCount.getCash()); 
            }finally{
            	//释放锁，否则别的线程没有机会执行了 
            	myLock.unlock(); 
            }
    } 
} 

 

ReentrantReadWriteLock（可重入的读写锁）

ReentrantReadWriteLock与ReentrantLock的用法基本差不多，都是通过lock方法和unlock方法来锁定，不同的地方是ReentrantReadWriteLock实现了读写锁机制，它含有读锁和写锁，通过调用readLock()方法可以获得读锁，调用writeLock()方法可以获得写锁，需要注意的是：只要没有writer，读取锁定可以由多个reader 线程同时保持，而写入锁定是独占的。当有人使用读锁时，其他人可以读取，但不可以写入锁会被阻塞。当有人使用写锁时，其他人既不能读取也不能写入。

public class User2 implements Runnable { 
    private String name;                //用户名 
    private MyCount myCount;        //所要操作的账户 
    private int iocash;                 //操作的金额，当然有正负之分了 
    private ReadWriteLock myLock=new ReentrantReadWriteLock(); //执行操作所需的锁对象 
    private boolean ischeck;        //是否查询 

    public User2(String name, MyCount myCount, int iocash, ReadWriteLock myLock, boolean ischeck) { 
            this.name = name; 
            this.myCount = myCount; 
            this.iocash = iocash; 
            this.myLock = myLock; 
            this.ischeck = ischeck; 
    } 

    public void run() { 
            if (ischeck) { 
                    //获取读锁 
                    myLock.readLock().lock(); 
                    try{
                    	System.out.println("读：" + name + "正在查询账户，当前金额为" + myCount.getCash());  
                    }//释放读锁 
                    finally{
                    	myLock.readLock().unlock(); 
                    }
            } else { 
                    //获取写锁 
                    myLock.writeLock().lock(); 
                    //执行现金业务 
                    try{
                    	System.out.println("写：" + name + "正在操作" + myCount + "账户，金额为" + iocash + "，当前金额为" + myCount.getCash()); 
                        myCount.setCash(myCount.getCash() + iocash); 
                        System.out.println("写：" + name + "操作账户成功，金额为" + iocash + "，当前金额为" + myCount.getCash()); 
                        
                    }
                    finally{
                    	//释放写锁 
                    	myLock.writeLock().unlock(); 
                    }
            } 
    } 
} 

Condition接口:

对于有条件的线程并发，java提供了Condition来控制线程之间的关系。简单的说，Condition实现的功能就是多线程基础版本的wait(),notify(),notifyall()的功能。

Condition依赖于Lock接口，生成一个Condition的代码是lock.newCondition() 
调用Condition的await()和signal()方法，都必须在lock.lock()和lock.unlock之间才可以使用
Conditon中的await()对应Object的wait()；
Condition中的signal()对应Object的notify()；
Condition中的signalAll()对应Object的notifyAll()。

public class ConditonTest {
	/*
	 * 1. 线程1调用reentrantLock.lock时，尝试获取锁。如果成功，则返回，从AQS的队列中移除线程；
	 * 否则阻塞，保持在AQS的等待队列中。
	 * 2. 线程1调用await方法被调用时，对应操作是被加入到Condition的等待队列中，等待signal信号；
	 * 同时释放锁。
	 * 3. 锁被释放后，会唤醒AQS队列中的头结点，所以线程2会获取到锁。
	 * 4. 线程2调用signal方法，这个时候Condition的等待队列中只有线程1一个节点，于是它被取出来，并
	 * 被加入到AQS的等待队列中。注意，这个时候，线程1 并没有被唤醒，只是被加入AQS等待队列。
	 * 5. signal方法执行完毕，线程2调用unLock()方法，释放锁。这个时候因为AQS中只有线程1，于是，
	 * 线程1被唤醒，线程1恢复执行。
	 * 所以：
	 * 发送signal信号只是将Condition队列中的线程加到AQS的等待队列中。只有到发送signal信号的线
	 * 程调用reentrantLock.unlock()释放锁后，这些线程才会被唤醒。
	 * 可以看到，整个协作过程是靠结点在AQS的等待队列和Condition的等待队列中来回移动实现的，Condit
	 * ion作为一个条件类，很好的自己维护了一个等待信号的队列，并在适时的时候将结点加入到AQS的等待队列中
	 * 来实现的唤醒操作。
	 */
	public static void main(String[] args) {
        final ReentrantLock reentrantLock = new ReentrantLock();
        final Condition condition = reentrantLock.newCondition();
        new Thread(new Runnable() {
            @Override
            public void run() {
                reentrantLock.lock();
                System.out.println(Thread.currentThread().getName() + "拿到锁了");
                System.out.println(Thread.currentThread().getName() + "等待信号");
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread().getName() + "拿到信号");

                reentrantLock.unlock();
            }
        }, "线程1").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                reentrantLock.lock();
                System.out.println(Thread.currentThread().getName() + "拿到锁了");

                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread().getName() + "发出信号");
                condition.signalAll();

                reentrantLock.unlock();
            }
        }, "线程2").start();
    }
}