105 lines
2.7 KiB
C++
105 lines
2.7 KiB
C++
// Copyright 2016 The Chromium Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#ifndef BASE_SYNCHRONIZATION_READ_WRITE_LOCK_H_
|
|
#define BASE_SYNCHRONIZATION_READ_WRITE_LOCK_H_
|
|
|
|
#include "base/base_export.h"
|
|
#include "base/macros.h"
|
|
#include "build/build_config.h"
|
|
|
|
#if defined(OS_NACL)
|
|
#include "base/synchronization/lock.h"
|
|
#endif
|
|
|
|
#if defined(OS_WIN)
|
|
#include <windows.h>
|
|
#elif defined(OS_POSIX)
|
|
#include <pthread.h>
|
|
#else
|
|
# error No reader-writer lock defined for this platform.
|
|
#endif
|
|
|
|
namespace base {
|
|
namespace subtle {
|
|
|
|
// An OS-independent wrapper around reader-writer locks. There's no magic here.
|
|
//
|
|
// You are strongly encouraged to use base::Lock instead of this, unless you
|
|
// can demonstrate contention and show that this would lead to an improvement.
|
|
// This lock does not make any guarantees of fairness, which can lead to writer
|
|
// starvation under certain access patterns. You should carefully consider your
|
|
// writer access patterns before using this lock.
|
|
class BASE_EXPORT ReadWriteLock {
|
|
public:
|
|
ReadWriteLock();
|
|
~ReadWriteLock();
|
|
|
|
// Reader lock functions.
|
|
void ReadAcquire();
|
|
void ReadRelease();
|
|
|
|
// Writer lock functions.
|
|
void WriteAcquire();
|
|
void WriteRelease();
|
|
|
|
private:
|
|
#if defined(OS_WIN)
|
|
using NativeHandle = SRWLOCK;
|
|
#elif defined(OS_NACL)
|
|
using NativeHandle = Lock;
|
|
#elif defined(OS_POSIX)
|
|
using NativeHandle = pthread_rwlock_t;
|
|
#endif
|
|
|
|
NativeHandle native_handle_;
|
|
|
|
#if defined(OS_NACL)
|
|
// Even though NaCl has a pthread_rwlock implementation, the build rules don't
|
|
// make it universally available. So instead, implement a slower and trivial
|
|
// reader-writer lock using a regular mutex.
|
|
// TODO(amistry): Remove this and use the posix implementation when it's
|
|
// available in all build configurations.
|
|
uint32_t readers_ = 0;
|
|
// base::Lock does checking to ensure the lock is acquired and released on the
|
|
// same thread. This is not the case for this lock, so use pthread mutexes
|
|
// directly here.
|
|
pthread_mutex_t writer_lock_ = PTHREAD_MUTEX_INITIALIZER;
|
|
#endif
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(ReadWriteLock);
|
|
};
|
|
|
|
class AutoReadLock {
|
|
public:
|
|
explicit AutoReadLock(ReadWriteLock& lock) : lock_(lock) {
|
|
lock_.ReadAcquire();
|
|
}
|
|
~AutoReadLock() {
|
|
lock_.ReadRelease();
|
|
}
|
|
|
|
private:
|
|
ReadWriteLock& lock_;
|
|
DISALLOW_COPY_AND_ASSIGN(AutoReadLock);
|
|
};
|
|
|
|
class AutoWriteLock {
|
|
public:
|
|
explicit AutoWriteLock(ReadWriteLock& lock) : lock_(lock) {
|
|
lock_.WriteAcquire();
|
|
}
|
|
~AutoWriteLock() {
|
|
lock_.WriteRelease();
|
|
}
|
|
|
|
private:
|
|
ReadWriteLock& lock_;
|
|
DISALLOW_COPY_AND_ASSIGN(AutoWriteLock);
|
|
};
|
|
|
|
} // namespace subtle
|
|
} // namespace base
|
|
|
|
#endif // BASE_SYNCHRONIZATION_READ_WRITE_LOCK_H_
|