class RequestHandler {
  ...
  std::mutex requestMutex_;
  RequestQueue requestQueue_;

  processRequest(const Request& request);
};

void RequestHandler::processRequest(const Request& request) {
  std::lock_guard<std::mutex> lg(requestMutex_);
  requestQueue_.push_back(request);
}

class RequestHandler {
  folly::Synchronized<RequestQueue> requestQueue_;

  processRequest(const Request& request);
};

void RequestHandler::processRequest(const Request& request) {
  requestQueue_.wlock()->push_back(request);
}

{
      auto lockedQueue = requestQueue_.wlock();
      lockedQueue->push_back(request1);
      lockedQueue->push_back(request2);
}

void RequestHandler::processRequest(const Request& request) {
      requestQueue_.withWLock([&](auto& queue "&") {
        // withWLock() automatically holds the lock for the
        // duration of this lambda function
        queue.push_back(request);
      });
}

template <class T, class Mutex = SharedMutex>

auto locked = vec.lock();
for (int& n : *locked) {
    n *= 2;
}

// No. NO. NO!
for (int& n : *vec.wlock()) {
      n *= 2;
}

vec.withLock([](auto& data "") {
    for (int& n : data) {
        n *= 2;
    }
});

  /**
   * Invoke a function while holding the lock.
   *
   * A reference to the datum will be passed into the function as its only
   * argument.
   *
   * This can be used with a lambda argument for easily defining small critical
   * sections in the code.  For example:
   *
   *   auto value = obj.withLock([](auto& data "") {
   *     data.doStuff();
   *     return data.getValue();
   *   });
   */
  template <class Function>
  auto withLock(Function&& function) {
    return function(*lock());
  }

  template <class Function>
  auto withLock(Function&& function) const {
    return function(*lock());
  }

/**
 * An enum to describe the "level" of a mutex.  The supported levels are
 *  Unique - a normal mutex that supports only exclusive locking
 *  Shared - a shared mutex which has shared locking and unlocking functions;
 *  Upgrade - a mutex that has all the methods of the two above along with
 *            support for upgradable locking
 */
enum class MutexLevel { UNIQUE, SHARED, UPGRADE };

{
    // only const access allowed to the underlying object when an upgrade lock
    // is acquired
    auto ulock = vec.ulock();
    auto newSize = ulock->size();
}

auto newSize = vec.withULockPtr([](auto ulock "") {
    // only const access allowed to the underlying object when an upgrade lock
    // is acquired
    return ulock->size();
});

folly::Synchronized<std::unordered_map<int64_t, int64_t>> cache;

int64_t res = cache.withULockPtr([key,value](auto ulock "key,value") {
    int64_t cache_value;
    auto iter = ulock->find(key);
    if (iter != ulock->end()) {
        cache_value = iter->second;
    } else {
        cache_value = 0;

        // ulock is now null
        auto wlock = ulock.moveFromUpgradeToWrite();
        (*wlock)[key] = cache_value;
    }

    return cache_value;
});

void fun(Synchronized<vector<string>>& vec) {
      {
        auto locked = vec.lock(10ms);
        if (!locked) {
          throw std::runtime_error("failed to acquire lock");
        }
        locked->push_back("hello");
        locked->push_back("world");
      }
      LOG(INFO) << "successfully added greeting";
}

Synchronized<vector<string>, std::mutex> vec;
std::condition_variable emptySignal;

// Assuming some other thread will put data on vec and signal
// emptySignal, we can then wait on it as follows:
auto locked = vec.lock();
emptySignal.wait(locked.getUniqueLock(),
                    [&] { return !locked->empty(); });

 /**
   * Get a reference to the std::unique_lock.
   *
   * This is provided so that callers can use Synchronized<T, std::mutex>
   * with a std::condition_variable.
   *
   * While this API could be used to bypass the normal Synchronized APIs and
   * manually interact with the underlying unique_lock, this is strongly
   * discouraged.
   */
  std::unique_lock<std::mutex>& getUniqueLock() { return lock_; }

void fun(Synchronized<vector<int>>& a, Synchronized<vector<int>>& b) {
    auto lockedA = a.wlock();
    auto lockedB = b.wlock();
    ... use lockedA and lockedB ...
}

void fun(Synchronized<vector<int>>& a, Synchronized<vector<int>>& b) {
    auto ret = folly::acquireLocked(a, b);
    auto& lockedA = std::get<0>(ret);
    auto& lockedB = std::get<1>(ret);
    ... use lockedA and lockedB ...
}

// 实现：通过比较锁地址的大小
/**
 * Acquire locks for multiple Synchronized<T> objects, in a deadlock-safe
 * manner.
 *
 * The locks are acquired in order from lowest address to highest address.
 * (Note that this is not necessarily the same algorithm used by std::lock().)
 * For parameters that are const and support shared locks, a read lock is
 * acquired.  Otherwise an exclusive lock is acquired.
 *
 * use lock() with folly::wlock(), folly::rlock() and folly::ulock() for
 * arbitrary locking without causing a deadlock (as much as possible), with the
 * same effects as std::lock()
 */
template <class Sync1, class Sync2>
std::tuple<detail::LockedPtrType<Sync1>, detail::LockedPtrType<Sync2>>
acquireLocked(Sync1& l1, Sync2& l2) {
  if (static_cast<const void*>(&l1) < static_cast<const void*>(&l2)) {
    auto p1 = l1.contextualLock();
    auto p2 = l2.contextualLock();
    return std::make_tuple(std::move(p1), std::move(p2));
  } else {
    auto p2 = l2.contextualLock();
    auto p1 = l1.contextualLock();
    return std::make_tuple(std::move(p1), std::move(p2));
  }
}

void fun(Synchronized<vector<int>>& a, Synchronized<vector<int>>& b) {
     auto [lockedA, lockedB] = folly::acquireLocked(a, b);
     ... use lockedA and lockedB ...
}

class Server {
    struct BiMap {
    map<int, string> direct;
    map<string, int> inverse;
    };
    Synchronized<BiMap> bimap_;
    ...
};

...
bimap_.withLock([](auto& locked "") {
    locked.direct[0] = "zero";
    locked.inverse["zero"] = 0;
});

class Server {
    Synchronized<tuple<map<int, string>, map<string, int>>> bimap_;
    ...
};

...
bimap_.withLock([](auto& locked "") {
    get<0>(locked)[0] = "zero";
    get<1>(locked)["zero"] = 0;
});