java并发-锁-ReentrantLock(重入锁)和ReentrantReadWriteLock(读写锁)

转载地址：https://www.cnblogs.com/whatadiors/p/8013086.html

• 同步控制是并发程序必不可少的重要手段，synchronized关键字就是一种简单的控制方式，除此之外，JDK内部并发包中也也提供了Lock接口，该接口中提供了lock()方法和unLock()方法对显式加锁和显式释放锁操作进行支持。

ReentrantLock(重入锁)

重入锁可以完全替代synchronized关键字，在jdk5早期版本中重入锁的性能远远好于synchronized，但从JDK6开始JDK在synchronized中做了大量的优化，是的两者的性能差距不大，

public class Test {
    public static ReentrantLock lock = new ReentrantLock();
    public static int i = 0;
    public static void increase() {
        try {
            lock.lock();
            i++;
        }finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) throws Exception {
        Thread t1 = new TestThread();
        Thread t2 = new TestThread();
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(i);
    }
}
class TestThread extends Thread {
    @Override
    public void run() {
        for (int j = 0; j < 1000; j++) {
            Test.increase();
        }
    }
}

从这段代码可以看到与synchronized相比，重入锁有着显示的操作过程，我们需要手动定义核实加锁，核实释放锁，但也就是因为这样，重入锁对逻辑的控制灵活性要好于synchronized。

公平锁

大多数情况下锁的申请都是非公平的。如一个线程1先请求了锁A,然后线程2页也请求了锁A,那么当锁A可用时，是线程1可以获得锁还是线程2是不一定的，系统只是会从这个锁的等待队列中随机挑选一个。

重入锁允许我们对其公平性进行设置。公平锁的一大特点是：它不会产生饥饿现象。只要排队，最终你就可以获得资源。可以使用如下构造函数创建公平锁：

public ReentrantLock(boolean fair)

当参数fair为true,表示锁的公平的，当然由于公平所需要维护有序队列，因此公平锁的实现成本比较高，性能相对也底下，所以默认都是非公平锁

public class Test {
    public static ReentrantLock lock = new ReentrantLock(true);
    public static void main(String[] args) throws Exception {
        Thread t1 = new TestThread();
        Thread t2 = new TestThread();
        t1.start();
        t2.start();
    }
}
class TestThread extends Thread {
    @Override
    public void run() {
        while(true)
        try {
            Test.lock.lock();
            System.out.println(Thread.currentThread().getName()+"获得锁");
        } finally{
            Test.lock.unlock();
        }
    }
}

可以看到如上代码制定公平锁之后，两个线程交替获得锁

Thread-1获得锁
Thread-0获得锁
Thread-1获得锁
Thread-0获得锁
Thread-1获得锁
Thread-0获得锁
Thread-1获得锁
Thread-0获得锁
Thread-1获得锁
Thread-0获得锁
Thread-1获得锁
Thread-0获得锁
Thread-1获得锁
...

ReentrantLock的一些其他方法：

public boolean tryLock();
//使用此方法，当前线程会尝试获得锁，如果锁未被其他线程占用，则申请锁成功，返回true,否则会立即返回false.这种模式不会引起线程等待，因此也不会产生死锁。

 

public boolean tryLock(long timeout, TimeUnit unit)
//在这里tryLock接收两个参数，一个表示等待时长，一个表示计时单位，表示在一段时间范围内如果得到锁就返回true,否则直接返回false，不在继续等待锁。

public class Test implements Runnable {
    public static ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        try {
            if (lock.tryLock(5, TimeUnit.SECONDS)) {
                System.out.println(Thread.currentThread().getName());
                System.out.println("get lock success");
                Thread.sleep(6000);
            } else {
                System.out.println(Thread.currentThread().getName());
                System.out.println("get lock failed");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
    public static void main(String args[]) {
        Test timeLock = new Test();
        Thread thread1 = new Thread(timeLock);
        Thread thread2 = new Thread(timeLock);
        thread1.start();
        thread2.start();
    }
}

输出结果：

Thread-0
get lock success
Thread-1
get lock failed

 其他：

关于重入锁的具体原理及这部分源码的分析可以看下这篇文章http://www.cnblogs.com/xrq730/p/4979021.html

ReentrantReadWriteLock(读写锁)

ReadWriteLock是JDK5开始提供的读写分离锁。读写分离开有效的帮助减少锁的竞争，以提升系统性能。用锁分离的机制避免多个读操作线程之间的等待。

读写锁的访问约束：

• 读-读不互斥：读读之间不阻塞
• 读-写互斥：读堵塞写，写也阻塞读
• 写-写互斥：写写阻塞

如果在一个系统中读的操作次数远远大于写操作，那么读写锁就可以发挥明显的作用，提升系统性能

public class Test {
    private static Lock lock = new ReentrantLock();
    private static ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
    private static Lock readLock = reentrantReadWriteLock.readLock();
    private static Lock writeLock = reentrantReadWriteLock.writeLock();
    private static int value;

    public static Object handleRead(Lock lock) throws InterruptedException {
        try {
            lock.lock();
            Thread.sleep(1000);// 模拟读操作
            System.out.println("读操作:" + value);
            return value;
        } finally {
            lock.unlock();
        }
    }

    public static void handleWrite(Lock lock, int index)
            throws InterruptedException {
        try {
            lock.lock();
            Thread.sleep(1000);// 模拟写操作
            System.out.println("写操作:" + value);
            value = index;
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) throws Exception {
        TestReadThread testReadThread = new TestReadThread();
        TestWriteThread testWriteThread = new TestWriteThread();
        for (int i = 0; i < 18; i++) {
            new Thread(testReadThread).start();
        }
        for (int i = 18; i < 20; i++) {
            new Thread(testWriteThread).start();
        }

    }
    
    private static class TestReadThread extends Thread {
        @Override
        public void run() {
            try {
                //Test.handleRead(lock);
                Test.handleRead(readLock);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private static class TestWriteThread extends Thread {
        @Override
        public void run() {
            try {
                //Test.handleWrite(lock,new Random().nextInt(100));
                Test.handleWrite(writeLock,new Random().nextInt(100));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

 

这一段代码可以清楚的表达读写锁的作用，如果不使用读写锁，那么整个程序执行时间大概是20s。换用读写锁后只需要2s多，这里读线程完全并行，节省了大部分时间。