Question

如果此Quesiton已经发布，请执行我。我无法找到它。

在以下实现中，getValue()是读操作，onDataChange()是对整数对象的写操作。我的问题是，与写作用法相比，读者的使用率非常高。具体而言，写作每年发生一次，每天读取100次。虽然它的使用率较低，但不同的和多个线程都会被用于阅读甚至写入。在这种情况下，以下哪种实现更好？我更喜欢使用volatile实现，但是想收集你的反馈意见。如果这些实施或更好的方法存在问题，请随时更新我。

1。易失性用法：

public class SingletonClass{
    private static SingletonClass instance = new SingletonClass();
        private SingletonClass(){
    }

    private volatile Integer val = new Integer(3);

    public int getValue(){
        return val.toInteger();
    }
    public onDataChange(int value){
        this.val = new Integer(value);
    }
}

2。读 - 写锁

public class SingletonClass{

    private static SingletonClass instance = new SingletonClass();
        private SingletonClass(){
    }
    private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private final Lock readLock = readWriteLock.readLock();
    private final Lock writeLock = readWriteLock.writeLock();

    private Integer val = new Integer(3);

    public int getValue(){
        try{
         readLock.lock();
         return val.toInteger();
         } finally{
            readLock.unlock();
         }
     }

    public onDataChange(int value){
       try{
           writeLock.lock();
           this.val = new Integer(value);
       } finally{
           writeLock.unlock();
       }
    }
}

Answer 1

可能不是你要找的答案，但我会在这里使用AtomicInteger，因为它非常适合这个用例，即

可以原子方式更新的int值

private class SingletonClass {
    private static SingletonClass instance = new SingletonClass();
    private SingletonClass() {}

    private final AtomicInteger val = new AtomicInteger(3);

    public int getValue(){
        return this.val.get();
    }

    public onDataChange(int value){
        this.val.set(value);
    }
}

使用同步vs volatile哪个？

1 个答案: