Question

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

每个增加线程，将值增加25000次。

每个递减线程，将值减少25000次。

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

因此，所有操作均以读取为主。

在读取值时放置了ReadLock

和WriteLock用于方法增加和减少值。

已观察到：ReentrantReadWriteLock大约需要13000毫秒锁定大约需要3000毫秒。预期：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处理进行了优化，以避免线程停顿。

您做的恰恰相反。您会做很多作家，这些作家会导致过多的自旋和其他复杂的方法，适合于“多读少写”的情况。

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

Answer 2

感谢Nick和Slaw指出，它不是主要读物。我确保我有100个增量，100个减量和1000个读取线程。

结果符合预期。 ReentrantReadWriteLock的输出为300毫秒并且withLock为5000毫秒。

这是修改后的代码

#include <iostream>

与ReentrantLock相比，ReentrantReadWriteLock的执行效果非常差

2 个答案: