标签: thread-local

我目前正在构建一个系统，其中有多个线程正在运行，一个线程可以将工作排队到另一个线程并等待完成。我使用互斥体和条件变量进行同步。为了避免为每个操作创建新的互斥体和 cv，我想对其进行优化，并尝试为每个正在等待的线程使用 thread_local 互斥体/cv 对。然而，这出乎意料地不起作用，我很有趣为什么。

基本上我的代码将工作排队到另一个线程并等待它，如下所示：

/* thread_local */ std::mutex mtx;
/* thread_local */ std::condition_variable cv;
bool done = false;  

io_service.post([&]() {
    // Execute the handler in context of the io thread
    functionWhichNeedsToBeCalledInOtherThread();

    // Signal completion to unblock the waiter
    {
        std::lock_guard<std::mutex> lock(mtx);
        done = true;
    }
    cv.notify_one();
});

// Wait until queued work has been executed in io thread
{
    std::unique_lock<std::mutex> lk(mtx);
    while (!done) cv.wait(lk);
}

如果同步对象不是，则此方法可以正常工作thread_local。当我添加thread_local等待线程时，它会永远等待，这表明条件变量永远不会发出信号。我现在有一种感觉，尽管通过引用捕获对象，但另一个线程的 thread_local 对象在 lambda 内部使用。mtx我什至可以通过检查lambda 内部和外部的地址来确认捕获没有执行正确的操作-> 它们不匹配。 …

我有以下情况：在标头“test.hpp”中我定义：

class ObjectA {
    public:
        ObjectA();
        ~ObjectA();
        static ObjectA & get_A();
};
class ObjectB {
    public:
        ~ObjectB();
        static ObjectB & get_B();
        void do_cleanup();
};

在单独的编译单元中，我实现了 ObjectB：

#include "test.hpp"
#include <iostream>
ObjectB::~ObjectB() {
    std::cout<<"ObjectB dtor"<<std::endl;
}
ObjectB & ObjectB::get_B() {
    thread_local ObjectB b_instance;
    return b_instance;
}
void ObjectB::do_cleanup() {
    std::cout<<"Clearing up B garbage..."<<std::endl;
}

对象A：

#include "test.hpp"
#include <iostream>
ObjectA::ObjectA() {
    ObjectB::get_B(); <--dummy call to initialize thread_local ObjectB;
}
ObjectA::~ObjectA() {
     std::cout<<"ObjectA dtor"<<std::endl;
     ObjectB::get_B().do_cleanup(); // <-- is this undefined behaviour??
} …

我在文件 tracker.hpp 中有一个变量：

namespace TRIALS
{
    static thread_local int a = -1;
}

我在 ema.hpp/ema.cpp 中的文件中有另一个名为 EMP 的类

namespace Algo
{
    class EMP
    {
        public:
            void Sample();
    };
}

namespace Algo
{
    void EMP::Sample()
    {
        std::cout << "model " << std::this_thread::get_id() << " " << &TRIALS::a << " " << TRIALS::a << std::endl;
    }
}

然后我的主文件

auto model = Algo::EMP();

void Simulate(const int a)
{
    TRIALS::a = a;
    model.Sample()
    std::cout << "worker " << std::this_thread::get_id() << " " << &TRIALS::a …

Rust 标准库中的线程局部变量是如何工作的？我查看了代码，但在间接中迷失了方向。线程本地存储、OS 依赖模式和快速模式似乎有不同的配置。哪一个是默认的，我该如何选择使用哪一个？特别是，在 crate 中使用线程本地存储对 crate 用户有什么影响？

使用线程本地存储非常简单，生成的程序集看起来非常高效，但如果不完全理解其含义，我无法在库中使用该功能。

我也问过：

• Rust 中的线程局部变量将使用多少字节？

而不是编写以下非线程安全的方法.

private static final Calendar calendar = Calendar.getInstance();
public void fun() {
    // Going to call mutable methods in calendar.
}

我将其更改为线程安全版本.

public void fun() {
    final Calendar calendar = Calendar.getInstance();
    // Going to call mutable methods in calendar.
}

即使对于同一个线程,我也不是每次创建一个新实例,而是通过执行改进

public void fun() {
    final Calendar calendar = getCalendar();
    // Going to call mutable methods in calendar.
}

/**
 * Returns thread safe calendar.
 * @return thread safe calendar
 */
public Calendar getCalendar() {
    return calendar.get();
}

private static …

外行人说,当有人说某个对象是Java中的线程单一单例时,它意味着什么？我正在参加有关Java Server Faces的讲座,每次谈到FacesContext时 - 讲师总是提醒我们这是一个线程单一的单身人士.

我们可以在一个中设置多个对象ThreadLocal吗？