blocks|key|1869941|text|可移植的解决方案是将您自己生成的is传递到线程中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1869942|int+id+=+0;
for(auto&+work_item+:+all_work)+{
++++std::async(std::launch::async,+[id,&work_item]{+work_item(id);+});
++++%2B%2Bid;
}|code-block|syntax|javascript|1869943|std::thread::id类型仅用于比较，而不用于算术(即，正如它在can上所说的:标识符)。即使是由operator<<生成的文本表示也是未指定的，因此您不能依赖它作为数字的表示。|offset|length|style|CODE|1869944|您还可以使用std::thread::id值到您自己的id的映射，并在线程之间共享此映射(通过适当的同步)，而不是直接传递id。|1869945|entityMap^0|0|0|0|F|1H|A|0|6|F|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]|$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@$I|Y|J|Z|K|L]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|P|$]]

The portable solution is to pass your own generated IDs into the thread.

<pre><code>int id = 0;
for(auto&amp; work_item : all_work) {
 std::async(std::launch::async, [id,&amp;work_item]{ work_item(id); });
 ++id;
}
</code></pre>

The <code>std::thread::id</code> type is to be used for comparisons only, not for arithmetic (i.e. as it says on the can: an identifier). Even its text representation produced by <code>operator&lt;&lt;</code> is unspecified, so you can't rely on it being the representation of a number.

You could also use a map of <code>std::thread::id</code> values to your own id, and share this map (with proper synchronization) among the threads, instead of passing the id directly.

blocks|key|1869947|text|我真的不知道这有多快，但这是我设法猜测的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1869948|const+size_t+N_MUTEXES=128;//UINT_MAX,not+128++for+answer+to+my+original+question
hash<std::thread::id>+h;
cout<<h(std::this_thread::get_id())%25N_MUTEXES<<endl;|code-block|syntax|javascript|1869949|我又一次开始认为，获取指向该结构的指针并将其转换为unsigned+int或uint64_t是解决方案……编辑：|1869950|uint64_t+get_thread_id()
{
++++static_assert(sizeof(std::thread::id)==sizeof(uint64_t),"this+function+only+works+if+size+of+thead::id+is+equal+to+the+size+of+uint_64");
++++auto+id=std::this_thread::get_id();
++++uint64_t*+ptr=(uint64_t*)+&id;
++++return+(*ptr);
}
int+main()
{
++++cout<<std::this_thread::get_id()<<"++"<<get_thread_id()<<endl;
}|1869951|static_assert来防止地狱般的问题:)与寻找这种bug相比，重写是很容易的。:)|1869952|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I really dont know how fast is this, but this is the solution I managed to guestimate :

<pre><code>const size_t N_MUTEXES=128;//UINT_MAX,not 128 for answer to my original question
hash&lt;std::thread::id&gt; h;
cout&lt;&lt;h(std::this_thread::get_id())%N_MUTEXES&lt;&lt;endl;
</code></pre>

Again I'm starting to think that getting a pointer to the structure and casting it to unsigned int or uint64_t is the answer...
EDIT:

<pre><code>uint64_t get_thread_id()
{
 static_assert(sizeof(std::thread::id)==sizeof(uint64_t),"this function only works if size of thead::id is equal to the size of uint_64");
 auto id=std::this_thread::get_id();
 uint64_t* ptr=(uint64_t*) &amp;id;
 return (*ptr);
}
int main()
{
 cout&lt;&lt;std::this_thread::get_id()&lt;&lt;" "&lt;&lt;get_thread_id()&lt;&lt;endl;
}
</code></pre>

static_assert to prevent hellish problems :) Rewrite is easy compared to hunting down this kind of bug. :)

blocks|key|1869954|text|一个想法是使用线程本地存储来存储变量--不管它是什么类型，只要它符合线程本地存储的规则--然后使用该变量的地址作为你的“线程id”。显然，任何算术运算都是没有意义的，但它将是一个整数类型。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1869955|对于后代：pthread_self()返回一个pid_t，并且是posix。对于可移植的定义来说，这是可移植的。|offset|length|style|CODE|1869956|gettid()，几乎可以肯定它不是可移植的，但它确实返回一个GDB友好的值。|1869957|entityMap^0|0|5|E|N|5|0|0|8|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]|$D|P|E|Q|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@$D|S|E|T|F|G]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|K|$]]

One idea would be to use thread local storage to store a variable - doesn't matter what type, so long as it complies with the rules of thread local storage - then to use the address of that variable as your "thread id". Obviously any arithemetic will not be meaningful, but it will be an integral type.

For posterity:
<code>pthread_self()</code> returns a <code>pid_t</code> and is posix. This is portable for some definition of portable.

<code>gettid()</code>, almost certainly not portable, but it does return a GDB friendly value.

blocks|key|2083732|text|另一个id+(idea？%5E%5E)是使用stringstreams：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2083733|std::stringstream+ss;
ss+<<+std::this_thread::get_id();
uint64_t+id+=+std::stoull(ss.str());|code-block|syntax|javascript|2083734|如果你不想在出错的情况下出现异常，请使用try+catch…|2083735|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Another id (idea? ^^) would be to use stringstreams:

<pre><code>std::stringstream ss;
ss &lt;&lt; std::this_thread::get_id();
uint64_t id = std::stoull(ss.str());
</code></pre>

And use try catch if you don't want an exception in the case things go wrong...

blocks|key|2083818|text|这取决于您要使用thread_id做什么；您可以使用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2083819|std::stringstream+ss;
ss+<<+std::this_thread::get_id();
uint64_t+id+=+std::stoull(ss.str());|code-block|syntax|javascript|2083820|这将为您的进程生成一个唯一的id；但是有一个限制:如果您启动同一进程的多个实例，并且每个实例都将其线程id写入到一个公共文件中，则无法保证thread_id的唯一性；实际上，您很可能会有重叠。在这种情况下，您可以执行以下操作：|2083821|#include+<sys/time.h>
timespec+ts;
clock_gettime(CLOCK_REALTIME,+&ts);
uint64_t+id+=+(ts.tv_sec+%25+1000000000)+*+1000000000+%2B+ts.tv_nsec;|2083822|现在，您可以保证获得系统范围内唯一的线程ids。|2083823|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

it depends on what you what you want to use the thread_id for; 
you can use:

<pre><code>std::stringstream ss;
ss &lt;&lt; std::this_thread::get_id();
uint64_t id = std::stoull(ss.str());
</code></pre>

This will generate a unique id withing you process; but there's a limitation: if you launch several instances of the same process and each one of them writes their thread ids to a common file, the uniqueness of the thread_id is not guaranteed; in fact it's very likely you'll have overlaps.
In this case you can do something like:

<pre><code>#include &lt;sys/time.h&gt;
timespec ts;
clock_gettime(CLOCK_REALTIME, &amp;ts);
uint64_t id = (ts.tv_sec % 1000000000) * 1000000000 + ts.tv_nsec;
</code></pre>

now you are guaranteed unique thread ids systemwide.

blocks|key|2083829|text|以这种方式，应该是有效的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2083830|std::stringstream+ss;
ss+<<+std::this_thread::get_id();
int+id+=+std::stoi(ss.str());|code-block|syntax|javascript|2083831|记住要包含库sstream|2083832|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

In this way, should work:

<pre><code>std::stringstream ss;
ss &lt;&lt; std::this_thread::get_id();
int id = std::stoi(ss.str());
</code></pre>

Remember to include library sstream

blocks|key|2083837|text|thread::native_handle()返回thread::native_handle_type，这是long+unsigned+int的一个类型定义。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2083838|如果线程是默认构造的，则native_handle()返回0。如果有OS线程连接到它，则返回值为非零(在POSIX上为pthread_t+)。|2083839|entityMap^0|0|N|P|Q|1I|H|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|R|8|@]|D|@]|E|$]]]|I|$]]

<code>thread::native_handle()</code> returns <code>thread::native_handle_type</code>, which is a typedef to <code>long unsigned int</code>.

If thread is default constructed, native_handle() returns 0.
If there is an OS thread attached to it, the return value is non-zero (it is pthread_t on POSIX).

blocks|key|2083844|text|也许这个解决方案对某些人有帮助。叫它第一次im+main()吧。警告：names无限增长。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2083845|std::string+currentThreadName(){
++++static+std::unordered_map<std::thread::id,std::string>+names;
++++static+std::mutex+mtx;

++++std::unique_lock<std::mutex>+lock(mtx);

++++auto+id+=+std::this_thread::get_id();

++++if(names.empty()){
++++++++names[id]+=+"Thread-main";
++++}+else+if(names.find(id)+==+names.end()){
++++++++std::stringstream+stream;
++++++++stream+<<+"Thread-"+<<+names.size();
++++++++names[id]+=+stream.str();
++++}

++++return+names[id];
}|code-block|syntax|javascript|2083846|entityMap^0|O|6|Z|5|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

Maybe this solution be helpful to someone. Call it a first time im <code>main()</code>. Warning: <code>names</code> grows indefinitely.

<pre><code>std::string currentThreadName(){
 static std::unordered_map&lt;std::thread::id,std::string&gt; names;
 static std::mutex mtx;

 std::unique_lock&lt;std::mutex&gt; lock(mtx);

 auto id = std::this_thread::get_id();

 if(names.empty()){
 names[id] = "Thread-main";
 } else if(names.find(id) == names.end()){
 std::stringstream stream;
 stream &lt;&lt; "Thread-" &lt;&lt; names.size();
 names[id] = stream.str();
 }

 return names[id];
}
</code></pre>

blocks|key|2083851|text|不使用thread::get_id()的一个关键原因是它在单个程序/进程中不是唯一的。这是因为，一旦第一个线程完成，该id就可以在第二个线程中重用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2083852|这似乎是一个可怕的特性，但它是c%2B%2B11中的特性。|2083853|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

A key reason not to use thread::get_id() is that it isn't unique for in a single program/process. This is because the id can be reused for a second thread, once the first thread finishes.

This seems like a horrible feature, but its whats in c++11.

blocks|key|1870051|text|另一种选择：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1870052|#include+<atomic>

static+std::atomic<unsigned+long+long>+thread_counter;

unsigned+long+long+thread_id()+{
++++thread_local+unsigned+long+long+tid+=+%2B%2Bthread_counter;
++++return+tid;
}|code-block|syntax|javascript|1870053|在64位x86中，g%2B%2B为该函数生成的代码如下：|1870054|_Z9thread_idv:
++++++++cmp+++++BYTE+PTR+fs:_ZGVZ9thread_idvE3tid@tpoff,+0
++++++++je++++++.L2
++++++++mov+++++rax,+QWORD+PTR+fs:_ZZ9thread_idvE3tid@tpoff
++++++++ret
.L2:
++++++++mov+++++eax,+1
++++++++lock+xadd+++++++QWORD+PTR+_ZL14thread_counter[rip],+rax
++++++++mov+++++BYTE+PTR+fs:_ZGVZ9thread_idvE3tid@tpoff,+1
++++++++mov+++++QWORD+PTR+fs:_ZZ9thread_idvE3tid@tpoff,+rax
++++++++ret
_ZGVZ9thread_idvE3tid:
++++++++.zero+++8
_ZZ9thread_idvE3tid:
++++++++.zero+++8|1870055|也就是说，没有任何同步的单个分支将被正确预测，除非您第一次调用该函数。在此之后，只需进行一次内存访问，而不进行同步。|1870056|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Another alternative:

<pre><code>#include &lt;atomic&gt;

static std::atomic&lt;unsigned long long&gt; thread_counter;

unsigned long long thread_id() {
 thread_local unsigned long long tid = ++thread_counter;
 return tid;
}
</code></pre>

The generated code for this function by g++ in x86 64-bit is just:

<pre><code>_Z9thread_idv:
 cmp BYTE PTR fs:_ZGVZ9thread_idvE3tid@tpoff, 0
 je .L2
 mov rax, QWORD PTR fs:_ZZ9thread_idvE3tid@tpoff
 ret
.L2:
 mov eax, 1
 lock xadd QWORD PTR _ZL14thread_counter[rip], rax
 mov BYTE PTR fs:_ZGVZ9thread_idvE3tid@tpoff, 1
 mov QWORD PTR fs:_ZZ9thread_idvE3tid@tpoff, rax
 ret
_ZGVZ9thread_idvE3tid:
 .zero 8
_ZZ9thread_idvE3tid:
 .zero 8
</code></pre>

I.e. a single branch without any synchronization that will be correctly predicted except for the first time you call the function. After that just a single memory access without synchronization.

c++11 has a possibility of getting current thread id, but it is not castable to integer type:

<pre><code>cout&lt;&lt;std::this_thread::get_id()&lt;&lt;endl;
</code></pre>

output : 139918771783456

<pre><code>cout&lt;&lt;(uint64_t)std::this_thread::get_id()&lt;&lt;endl;
</code></pre>

error: invalid cast from type ‘std::thread::id’ to type ‘uint64_t’
same for other types:
invalid cast from type ‘std::thread::id’ to type ‘uint32_t’

I really dont want to do pointer casting to get the integer thread id. Is there some reasonable way(standard because I want it to be portable) to do it?

How to get integer thread id in c++11

c++11有可能获得当前线程id，但它不能强制转换为整数类型：cout<<std::this_thread::get_id()<<endl;输出: 139918771783456cout<<(uint64_t)std::this_thread::get_id()<<endl;错误:类型‘std：：thread：：id’...

问如何在c++11中获取整数线程id
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在c++11中获取整数线程idEN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在c++11中获取整数线程id
EN