线程局部变量与 __thread

最新推荐文章于 2024-03-20 17:40:09 发布
转载 最新推荐文章于 2024-03-20 17:40:09 发布 · 819 阅读 · 0

线程局部变量与 __thread
–五竹,2012/09/03

现在使用多线程开发越来越普遍, 为了提高性能,性能局部变量使用也非常普遍.如线程私有的成员变量,buffer等.
本文首先介绍线程局部变量的2 种使用方法:
1). 常规的使用方式: 相对复杂
2). __thread 修饰符: 使用简单，但容易不正确使用

最后介绍封装的线程局变量操作接口，来解决上述两种使用方法的不足．该方法主要参考了 ACL 库关于这块的实现．

1 常规的使用方式

1
2
3
4
5
6
7
8
9
#include <pthread.h>
 
int pthread_once(pthread_once_t *once_control, void (*init_routine)(void));
pthread_once_t once_control = PTHREAD_ONCE_INIT;
 
int pthread_key_create(pthread_key_t *key, void (*destructor)(void*));
 
void *pthread_getspecific(pthread_key_t key);
int pthread_setspecific(pthread_key_t key, const void *value);

1). pthread_once 可以保证在整个进程空间init_routine函数仅被调用一次（它解决了多线程环境中使得互斥量和初始化代码都仅被初始化一次的问题）
2). pthread_key_create 的参数之一指一个析构函数指针，当某个线程终止时该析构函数将被调用，并用对于一个进程内的给定键，该函数只能被调用一次
3). pthread_sespecific 和 pthread_getspecific 用来存放和获取与一个键关联的值。

1.1 示例1：

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
pthread_key_t key; 
pthread_once_t once = PTHREAD_ONCE_INIT; 
  
static void destructor(void *ptr) 
{ 
    free(ptr); 
} 
  
void init_once(void) 
{ 
    pthread_key_create(&key, destructor); 
} 
  
static void *get_buf(void) 
{ 
    pthread_once(&once, init_once); 
      
    if ((ptr = pthread_getspecific(key)) == NULL)
    { 
        ptr = malloc(1024); 
        pthread_setspecific(key, ptr); 
    } 
    return (ptr); 
} 
  
static void *thread_fn(void *arg) 
{ 
    char *ptr = (char*) get_buf(); 
      
    sprintf(ptr, "hello world"); 
    printf(">>%s\n", ptr); 
    return (NULL); 
} 
  
void test(void) 
{ 
    int   i, n = 10; 
    pthread_t tids[10]; 
      
    for (i = 0; i < n; i++)
    { 
        pthread_create(&tids[i], NULL, thread_fn, NULL); 
    } 
      
    for (i = 0; i < n; i++)
    { 
        pthread_join(&tids[i], NULL); 
    } 
} 

2 __thread 修饰符
The __thread specifier may be applied to any global, file-scoped static, function-scoped static, or static data member of a class. It may not be applied to block-scoped automatic or non-static data member. [参考文档3]

基本类型(如(unsigned) int,long, char,指针，c类型的结构体等 )可以采用用 __thread修饰符来定义线程局部变量.
示例如下：

1
2
3
__thread int i;
extern __thread struct state s;
static __thread char *p;

像 string 等类是不能直接用 __thread 修符的，只能用其指针类型的．如下面的示例是错误的．

1
__thread std::string    thread_name;

下面是正确的:

1
__thread std::string *  p_thread_name;

使用 __thread修饰符来定义一些类的线程局部变量，往往容易造成内存泄漏．
2.1 示例2：

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
#include <unistd.h>
#include <stdio.h>
#include <signal.h>
#include <stdint.h>
#include <pthread.h>
#include <sys/syscall.h>
#include <vector>
#include <string>
 
#ifdef USE_TLS
#include "Tls.h"
#endif
 
#define gettid() syscall(__NR_gettid)
using namespace std;
 
class TlsLeakTest
{
public:
    TlsLeakTest();
    ~TlsLeakTest();
    virtual void start();
    bool threadFun();
public:
    static void * threadEntry(void * arg);
#ifdef USE_TLS
    static void releaseTls(void * ptr);
#endif
protected:
    static __thread std::string *   _vecArray;
    uint32_t                    _threadNum;
    std::vector<pthread_t>        _vecThreadIds;
 
};
 
__thread string *   TlsLeakTest::_vecArray=NULL;
 
TlsLeakTest::TlsLeakTest()
{
    _threadNum=10;
}
TlsLeakTest::~TlsLeakTest()
{
}
void TlsLeakTest::start()
{
    pthread_t tid=0;
    for(uint32_t i=0; i < _threadNum; i++)
    {
         pthread_create(&tid, NULL, TlsLeakTest::threadEntry, this);
        _vecThreadIds.push_back(tid);
    }
    //waiting for threads to finish
    for(uint32_t i=0; i<_threadNum; i++)
    {
        if(_vecThreadIds[i] != 0)
        {
            pthread_join(_vecThreadIds[i], NULL);
            _vecThreadIds[i]=0;
        }
    }
}
bool TlsLeakTest::threadFun()
{
    char buff[128];
    int64_t tid=gettid();
    for(int32_t i=0; i < 100 ; i++)
    {
        if(NULL == _vecArray )
        {
            _vecArray=new string[100];
#ifdef USE_TLS
            Tls::pthread_atexit_add((void *)_vecArray,&TlsLeakTest::releaseTls);
            printf("register TlsLeakTest::releaseTls(): tid=%ld\n",gettid());
#endif
        }
        sprintf(buff,"%ld:%d",tid,i);
        _vecArray[i]=buff;
        usleep(100000);
        if(99 == i)
        {
            printf("tid=%ld _vecArray's addr=%p _vecArray[99]=%s\n"
                                ,tid,_vecArray,_vecArray[99].c_str());
        }
    }
 
 
    return true;
 
}
 
void * TlsLeakTest::threadEntry(void * arg)
{
    TlsLeakTest *test=(TlsLeakTest*)arg;
    test->threadFun();
    return NULL;
}
 
#ifdef USE_TLS
void  TlsLeakTest::releaseTls(void * ptr)
{
    std::string * vecArray=(std::string *)ptr;
    if(vecArray)
    {
        delete []vecArray;
        vecArray=NULL;
        printf("TlsLeakTest::releaseTls(): tid=%ld\n",gettid());
    }
}
#endif
 
int main(int argc, char *argv[])
{
    TlsLeakTest test;
    test.start();
    return 0;
}

1) 编译:
g++ -g -o t_tls_mem_leak t_tls_mem_leak.cpp -lpthread

2) 用 valgrind 检查内存泄漏

valgrind -v –leak-check=full –tool=memcheck ./t_tls_mem_leak

==27391==
==27391== HEAP SUMMARY:
==27391== in use at exit: 40,980 bytes in 1,010 blocks
==27391== total heap usage: 1,025 allocs, 15 frees, 44,268 bytes allocated
==27391==
==27391== Searching for pointers to 1,010 not-freed blocks
==27391== Checked 183,352 bytes
==27391==
==27391== 40,980 (8,080 direct, 32,900 indirect) bytes in 10 blocks are definitely lost in loss record 2 of 2
==27391== at 0x4A067A3: operator new[](unsigned long) (vg_replace_malloc.c:305)
==27391== by 0x400C75: TlsLeakTest::threadFun() (t_tls_mem_leak.cpp:72)
==27391== by 0x400E5E: TlsLeakTest::threadEntry(void*) (t_tls_mem_leak.cpp:96)
==27391== by 0x38632064A6: start_thread (pthread_create.c:297)
==27391== by 0x38626D3C2C: clone (in /lib64/libc-2.5.so)
==27391==
==27391== LEAK SUMMARY:
==27391== definitely lost: 8,080 bytes in 10 blocks
==27391== indirectly lost: 32,900 bytes in 1,000 blocks
==27391== possibly lost: 0 bytes in 0 blocks
==27391== still reachable: 0 bytes in 0 blocks
==27391== suppressed: 0 bytes in 0 blocks
==27391==
==27391== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 4 from 4)
–27391–
–27391– used_suppression: 4 dl-hack3
==27391==
==27391== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 4 from 4)

3 封装的线程局变量操作接口

于常规的使用方式，每个线程局部变量的创建与使用，都需要通过pthread_once, pthread_key_create, pthread_sespecific 和 pthread_getspecific 来操作，比较复杂，但不会有内存泄漏问题．
__thread 修饰符，使用简单，但往往容易不正确使用造成内存泄漏．
为解决上述两种方法的不足，ACL 库提供了一种线程局部变量操作接口．本文中提供的 Tls 类，是参考了 ACL 库的实现．
主要实现方法如下：
1) 定义一个通用的内存释放结构，成员包括用户自定义的释放函数和参数

1
2
3
4
5
typedef struct pthread_atexit
{
    void   (*free_fn)(void *);
    void   *arg;
}pthread_atexit_t;

2) 通过常规方法，声明一个std::list 类型的线程局部变量,并注册一个退出时的内存释放函数；该释放函数在线程退出时，首先遍列该 list,调用list 成员对象的 free_fn 函数来释放其他的线程局部变量的内存．然后释放自身的内存．

3) 提供一个 static int pthread_atexit_add(void *arg, void (*free_fn)(void *) ) 接口．当用户使次用 __thread 修饰符声明线程局部变量指针时，定义一个相应的释放函数，然后通过上述接口加到线程局部变量内存释放函数list．这样，在线程退出时，用调用该内存释放函数来释放内存．

3.1 Tls 类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//Tls.h
#ifndef __SAP_UTIL_TLS_H_
#define __SAP_UTIL_TLS_H_
#include <pthread.h>
 
class Tls
{
public:
    static int pthread_atexit_add(void *arg, void (*free_fn)(void *) );
    static int pthread_atexit_remove(void *arg, void (*free_fn)(void*) );
protected:
    static void pthread_atexit_done(void *arg);
    static void pthread_atexit_init(void);
protected:
    static pthread_key_t    _pthread_atexit_key;
    static pthread_once_t   _pthread_atexit_control_once;
};
 
#endif
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
// Tls.cpp
#include <sys/syscall.h>
#include <list>
#include "Tls.h"
 
using namespace std;
 
 
#define gettid() syscall(__NR_gettid)
#define TLS_OUT_OF_INDEXES          0xffffffff
 
typedef struct pthread_atexit
{
    void   (*free_fn)(void *);
    void   *arg;
}pthread_atexit_t;
 
typedef std::list<pthread_atexit_t *> TlsList;
 
pthread_key_t   Tls::_pthread_atexit_key = TLS_OUT_OF_INDEXES;
pthread_once_t  Tls::_pthread_atexit_control_once = PTHREAD_ONCE_INIT;
 
void Tls::pthread_atexit_done(void *arg)
{
    TlsList *id_list = (TlsList*) arg;
    pthread_atexit_t *id_ptr=NULL;
    printf("invoke Tls::pthread_atexit_done(): tid=%ld\n",gettid());
    for(TlsList::iterator iter=id_list->begin(); iter !=id_list->end(); ++iter)
    {
        id_ptr = *iter;
        if (id_ptr == NULL)
            continue;
        if (id_ptr->free_fn)
            id_ptr->free_fn(id_ptr->arg);
        delete id_ptr;
    }
    delete id_list;
}
 
void Tls::pthread_atexit_init(void)
{
    pthread_key_create(&_pthread_atexit_key, pthread_atexit_done);
}
 
int Tls::pthread_atexit_add(void *arg, void (*free_fn)(void *))
{
    const char *myname = "pthread_atexit_add";
    pthread_atexit_t *id;
    TlsList *id_list;
 
    if (arg == NULL)
    {
        return 0;
    }
    pthread_once(&_pthread_atexit_control_once, pthread_atexit_init);
    if (_pthread_atexit_key == (pthread_key_t) TLS_OUT_OF_INDEXES)
    {
        printf("%s(%d): _pthread_atexit_key(%d) invalid\n",
                myname, __LINE__, _pthread_atexit_key);
        return (-1);
    }
 
    id = new pthread_atexit_t;
    if (id == NULL)
    {
        printf("%s(%d): new pthread_atexit_t error\n", myname, __LINE__);
        return -1;
    }
    id->free_fn = free_fn;
    id->arg = arg;
 
    id_list = (TlsList*) pthread_getspecific(_pthread_atexit_key);
    if (id_list == NULL)
    {
        id_list = new TlsList();
        if (pthread_setspecific(_pthread_atexit_key, id_list) != 0)
        {
            printf("%s(%d): pthread_setspecific error, key(%d)\n",
                    myname, __LINE__, _pthread_atexit_key);
            return -1;
        }
    }
    id_list->push_back(id);
    return 0;
}
 
int Tls::pthread_atexit_remove(void *arg, void (*free_fn)(void*))
{
    const char *myname = "pthread_atexit_remove";
    TlsList *id_list;
 
    if (arg == NULL)
    {
        return (-1);
    }
    if (_pthread_atexit_key == (pthread_key_t) TLS_OUT_OF_INDEXES)
    {
        printf("%s(%d): _pthread_atexit_key(%d)  invalid\n",myname, __LINE__, _pthread_atexit_key);
        return (-1);
    }
    id_list = (TlsList*) pthread_getspecific(_pthread_atexit_key);
    if (id_list == NULL)
    {
        printf("%s(%d): _pthread_atexit_key(%d) no exist in tid(%lu)\n",
            myname, __LINE__, _pthread_atexit_key,(unsigned long) pthread_self());
        return (-1);
    }
    pthread_atexit_t *id_ptr =NULL;
    TlsList::iterator iter=id_list->begin();
    for(; iter !=id_list->end(); ++iter)
    {
        id_ptr = *iter;
        if (id_ptr == NULL)
            continue;
        if (id_ptr->free_fn == free_fn && id_ptr->arg == arg)
        {
            break;
        }
    }
    if(id_ptr != NULL)
    {
        id_list->erase(iter);
        delete id_ptr;
    }
    return (0);
}

使用方法：
1) #include “Tls.h”
2) 用 __thread 声明某类型的线程局部变量指针
3) 定义该线程局部变量的内存释放函数
4) 第一次使用该线程局部变量时，分配内存并调用pthread_atexit_add注册内存释放函数

3.2 示例3 
示例3 的代码同示例2，主要增加了 USE_TLS　宏定义部分代码。

1) 编译
g++ -g -o t_tls_mem_leak t_tls_mem_leak.cpp Tls.cpp -lpthread -DUSE_TLS

2) 用 valgrind 检查内存泄漏
–21825– REDIR: 0x38626726f0 (free) redirected to 0x4a05d7d (free)
==21825==
==21825== HEAP SUMMARY:
==21825== in use at exit: 0 bytes in 0 blocks
==21825== total heap usage: 1,055 allocs, 1,055 frees, 44,828 bytes allocated
==21825==
==21825== All heap blocks were freed — no leaks are possible
==21825==
==21825== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 4 from 4)
–21825–
–21825– used_suppression: 4 dl-hack3
==21825==
==21825== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 4 from 4)

4 参考文档:
1) 线程局部变量的使用与多线程开发: http://developer.51cto.com/art/200909/153297.htm

2) 再谈线程局部变量 : http://zsxxsz.iteye.com/blog/548903

3) http://gcc.gnu.org/onlinedocs/gcc-4.3.2/gcc/Thread_002dLocal.html

C++(11)：线程局部变量thread_local
风静如云的博客
05-01 1534
(4).静态成员变量（成员变量必须是static的，此时对于同一个线程内的该类的多个对象，会共享这一个静态变量实例）。但无法保证每个线程的在运行期间g_d的值，因此会出现thread:60000 g_d=119472这种随机情况。因此只能保证当t1和t2线程运行结束后，g_d的值一定是140000。thread:60000 g_d=119472（此结果为随机的）虽然原子类型可以避免竞争，但是不能避免对全局变量的共享。两个线程分别对全局变量g_d进行操作，产生竞争。由于产生了线程竞争，因此此结果为随机的。
c++11之线程局部变量thread_local使用示例
最新发布
我不是码农的博客~~~
12-03 435
摘要：该代码演示了线程局部变量(tl_var)的使用，两个线程(t1,t2)分别向各自的tl_var写入数据并通过互斥锁(mtx)安全输出。主线程访问tl_var时由于线程局部特性无法获取子线程数据。展示了线程局部存储的隔离性和互斥锁的线程同步机制。
多线程：线程内局部变量
少年啦飞啦的博客
12-08 1813
ThreadLocal类 该类提供了线程内局部 (thread-local) 变量。 好比有两个窗口（两个线程），一个窗口可以拿饮料，一个窗口可以拿食物。现在有多个人要来拿东西，如果在饮料窗口有的人拿到了饮料，有的人拿到了不该拿的食物，就说明线程之间出现了混乱，我们应当避免这种情况出现。 以下代码就可能会出现线程混乱的问题： private static int data; publi...
线程变量__thread使用
sun172270102的博客
11-16 583
#define MAX_CALLBACK_TYPE 100 static struct { char stu_type; int flags; void *callback; } msg_callback[MAX_CALLBACK_TYPE] ; 如上结构体初始化： #define MAX_CALLBACK_TYPE 100 static struct { char stu_type; int flags; void *callback; } msg_callback[MAX_CALLBACK
线程局部变量：原理、应用与实践技巧
silenceallat的博客
03-20 1306
本文深入探讨了Java中的ThreadLocal机制，阐述了其原理和应用场景，强调了线程隔离和变量传递的重要性。文章介绍了ThreadLocal的使用技巧，包括避免内存泄漏和合理初始化，并通过案例分析了ThreadLocal在实际开发中的应用。同时，也讨论了ThreadLocal的适用性和未来发展趋势。最后，总结了ThreadLocal在多线程编程中的关键作用和注意事项。
深入理解线程局部变量：ThreadLocal
Jack Zhou的专栏
07-09 1万+
一、ThreadLocal概述 　　学习JDK中的类，首先看下JDK API对此类的描述，描述如下： 　　该类提供了线程局部 (thread-local) 变量。这些变量不同于它们的普通对应物，因为访问某个变量（通过其 get 或 set 方法）的每个线程都有自己的局部变量，它独立于变量的初始化副本。ThreadLocal 实例通常是类中的 private static 字段，它们希望
C++11之线程局部存储 thread_local
KingOfMyHeart的博客
07-23 503
我们知道，在Linux系统中，子线程是通过复制来产生的，由于进程是资源分配的最小单位，那么，进程中的线程除了有自身运行时需要的一些栈空间，寄存器等资源，其余资源都是和其他线程共享的，这就会引入一些资源竞争的问题，为应用程序执行带来不确定性。而线程存储指的是一种特殊的内存机制，用于将数据存储在当前线程的私有内存中，这样线程就有自己私有的数据存储空间，不会被其他线程所干扰。实际上，线程局部存储早就出现，由于是一种特殊的内存机制，所以需要操作系统层面的支持。
java 线程 全局变量_【转】Java多线程操作局部变量与全局变量
weixin_39828960的博客
02-12 771
原文网址：http://blog.youkuaiyun.com/undoner/article/details/12849661在这篇文章里，我们首先阐述什么是同步，不同步有什么问题，然后讨论可以采取哪些措施控制同步，接下来我们会仿照回顾网络通信时那样，构建一个服务器端的“线程池”，JDK为我们提供了一个很大的concurrent工具包，最后我们会对里面的内容进行探索。为什么要线程同步？说到线程同步，大部分情...
Hibernate用ThreadLocal模式(线程局部变量模式)管理Session
08-26
ThreadLocal并不是线程的本地实现，而是一个线程局部变量，它为每个线程提供了一个变量的副本，确保每个线程都可以独立地操作自己的副本，而不干扰其他线程。因此，ThreadLocal可以帮助我们在多线程环境下为每个线程...
线程局部变量（thread-local variable)
热门推荐
dongliheng的专栏
06-23 1万+
什么是线程局部变量（thread-local variable）？轻松使用线程: 不共享有时是最好的 ThreadLocal 类是悄悄地出现在 java 平台版本 1.2 中的。虽然支持线程局部变量早就是许多线程工具（例如 Posix pthreads 工具）的一部分，但 java Threads API 的最初设计却没有这项有用的功能。而且，最初的实现也相当低效。由于这些原因， Thread
什么是线程局部变量？
xiaoningaichila的博客
04-21 466
什么是线程局部变量？(答案) 线程局部变量是局限于线程内部的变量，属于线程自身所有，不在多个线程间共享。Java 提供 ThreadLocal 类来支持线程局部变量，是一种实现线程安全的方式。但是在管理环境下（如 web 服务器）使用线程局部变量的时候要特别小心，在这种情况下，工作线程的生命周期比任何应用变量的生命周期都要长。任何线程局部变量一旦在工作完成后没有释放，Java 应用就存在内存泄露的风险。 ...
多线程中的局部变量
weixin_33910759的博客
06-27 840
在实现多线程业务时，如果没有涉及到共享数据处理的业务，还是使用局部变量，必将，在处理共享数据时，还是需要加锁；线程与线程间的局部变量相互独立，变量的处理互补干扰。 在多线程的场景下，针对线程中的局部变量，如果需要让其他业务操作此变量时，此时 局部变量相对当前线程来讲，是全局变量； 局部变量相对其他线程来讲，是局部变量； 为了实现当前线...
__thread
qu1993的博客
10-31 1266
看muduo源码，发现有很多使用__thread的地方，所以先单独写一下__thread的功能。 这个特性是linux的非标准特性，需要内核(Linux2.6提供)、Pthreads实现(NPTL提供)以及C编译器(在X86-32平台上由gcc 3.3或后续版本提供)的支持。 线程局部存储的主要优点在于，比线程特有数据的使用要简单。要创建线程局部变量，只要简单地在全局或静态变量的声明中包含__thread说明符即可。 static __thread buf[MAX_ERROR_LEN]; 但凡带有这
多线程变量　　　　　__thread　自查文档
liuzhuchen的专栏
05-19 650
相关接口： __thread 修饰符 The __thread specifier may be applied to any global, file-scoped static, function-scoped static, or static data member of a class. It may not be applied to block-scoped automatic or
深入学习线程局部变量ThreadLocal
小小默：进无止境
01-29 2492
ThreadLocal是线程局部变量，和普通变量的不同在于：每个线程持有这个变量的一个副本，可以独立修改（set方法）和访问（get方法）这个变量，并且线程之间不会发生冲突。 类中定义的ThreadLocal实例一般会被private static修饰，这样可以让ThreadLocal实例的状态和Thread绑定在一起。业务上，一般用ThreadLocal包装一些业务ID（user ID或事务ID...
多线程-局部变量和成员变量
qianyiyiding的专栏
09-06 9089
Java多线程对成员变量和局部变量的影响最近复习了一下Java多线程的一些基础的础知识,这里演示一个java多线程对成员变量和局部变量的Demo对局部变量的操作：/** * Java局部变量和成员变量代码演示 */ public class TTTTTT { public static void main(String[] args) { DemoThread
什么是线程局部变量？如何在Java中使用线程局部变量？
wzxue1984的博客
08-22 614
线程局部变量(Thread Local Variable)是指每个线程都有自己的值副本，互不干扰，线程之间互不可见。它可以理解为一种特殊的变量，每个线程对应一个变量副本，不同线程之间访问的是各自的副本。线程局部变量适用于在多线程环境下需要保持独立状态的变量，例如记录用户信息或跟踪线程执行过程等。使用线程局部变量时，要注意及时清理或移除变量的值，以免造成内存泄露。是Java提供的一个用于创建线程局部变量的类，它通过为每个线程创建一个独立的变量副本来实现。方法为当前线程的局部变量设置值。类来实现线程局部变量。
局部变量
LC的专栏
09-07 1万+
C语言提供了局部变量的定义，局部变量也称为：内部变量。局部变量就是定义在大括号{ }包含的代码块内，例如： if(){ } if(){ }else{} for(){ } while() { } do{ } while(); switch(){ } 还有函数的定义，例如： voidfunc(void){ } 在大括号{}包含的代码块内定义的变量，称为：局部变量。程序测试例子如下例如： 程序运行结果如下： 可以看到，在main函数中定义的变量a和变量b，都是局部变...
找不到局部变量slot_3
07-08
在Java编程中，出现“找不到局部变量 slot_3”的问题通常与方法执行时的局部变量表（Local Variable Table）有关。局部变量表是一组变量存储空间，用于存放方法参数和方法内定义的局部变量，在编译阶段由Class文件中的Code属性的`max_locals`值指定其最大容量[^4]。 ### 可能原因及解决方法 #### 1. 局部变量作用域错误 如果尝试访问一个未被声明或已超出作用域的局部变量，会导致无法找到该变量。例如，在某个代码块中定义的变量试图在外部访问。 ```java public void method() { if (true) { int slot_3 = 10; } System.out.println(slot_3); // 编译错误：找不到变量 slot_3 } ``` **解决方法**：确保变量在使用前已被正确声明，并且访问范围在其作用域内。 #### 2. 编译器优化导致的变量不可见 JVM运行时常量池中的符号引用（如字段、方法引用）可能影响变量的可见性。例如，在某些情况下，编译器会进行逃逸分析并优化变量分配，使得原本预期在堆上分配的对象实际被分配在栈上，从而导致局部变量表中某些slot未被保留[^2]。 **解决方法**：避免对变量进行复杂的生命周期管理，尽量使用标准的变量声明方式，减少手动干预编译器行为的操作。 #### 3. 字节码操作或反编译工具误导 在使用ASM、Javassist等字节码增强工具时，若手动修改了局部变量表的结构，可能导致某些slot编号不匹配。例如，人为插入指令却未更新`max_locals`或局部变量表信息，造成运行时查找不到slot_3。 ```java // 假设手动插入了一条加载指令但未调整局部变量表 // aload_3 指令试图加载第4个局部变量（索引为3），但该slot未被分配 ``` **解决方法**：检查字节码修改逻辑，确保`max_locals`与局部变量表同步更新。使用调试工具（如JD-GUI、Bytecode Viewer）查看实际字节码，确认局部变量表是否包含期望的slot信息[^3]。 #### 4. 多线程环境下共享局部变量引发异常 虽然局部变量本身是线程私有的，但如果将局部变量引用传递给其他线程（如通过Runnable对象），则可能引发并发访问问题，甚至导致变量状态不一致。 ```java public void method1(int loopNumber) { ArrayList<String> list = new ArrayList<>(); for (int i = 0; i < loopNumber; i++) { new Thread(() -> { method2(list); // list 是局部变量，但被多个线程共享 }).start(); } } ``` **解决方法**：避免将局部变量暴露给其他线程，或者在多线程环境中使用线程安全的数据结构[^1]。 #### 5. JVM 内存模型理解偏差 Java堆是JVM中最大的一块内存区域，用于存放对象实例，而局部变量通常存储在栈帧的局部变量表中。如果误以为局部变量存储在堆中，可能导致对其生命周期和访问方式的理解错误。 **解决方法**：明确区分堆和栈的作用，理解局部变量的生命周期仅限于当前方法调用范围内。 --- ### 示例代码：验证局部变量是否有效 ```java public class LocalVariableTest { public static void main(String[] args) { int a = 10; int b = 20; int c = 30; int d = 40; // slot_3 对应的是变量 c System.out.println("变量 c 的值：" + c); } } ``` --- ###
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值