多线程之锁(五)

并发编程中最常出现的情形就是多个线程共享一个资源，这些共享的资源很可能导致错误或者数据不一致的情形，需要想办法来解决这种问题。

锁

临界区(critical section)：最多只能有一个线程执行的代码块来访问某些共享资源。

一般锁能够防止多个线程同时访问某些资源，但是有些锁可以允许多个线程并发的读取共享资源，比如读写锁。

两个基本的锁机制：

• synchronized关键字，之前也提到过
• Lock接口

锁的注意事项

锁是最常用的同步方法之一。但是在高并发情况下锁的竞争会导致程序的性能下降。为了降低这种副作用，这里有一些使用锁的建议。

• 减少锁的持有时间。
• 减小锁的粒度，即缩小锁作用的对象范围。
• 锁分离，如读多写少的场合，可以使用读写锁。其余需要使用独占锁的时候，尝试根据功能，分离锁。
• 锁粗化：这个和减少锁的持有时间相反，根据具体场景来衡量，假如某个线程不断的请求，同步和释放锁，也会浪费性能，根据实际情况进行权衡。

在学习或者使用Java的过程中进程会遇到各种各样的锁的概念：公平锁、非公平锁、自旋锁、可重入锁、偏向锁、轻量级锁、重量级锁、读写锁、互斥锁等等。

这篇文章整理了各种常见的Java锁：http://www.importnew.com/19472.html

Lock与synchronized的区别

在Lock接口出现前，Java都是依靠synchronized关键字的，在JavaSE5之后，新增了Lock接口以及相关类来实现类似功能。

• Lock接口在使用时需要显示的获取和释放锁，synchronized关键字是隐式获取和释放锁
• Lock接口更加灵活，在获取锁的时候可以指定更多的操作，可中断锁，超时获取锁，指定时间释放锁，非阻塞的获取锁。
• Lock接口可以允许读写分离，多个读，但是只有一个写

Lock可以说是synchronzed的增强版。

• 超时获取锁：在指定时间未获取到锁，则返回
• 非阻塞获取锁：当前线程尝试获取锁，如果未获取到，立刻返回，如果成功则获取到锁。
• 能被中断的获取锁：获取到锁的线程可以响应中断。

Lock.png

重入锁-ReenterantLock

可重入锁，也叫做递归锁，指的是同一线程 外层函数获得锁之后 ，内层递归函数仍然有获取该锁的代码，但不受影响。

Java中重入锁使用java.util.concurrent.locks.ReentrantLock实现。syncrhonzed也是可重入锁。

// 一个简单的案例
public class ReentrantLockTest implements Runnable{
    private ReentrantLock lock = new ReentrantLock();

    public void get() {
        // get两次加锁，set又加锁。
        lock.lock();
        lock.lock();
        System.out.println("线程当前ID：" + Thread.currentThread().getId());
        set();
        lock.unlock();
        lock.unlock();
    }

    public void set() {
        lock.lock();
        System.out.println("线程当前ID：" + Thread.currentThread().getId());
        lock.unlock();
    }

    @Override
    public void run() {
        get();
    }

    public static void main(String[] args) {
        ReentrantLockTest test = new ReentrantLockTest();
        new Thread(test,"A").start();
        new Thread(test,"B").start();
        new Thread(test,"C").start();
    }
}

ReentrantLock有几个重要方法：

• lock() : 获得锁，如果锁已经被占用，则等待
• lockInterruptibly() : 获得锁，但优先响应中断
• tryLock() : 无阻塞锁，如果成功返回true，失败返回false，该方法不等的，立刻返回
• tryLock(long time,TimeUnit unit) : 在给定时间内尝试获得锁
• unlock(): 释放锁

这几个方法都比较简单，可以自行尝试。

读写锁-ReadWriteLock

读写分离锁可以有效的减少锁竞争，以提升系统性能。

	读	写
读	非阻塞	阻塞
写	阻塞	阻塞

• 读读不互斥
• 读写互斥
• 写写互斥

如果在系统中，读操作的次数远远大于写操作，则读写锁就可以发挥最大的功效。JDK并发包中提供读写锁的实现是ReentrantReadWriteLock。

// 这个demo，用来验证读写锁的性能比一般的锁要好。
// 直接运行此demo，程序几秒钟就可以运行完毕
// 如果注释掉读写所，让sreadLock = sLock, sWriteLock = sLock。那么程序要运行20多秒才结束

public class ReadWriteLockDemo {
    private static Lock sLock = new ReentrantLock();
    private static ReadWriteLock sReadWriteLock = new ReentrantReadWriteLock();
    // 分别获取读写锁
    private static Lock sReadLock = sReadWriteLock.readLock();
//    private static Lock sReadLock = sLock;
    private static Lock sWriteLock = sReadWriteLock.writeLock();
//    private static Lock sWriteLock = sLock;

    private int value;

    // 模拟读操作
    public int read() throws InterruptedException {
        try {
            sReadLock.lock();
            Thread.sleep(1000);
            return value;
        }finally {
            sReadLock.unlock();
        }
    }

    // 模拟写操作
    public void write(int index) throws InterruptedException {
        try {
            sWriteLock.lock();
            Thread.sleep(1000);
            value = index;

        }finally {
            sWriteLock.unlock();
        }
    }

    static class ReadRunnable implements Runnable{
        private ReadWriteLockDemo mDemo;
        public ReadRunnable(ReadWriteLockDemo demo) {
            mDemo = demo;
        }
        @Override
        public void run() {
            try {
                mDemo.read();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static class WriteRunnable implements Runnable{
        private ReadWriteLockDemo mDemo;
        public WriteRunnable(ReadWriteLockDemo demo) {
            mDemo = demo;
        }
        @Override
        public void run() {
            try {
                mDemo.write(new Random().nextInt(1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        ReadWriteLockDemo demo = new ReadWriteLockDemo();
        ReadRunnable readRunnable = new ReadRunnable(demo);
        WriteRunnable writeRunnable = new WriteRunnable(demo);
        for (int i = 0; i < 20; i++) {
            if (i < 18){
                new Thread(readRunnable).start();
            }else {
                new Thread(writeRunnable).start();
            }
        }
    }
}

锁的公平性

重入锁和读写锁，构造器都提供了一个参数fair，允许你控制锁的公平性，默认情况下是不公平的。
非公平锁：在多个线程抢占锁的时候，系统随机挑选一个线程持有锁。
公平锁：多个线程抢占锁的时候，系统挑选等待时间最长的线程持有锁。

我们只需要在构造锁对象的时候，传入true参数即可获得公平锁对象。

new ReentrantLock(true);
new ReentrantReadWriteLock(true);

Condition

在JDK内部，重入锁和Condition对象经常一起用到。之前我们在并发基础中提到过wait与notify要与synchronized关键字配合使用。Condition与重入锁一起使用，功能与wait和notify类似。

Lock接口的newCondition()方法可以生成一个与当前重入锁绑定的Condition实例，利用Condition我们可以让线程在特定的时间等待，在特定的时刻受到通知。

以ArrayBlockingQueue为例：

public class ArrayBlockingQueue<E> extends AbstractQueue<E>
        implements BlockingQueue<E>, java.io.Serializable {
    //存储数据元素
    final Object[] items;
    /** 主要的锁 */
    final ReentrantLock lock;

    /** 等待taoke的条件 */
    private final Condition notEmpty;

    /** 等待put的条件 */
    private final Condition notFull;
    
    public ArrayBlockingQueue(int capacity, boolean fair) {
        if (capacity <= 0)
            throw new IllegalArgumentException();
        this.items = new Object[capacity];
        //构造锁与condition
        lock = new ReentrantLock(fair);
        notEmpty = lock.newCondition();
        notFull =  lock.newCondition();
    }   
    
    
    
    public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == 0)
                //如果队列为空，等待队列非空的信号
                notEmpty.await();
            return dequeue();
        } finally {
            lock.unlock();
        }
    }
    
    // 如果入队成功，发出不空的信号
    private void enqueue(E x) {
        // assert lock.getHoldCount() == 1;
        // assert items[putIndex] == null;
        final Object[] items = this.items;
        items[putIndex] = x;
        if (++putIndex == items.length)
            putIndex = 0;
        count++;
                
        //发信号
        notEmpty.signal();
    }    

    
    public void put(E e) throws InterruptedException {
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == items.length)
               //如果队列已满，等待队列有足够的空间
                notFull.await();
            enqueue(e);
        } finally {
            lock.unlock();
        }
    }     
    
    //如果出队成功，发出 不满 的信号
    private E dequeue() {
        // assert lock.getHoldCount() == 1;
        // assert items[takeIndex] != null;
        final Object[] items = this.items;
        @SuppressWarnings("unchecked")
        E x = (E) items[takeIndex];
        items[takeIndex] = null;
        if (++takeIndex == items.length)
            takeIndex = 0;
        count--;
        if (itrs != null)
            itrs.elementDequeued();
        //发信号    
        notFull.signal();
        return x;
    }
    
}

最后

这篇文章主要说了下使用锁的时候需要注意的几点，然后提了重入锁与读写锁。公平锁，最后说了重入锁的搭档Condition。
篇幅有限，没办法面面俱到，感兴趣的还望自己再摸索。希望能帮助大家。

参考

• Java中synchronized的实现原理与应用
• Java锁的种类以及辨析（四）：可重入锁
• 《Java高并发程序设计》
• 《并发编程的艺术》