与 ReentrantLock 相比，ReentrantReadWriteLock 的性能非常差

Question

我创建了 1000 个线程来递增，1000 个线程来递减，1000 个线程来读取值。

每个增量线程，值增加25000倍。

每个递减线程，值减少25000倍。

每个读取线程读取该值 50000 次。

所以总的来说，读操作是占主导地位的。

读取值时放置 ReadLock

WriteLock 用于递增和递减值的方法。

观察结果：ReentrantReadWriteLock 大约需要 13000 ms Lock 大约需要 3000 ms。预期：ReentrantReadWriteLock 提供比 ReentrantLock 更快的性能。

顺便说一句：我个人认为使用 getCounter 方法时不需要锁定/同步（只需读取值）

import java.util.ArrayList;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Main {
    public static void main(String[] args) throws InterruptedException {

        ArrayList<Thread> reads = new ArrayList<>();
        ArrayList<Thread> increments = new ArrayList<>();
        ArrayList<Thread> decrements = new ArrayList<>();
        Resources resources = new Resources();
        long start = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {
            Thread read = new Read(resources);
            Thread increment = new Increment(resources);
            Thread decrement = new Decrement(resources);
            reads.add(read);
            increments.add(increment);
            decrements.add(decrement);
            read.start();
            increment.start();
            decrement.start();
        }
        for (int i = 0; i < 1000; i++) {
            reads.get(i).join();
            increments.get(i).join();
            decrements.get(i).join();
        }
        System.out.println(resources.getCounter());
        System.out.println(System.currentTimeMillis() - start);
    }

    private static abstract class UserThread extends Thread {
        protected Resources resources;

        public UserThread(Resources resources) {
            this.resources = resources;
        }

    }

    private static class Read extends UserThread {

        public Read(Resources resources) {
            super(resources);
        }

        public void run() {
            for (int i = 0; i < 50000; i++) {
                resources.getCounter();

            }

        }
    }

    private static class Increment extends UserThread {

        public Increment(Resources resources) {
            super(resources);
        }

        public void run() {
            for (int i = 0; i < 25000; i++) {
                resources.increment();

            }

        }
    }

    private static class Decrement extends UserThread {

        public Decrement(Resources resources) {
            super(resources);
        }

        public void run() {
            for (int i = 0; i < 25000; i++) {
                resources.decrement();

            }

        }
    }

    private static class Resources {

        private ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();

        private ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock();
        private ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();
        private ReentrantLock lock = new ReentrantLock();

        public int getCounter() {
            readLock.lock();
            try {
                return counter;
            } finally {
                readLock.unlock();
            }

        }

        private int counter = 0;

        public void increment() {
            writeLock.lock();
            try {
                counter++;
            } finally {
                writeLock.unlock();
            }
        }

        public void decrement() {
            writeLock.lock();
            try {
                counter--;
            } finally {
                writeLock.unlock();
            }
        }

    }

}

Answer 1

这些类型的锁（读写）通常经过优化，适合许多读取器和单个或几个写入器。他们经常在操作上旋转，期望读取速度快而写入量很少。此外，它们还针对公平性或请求的 FIFO 处理进行了优化，以避免线程停滞。

你做的恰恰相反。您执行许多写入操作，这会导致过度旋转和其他复杂的方法，适合多读少写的场景。

简单的锁很简单。它们只是在准备好时阻塞所有线程，并且不会发生旋转。它们的缺点是，当它们唤醒多个线程以让它们再次休眠时，会引起雪崩效应。