blob: 0bbcd4cb9bcc8cf85ff277e5fe819ef400545f33 (
plain) (
blame)
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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
//
// ThreadLocal.h
//
// Library: Foundation
// Package: Threading
// Module: Thread
//
// Definition of the ThreadLocal template and related classes.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_ThreadLocal_INCLUDED
#define Foundation_ThreadLocal_INCLUDED
#include "Poco/Foundation.h"
#include <map>
namespace Poco {
class Foundation_API TLSAbstractSlot
/// This is the base class for all objects
/// that the ThreadLocalStorage class manages.
{
public:
TLSAbstractSlot();
virtual ~TLSAbstractSlot();
};
template <class C>
class TLSSlot: public TLSAbstractSlot
/// The Slot template wraps another class
/// so that it can be stored in a ThreadLocalStorage
/// object. This class is used internally, and you
/// must not create instances of it yourself.
{
public:
TLSSlot():
_value()
{
}
~TLSSlot()
{
}
C& value()
{
return _value;
}
private:
TLSSlot(const TLSSlot&);
TLSSlot& operator = (const TLSSlot&);
C _value;
};
class Foundation_API ThreadLocalStorage
/// This class manages the local storage for each thread.
/// Never use this class directly, always use the
/// ThreadLocal template for managing thread local storage.
{
public:
ThreadLocalStorage();
/// Creates the TLS.
~ThreadLocalStorage();
/// Deletes the TLS.
TLSAbstractSlot*& get(const void* key);
/// Returns the slot for the given key.
static ThreadLocalStorage& current();
/// Returns the TLS object for the current thread
/// (which may also be the main thread).
static void clear();
/// Clears the current thread's TLS object.
/// Does nothing in the main thread.
private:
typedef std::map<const void*, TLSAbstractSlot*> TLSMap;
TLSMap _map;
friend class Thread;
};
template <class C>
class ThreadLocal
/// This template is used to declare type safe thread
/// local variables. It can basically be used like
/// a smart pointer class with the special feature
/// that it references a different object
/// in every thread. The underlying object will
/// be created when it is referenced for the first
/// time.
/// See the NestedDiagnosticContext class for an
/// example how to use this template.
/// Every thread only has access to its own
/// thread local data. There is no way for a thread
/// to access another thread's local data.
{
typedef TLSSlot<C> Slot;
public:
ThreadLocal()
{
}
~ThreadLocal()
{
}
C* operator -> ()
{
return &get();
}
C& operator * ()
/// "Dereferences" the smart pointer and returns a reference
/// to the underlying data object. The reference can be used
/// to modify the object.
{
return get();
}
C& get()
/// Returns a reference to the underlying data object.
/// The reference can be used to modify the object.
{
TLSAbstractSlot*& p = ThreadLocalStorage::current().get(this);
if (!p) p = new Slot;
return static_cast<Slot*>(p)->value();
}
private:
ThreadLocal(const ThreadLocal&);
ThreadLocal& operator = (const ThreadLocal&);
};
} // namespace Poco
#endif // Foundation_ThreadLocal_INCLUDED
|
