深入解析 Hazard Pointer (上)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#include<iostream>
#include<thread> //C++11中的多线程基础设施
using namespace std;
int *p = new int(2);
void reader()
{
  if (nullptr != p) { //nullptr是C++11中引入的
    cout << *p << endl;
  }
}
void writer()
{
  delete p;
  p = nullptr;
}
int main()
{
  thread t1(reader);
  thread t2(writer);
  t1.join();
  t2.join();
  return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

#include<thread>
#include<iostream>
#define Memory_Barrier __asm__ __volatile__("" : : : "memory")
#define ACCESS_ONCE(x) (* (volatile typeof(x) *) &(x))
using namespace std;
struct HazardPointer
{
  HazardPointer() :p_(nullptr){}
  int *p_; //Hazard Pointer封装了原始指针
};

int *p = new int(2); //原始指针

HazardPointer *hp = new HazardPointer(); //只有一个线程可以写

class Writer
{
public:
  void retire(int *tmp) {
    retire_list = tmp;//设置要释放的指针
  }
  void gc() {
    if (retire_list == hp->p_) {
      //说明有读者正在使用它，不能释放
    } else {
      //可以安全地释放
      delete retire_list;
    }
  }
  void write() {
    int *tmp = ACCESS_ONCE(p);
    p = nullptr;
    retire(tmp);
    gc();
  }
private:
  int *retire_list;//记录待释放的指针
};
class Reader
{
public:
  void acquire(int *tmp) {
    hp->p_ = tmp;
  }
  void release() {
    hp->p_ = nullptr;
  }
  void read() {
    int *tmp = nullptr;
    do
    {
      tmp = ACCESS_ONCE(p);
      Memory_Barrier();
      acquire(tmp); //封装。这是告诉Writer：我要读，别释放！
    } while (tmp != ACCESS_ONCE(p));//仔细想想，为什么这里还要判断？
    if (nullptr != tmp) { //不妨想想，这里为什么也要判断？
      //it is safe to access *tmp from now on
      cout << *tmp << endl;//没问题~
    }
    //when you finish reading it, just release it .
    release();//其实就是告诉Writer：用完了，可以释放了。
  }
};
int main()
{
  thread t1(&Reader::read, Reader());
  thread t2(&Writer::write, Writer());
  t1.join();
  t2.join();
  return 0;
}