JavaSE-多线程（8）- ReadWriteLock

JavaSE-多线程（8）- ReadWriteLock

以下例子中多个线程同时对count进行读写，读方法和写方法都等待1秒，并且读写方法都使用了ReentrantLock重入锁，通过CountDownLatch工具类让主线程等待读写线程结束，最后程序输出执行时间为12秒左右

例1

package com.hs.example.base.multithread.day01;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ReadWriteTest {
    private volatile int count;
    private Lock lock;

    public ReadWriteTest(Lock lock) {
        this.lock = lock;
    }

    public void accumulate() {
        try {
            lock.lock();
            Thread.sleep(1000);
            count++;
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        try {
            lock.lock();
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + " : " + this.count);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
        return this.count;
    }

    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        CountDownLatch countDownLatch = new CountDownLatch(12);
        Lock lock = new ReentrantLock();
        ReadWriteTest readWriteTest = new ReadWriteTest(lock);

        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                readWriteTest.accumulate();
                countDownLatch.countDown();
            }).start();
        }

        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                readWriteTest.getCount();
                countDownLatch.countDown();
            }).start();
        }
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("耗时：" + (System.currentTimeMillis() - start));
    }
}

Thread-2 : 2
Thread-3 : 2
Thread-4 : 2
Thread-5 : 2
Thread-6 : 2
Thread-7 : 2
Thread-8 : 2
Thread-9 : 2
Thread-10 : 2
Thread-11 : 2
耗时：12060

例2 是对例1 的改造，从输出结果可见，多线程执行读写时间为 3 秒左右，在此例中，使用 ReentrantReadWriteLock 读写锁，当读取count值时使用 readLock 读锁，写入count数据时使用 writeLock 写锁，由输出结果可知，读取数据的线程几乎在同一时间执行，可见，当读操作较多时，读写锁可提高效率

例2

package com.hs.example.base.multithread.day01;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteTest2 {
    private volatile int count;

    public void accumulate(Lock lock) {
        try {
            lock.lock();
            Thread.sleep(1000);
            count++;
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public  int getCount(Lock lock) {
        try {
            lock.lock();
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + " : " + this.count);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
        return this.count;
    }

    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        CountDownLatch countDownLatch = new CountDownLatch(12);
        ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
        ReadWriteTest2 readWriteTest = new ReadWriteTest2();

        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                readWriteTest.accumulate(readWriteLock.writeLock());
                countDownLatch.countDown();
            }).start();
        }

        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                readWriteTest.getCount(readWriteLock.readLock());
                countDownLatch.countDown();
            }).start();
        }

        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("耗时：" + (System.currentTimeMillis() - start));
    }
}

Thread-7 : 2
Thread-5 : 2
Thread-3 : 2
Thread-11 : 2
Thread-9 : 2
Thread-4 : 2
Thread-8 : 2
Thread-10 : 2
Thread-6 : 2
Thread-2 : 2
耗时：3060