多线程之锁(五)

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

临界区(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的增强版。

  • 超时获取锁:在指定时间未获取到锁,则返回
  • 非阻塞获取锁:当前线程尝试获取锁,如果未获取到,立刻返回,如果成功则获取到锁。
  • 能被中断的获取锁:获取到锁的线程可以响应中断。
多线程之锁(五)_第1张图片
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 extends AbstractQueue
        implements BlockingQueue, 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高并发程序设计》
  • 《并发编程的艺术》

你可能感兴趣的:(多线程之锁(五))