标签: thread-local

在C/C++应用程序中嵌入Python解释器已有详细记录.在C/C++应用程序中调用的多个操作系统线程(即同一进程中的一个操作系统线程上的一个解释器)上运行多个python解释器的最佳方法是什么？此类应用程序也可能存在与内存碎片和Py_Finalize()限制相关的问题.

一种这样的方法可以是:

1. Python线程,因此在pyconfig.h中禁用GIL以保持简单(#undef WITH_THREAD)
2. Python解释器源代码的所有可变全局变量都移动到通过线程本地存储引用的堆分配结构(参考:电话上的Python).

我的问题是:

1. 有没有更好的方法？
2. 是否有任何工具可以自动将Python解释器源代码的全局变量转换为通过TLS(线程本地存储)引用的堆分配结构？

这里讨论类似的主题:

• C/C++程序中有多个独立的Python解释器？
• 同一进程中有多个python解释器
• Lua Versus Python

我最近阅读了这篇关于标记为ThreadStatic的字段性能不佳的帖子 - 它们显然比正常的字段访问慢60倍..NET 4的ThreadLocal <T>执行得更好吗？

有没有提供高性能线程专用存储的替代方案？

每个人都在Django世界似乎恨threadlocals(http://code.djangoproject.com/ticket/4280,http://code.djangoproject.com/wiki/CookBookThreadlocalsAndUser).我读过Armin的论文(http://lucumr.pocoo.org/2006/7/10/why-i-cant-stand-threadlocal-and-others),但大多数都取决于threadlocals是坏的,因为它是不雅.

我有一个场景,其中thellocals将使事情变得更加容易.(我有一个应用程序,人们将有子域名,因此所有模型都需要访问当前子域名,并且从请求中传递它们是不值得的,如果threadlocals的唯一问题是它们不优雅,或者变得脆弱码.)

许多Java框架似乎也经常使用threadlocals,那么他们的情况与Python/Django的情况有何不同？

我遇到了一个问题,我正在创建一个ThreadLocal并用新的ThreadLocal初始化它.问题是,我在概念上只是想要一个持久的列表,这个列表会延续线程的生命,但我不知道是否有办法在Java中初始化每个线程的东西.

例如,我想要的是:

ThreadLocal static {
  myThreadLocalVariable.set(new ArrayList<Whatever>());
}

这样它就可以为每个线程初始化它.我知道我可以这样做:

private static Whatever getMyVariable() {
  Whatever w = myThreadLocalVariable.get();
  if(w == null) {
    w = new ArrayList<Whatever>();
    myThreadLocalVariable.set(w);
  }
  return w; 
}

但是每次使用它时我都不需要检查它.我能在这做什么更好的事情吗？

这是在RHEL上的Java 7(51)上有24个内核我们注意到,当我们增加线程池大小时,包含在本地线程中的java SimpleDateFormat的平均响应时间会增加.这是预期的吗？或者,我只是在做一些愚蠢的事情？

测试程序

    public class DateFormatterLoadTest {
        private static final Logger LOG = Logger.getLogger(DateFormatterLoadTest .class);
        private final static int CONCURRENCY = 10;

        public static void main(String[] args) throws Exception {
            final AtomicLong total = new AtomicLong(0);
            ExecutorService es = Executors.newFixedThreadPool(CONCURRENCY);
            final CountDownLatch cdl = new CountDownLatch(CONCURRENCY);
            for (int i = 0; i < CONCURRENCY; i++) {
                es.execute(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            int size = 65000;
                            Date d = new Date();

                            long time = System.currentTimeMillis(); …

当ThreadLocal我使用时应该总是remove()在我完成时或当我这样做时set,旧的值被替换,因此remove是多余的？

请考虑以下示例(cout为简单起见,省略了锁定保护).

#include <future>
#include <iostream>
#include <thread>

using namespace std;

struct C
{
  C() { cout << "C constructor\n";}
  ~C() { cout << "C destructor\n";}
};

thread_local C foo;

int main()
{
   int select;
   cin >> select;
   future<void> f[10];
   for ( int i = 0;i < 10; ++i)
       f[i] = async( launch::async,[&](){ if (select) foo; } );
   return 0;
}

在clang和gcc上,如果用户写'0',该程序不输出任何内容,而如果用户输入非零数字则打印Constructor/ Destructor10次​​.另外clang抱怨明显的非使用表达结果.

由于thread_local存储生命周期应该跨越整个线程的生命周期,我期望foo在每个线程中初始化变量,而不管用户输入如何.

我可能想要一个thread-local变量,其唯一目的是在构造函数中产生副作用,标准是否要求thread_local在第一次使用时初始化对象？

在大量(每秒约50,000个请求)java web-app我正在使用ThreadLocal来执行应该按请求范围执行的任务.

我可以使用Spring请求范围实现相同的效果,我想知道哪个性能更好？

在代码中,使用ThreadLocal:

private static final ThreadLocal<SomeClass> myThreadLocal = new ThreadLocal<SomeClass>();

并为每个http请求设置:

myThreadLocal.set(new SomeClass());

使用Spring请求范围:

@Component
@Scope("request")
public class SomeClass{
...
}

现在,会花多少钱:

myThreadLocal.get();

要么

SpringContext.getBean(SomeClass.class);

我想知道是否有人已经尝试过这样的基准测试？

这个问题让我想到了Java和.NET等高级开发框架中的线程局部存储.

Java有一个ThreadLocal<T>类(也许还有其他构造),而.NET有数据槽,很快就有ThreadLocal<T>了它自己的类.(它也有ThreadStaticAttribute,但我对成员数据的线程局部存储特别感兴趣.)大多数其他现代开发环境为语言或框架级别提供了一种或多种机制.

线程局部存储解决了什么问题,或者线程局部存储提供了什么优势,而不是创建单独的对象实例以包含线程本地数据的标准面向对象的习惯用法？换句话说,这是怎么回事:

// Thread local storage approach - start 200 threads using the same object
// Each thread creates a copy of any thread-local data
ThreadLocalInstance instance = new ThreadLocalInstance();
for(int i=0; i < 200; i++) {
    ThreadStart threadStart = new ThreadStart(instance.DoSomething);
    new Thread(threadStart).Start();
}

优于此？

// Normal oo approach, create 200 objects, start a new thread on each
for(int i=0; i < 200; i++) {
    StandardInstance standardInstance …

在线程本地中设置值:

//Class A holds the static ThreadLocal variable.

    Class A{

    public static ThreadLocal<X> myThreadLocal = new ThreadLocal<X>();             
    ....
    }


//A Class B method sets value in A's static ThreadLocal variable 
    class B{
    {
         public void someBmethod(){
             X x = new X();
             A.myThreadLocal.set(x);
         }
    }


//Class C retrieves the value set in A's Thread Local variable.

    Class C {

    public void someCMethod(){
         X x = A.myThreadLocal.get();
    }
    ...
    }

Quesiton:
现在假设这是一个Web应用程序,并且线程按顺序执行:B.someBMethod,C.someCMethod.

执行B的someBMethod的多个线程将最终更新SAME A的静态ThreadLocal变量myThreadLocal,从而击败了ThreadLocal变量的目的.(对于ThreadLocal使用静态是根据文档推荐的.)

C的someCMethod,虽然从ThreadLocal中检索值可能无法获得"当前"线程设置的值.

我在这里失踪了什么？