本文描述了一種簡單的跨平臺鎖框架的設計與實現，該框架小巧實用、易于擴展，它的特點如下：
● 實現了線程間互斥鎖
● 實現優化了單線程環境中的空鎖和空級別鎖
● 支持編譯時或運行時選擇鎖
● 支持對象和類級別的鎖粒度
● 支持錯誤或異常處理
框架結構
由鎖抽象、鎖適配器、鎖守衛、線程互斥鎖和鎖級別5個基本組件構成，對應類的關系如下圖。
基本組件
鎖抽象
提供鎖語義的抽象，一般有5種操作：創建或初始化、阻塞加鎖、非阻塞加鎖、解鎖和銷毀，實現為lock_base類。
1
class lock_base
2
{
3
public:
4
lock_base()
{}
5 virtual ~lock_base(){}
6
7 virtual int lock() = 0;
8 virtual int trylock() = 0;
9 virtual int unlock() = 0;
10
};
構造對應創建或初始化操作，析構對應銷毀操作，lock對應阻塞加鎖，trylock對應非阻塞加鎖，unlock對應解鎖。
鎖適配器
支持運行時動態綁定某個具體鎖，實現為lock_adapter類模板，繼承lock_base。
1 template<class T>
2 class lock_adapter : public lock_base
3{
4public:
5 lock_adapter(T &lock)
6 :lock_(&lock)
7 ,del_(false)
8 {}
9
10 lock_adapter()
11 :del_(true)
12 { lock_ = new T(); }
13
14 ~lock_adapter()
15 { if(del_) delete lock_; }
16
17 virtual int lock()
18 { return lock_->lock(); }
19
20 virtual int trylock()
21 { return lock_->trylock(); }
22
23 virtual int unlock()
24 { return lock->unlock(); }
25
26private:
27 T *lock_;
28 bool del_;
29};
提供2個構造函數，支持引用外部鎖和構造內部鎖，并將方法實現委托給對應的鎖實例。
線程互斥鎖
一種支持線程間同步的具體鎖，支持windows和linux平臺，實現為thread_mutex類。
lock、trylock和unlock返回0表示成；-1表示失敗，errno指示錯誤碼; 當僅用于單線程環境時，加解鎖沒有意義，提供一個空鎖，實現為null_mutex類。
1class null_mutex
2{
3public:
4 int lock() { return 0;}
5 int trylock() { return 0;}
6 int unlock() { return 0; }
7};
鎖守衛
用于自動獲取和釋放鎖，保證當異常發生時能自動解鎖，實現為lock_guard類模板，T表示鎖類型，只要這個類型提供lock、trylock和unlock三種語義。
1template<class T>
2 class lock_guard : noncopyable
3{
4public:
5 explicit lock_guard(T &lock, bool block=true)
6 : lock_(&lock)
7 {
8 owner_ = (block ? lock_->lock() : lock_->trylock());
9
}
10
11 ~lock_guard()
12 {
13 if(0==owner_) lock_->unlock();
14 }
15
16 int locked() const
17 { return owner_; }
18
19private:
20 T *lock_;
21 int owner_;
22};
構造函數形參block為true表示阻塞加鎖，否則非阻塞加鎖。當T為null_mutex時，為了避免調用lock和unlock的開銷，特化如下。
1template<>
2class lock_guard<null_mutex>
3{
4 public:
5
explicit lock_guard(null_mutex&){}
6 ~lock_guard() {}
7 };
鎖級別
提供類級別和對象級別2種鎖粒度：類級別是指所有對象共享同一個鎖，實現為class_level_lock類模板；對象級別是指每個對象持有自己的鎖， 實現為object_level_lock類模板。
1template<class T>
2class level_lock_base : noncopyable
3{
4public:
5 typedef lock_guard<const T> lock_guard_type;
6
7 int lock() const
8 { return static_cast<const T*>(this)->lock_.lock(); }
9
10 int trylock() const
11 { return static_cast<const T*>(this)->lock_.trylock();}
12
13 int unlock() const
14 { return static_cast<const T*>(this)->lock_.unlock(); }
15
16protected:
17 ~level_lock_base(){}
18};
19
20 template<class T,class L>
21 class class_level_lock : public level_lock_base<class_level_lock<T,L> >
22{
23 template<class U>
24 friend class level_lock_base;
25
26protected:
27 ~class_level_lock(){}
28
29private:
30 static L lock_;
31};
32
33 template<class T,class L>
34 L class_level_lock<T,L>::lock_;
35
36 template<class T,class L>
37 class object_level_lock : public level_lock_base<object_level_lock<T,L> >
38{
39 template<class U>
40 friend class level_lock_base;
41
42protected:
43 ~object_level_lock(){}
44
45private:
46 mutable L lock_;
47};
level_lock_base是為遵循DRY SPOT原則而衍生的基類，使用CRTP模式，T是繼承它的級別子類類型；它避免了每個子類都要編寫lock、trylock和unlock的冗余，并使用const T定義了鎖守衛類型別名，這是為了支持子類的const方法。class_level_lock和object_level_lock中的T是宿主類類型，L是鎖類型，當L為null_mutex時，為避免調用lock（或trylock）和unlock的開銷，提供了一個空級別，實現為null_level_lock類模板，繼承level_lock_base，并且必須要以它特化鎖守衛，這樣在實際使用時就不會引起"lock_不是null_level_lock<T,L>的成員"編譯錯誤。
1 template<class T,class L>
2 class null_level_lock : public level_lock_base<null_level_lock<T,L> >
3{
4protected:
5 ~null_level_lock(){}
6};
7
8 template<class T,class L>
9 class lock_guard<const null_level_lock<T,L> >
10{
11public:
12 explicit lock_guard(const null_level_lock<T,L>&){}
13 ~lock_guard(){}
14};
應用示例
編譯時選擇鎖類型與級別
stl_sequence是以stl中的vector、list和deque三種序列容器為基礎進行共性抽象的包裝容器，為了使它靈活支持各種鎖與級別，就需要將鎖和級別定義為模板參數，并提供一個默認的類型。
1
template<typename T,
2 class L = null_mutex, //lock type
3 template<class T,class L> class E = null_level_lock, //lock level
4 template<class T,class U> class C = std::vector,
5 template <class T> class U = std::allocator
6 >
7class stl_sequence : private E<stl_sequence<T,L,E,C,U>,L>
8
{
9
typedef U<T> Allocator;
10 typedef C<T,Allocator> cont_type;
11 typedef stl_sequence<T,L,E,C,U> self_type;
12 typedef E<self_type,L> base_type;
13 typedef typename base_type::lock_guard_type lock_guard_type;
14
15public:
16
17 void add(const T &t,bool append = true)
18
{
19 lock_guard_type guard(*this);
20 //do add thing
21
}
22
23 void insert(size_t idx,const T &t)
24 {
25 lock_guard_type guard(*this);
26 //do insert thing
27 }
28
29 void erase(size_t idx)
30 {
31 lock_guard_type guard(*this);
32 //do erase thing
33 }
34
35 T* get(size_t idx)
36 {
37 lock_guard_type guard(*this);
38 //do get thing
39 }
40
41
};
從上可見，增加、刪除、修改和查找操作都是通過首先調用lock_guard_type guard(*this)僅一行代碼來支持線程同步，下面來看看它的使用。
● 使用空級別鎖：seq1和seq2都沒有鎖，即使seq2使用了thread_mutex。
1 stl_sequence<int> seq1;
2 stl_sequence<int,thread_mutex> seq2;
● 使用對象級別鎖：seq3和seq4具有各自的鎖。
1 stl_sequence<int,thread_mutex,object_level_lock> seq3, seq4;
● 使用類級別鎖：seq5和seq6共享同一個鎖。
1 stl_sequence<int,thread_mutex,class_level_lock> seq5, seq6;
● 使用空鎖：seq7、seq8和seq9都沒有鎖，但seq7效率稍高。
1 stl_sequence<int,null_mutex> seq7;
2 stl_sequence<int,null_mutex,class_level_lock> seq8;
3 stl_sequence<int,null_mutex,object_level_lock> seq9;
綜上可知，在單線程環境中，使用空級別空鎖就夠了；而在多線程環境中,可依據需求靈活選擇對象級別或類級別鎖。
運行時綁定具體鎖
1 lock_base *lb;
2 if(argc>1 && 0==strcmp(argv[1],"thread_mutex"))
3 lb = new lock_adapter<thread_mutex>(*(new thread_mutex));
4 else
5 lb = new lock_adapter<null_mutex> (*(new null_mutex));
6
auto_ptr<lock_base> ap(lb);
7 lock_guard<lock_base> guard(*lb);
8 //do some thing
posted on 2014-12-28 23:38
春秋十二月 閱讀(2421)
評論(6) 編輯 收藏 引用 所屬分類:
Opensrc