Lucene 源码分析集------- SyncLock

通用的同步锁

/// Utility class to support locking via a mutex.
class LPPAPI Synchronize {
public:
    Synchronize();
    virtual ~Synchronize();

protected:
    boost::recursive_timed_mutex mutexSynchronize;
    int64_t lockThread;
    int32_t recursionCount;

public:
    /// create a new Synchronize instance atomically.
    static void createSync(SynchronizePtr& sync);

    /// Lock mutex using an optional timeout.
    void lock(int32_t timeout = 0);

    /// Unlock mutex.
    void unlock();

    /// Unlock all recursive mutex.
    int32_t unlockAll();

    /// Returns true if mutex is currently locked by current thread.
    bool holdsLock();
};

/// Utility class to support scope locking.
class LPPAPI SyncLock {
public:
    SyncLock(const SynchronizePtr& sync, int32_t timeout = 0);

    template <class OBJECT>
    SyncLock(OBJECT object, int32_t timeout = 0) {
        this->sync = object->getSync();
        lock(timeout);
    }

    virtual ~SyncLock();

protected:
    SynchronizePtr sync;

protected:
    void lock(int32_t timeout);
};