当前位置：网站首页>Problem solving: how to manage thread_local pointer variables

Problem solving: how to manage thread_local pointer variables

2022-07-01 00:43:00 【51CTO】

introduction

The problem arises when implementing a function of the project , I need a thread_local The pointer to , Because the whole project has almost been realized , But in the end, I found the problem of memory leakage . Because it implements a library that is biased towards the bottom , And the use of memory is basically under control , So at the beginning of the project implementation, smart pointers were not used for efficiency , But later, there was a memory leak problem here .

The original code is almost like this ：

       
       __thread 
       
       Co_Rountinue_Env
       
       * 
       
       CurrentThread_CoEnv 
       
       = 
       
       nullptr;
      
1.

In this way, it is difficult to release the thread after it ends , So we need to think of a way to do this , And don't want to change the original code on a large scale , The final solution is ：

       
       __thread 
       
       Co_Rountinue_Env
       
       * 
       
       CurrentThread_CoEnv 
       
       = 
       
       nullptr;
       
       thread_local 
       
       std::unique_ptr
       
       <
       
       Co_Rountinue_Env, 
       
       decltype(
       
       Free_Co_Rountinue_Env)
       
       *>
       
       DeleteThread_CoEnv(
       
       CurrentThread_CoEnv, 
       
       Free_Co_Rountinue_Env);
      
1.
2.
3.
4.

Don't worry about variable names , The basic idea is to use smart pointers to manage memory , Let's look at a simulated small demo：

       
       #include <bits/stdc++.h>
       
       #include <unistd.h>
       
       using 
       
       namespace 
       
       std;
       
       void 
       
       Delete_(
       
       int
       
       * 
       
       para){
       
       if(
       
       para 
       
       == 
       
       nullptr) 
       
       return;
       
       cout 
       
       << 
       
       "nihao\n";
       
       delete 
       
       para;
       
       return;
       
}
       
       thread_local 
       
       int
       
       * 
       
       env 
       
       = 
       
       nullptr;
       
       thread_local 
       
       std::unique_ptr
       
       <
       
       int, 
       
       decltype(
       
       Delete_)
       
       *>
       
       Env(
       
       env, 
       
       Delete_);
       
       void
       
       * 
       
       Routine(
       
       void
       
       * 
       
       para){
       
       Env.
       
       reset();
       
       env 
       
       = 
       
       new 
       
       int(
       
       5);
       
       Env.
       
       reset(
       
       env);
       
       cout 
       
       << 
       
       " End of the function \n";
       
       return 
       
       0;
       
}
       
       int 
       
       main(){
       
       pthread_t 
       
       tid[
       
       5];
       
       for(
       
       size_t 
       
       i 
       
       = 
       
       0; 
       
       i 
       
       < 
       
       2; 
       
       i
       
       ++){
       
       pthread_create(
       
       tid 
       
       + 
       
       i, 
       
       nullptr, 
       
       Routine, 
       
       0);
       
    }
       
       for(
       
       size_t 
       
       i 
       
       = 
       
       0; 
       
       i 
       
       < 
       
       2; 
       
       i
       
       ++){
       
       pthread_join(
       
       tid[
       
       i], 
       
       nullptr);
       
    }
       
       sleep(
       
       1);
       
       return 
       
       0;
       
}
      
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.

Output ：

       
        End of the function 
       
       nihao
       
        End of the function 
       
       nihao
      
1.
2.
3.
4.

In this way, the expectation is achieved .

In the process of solving the problem, I also found boost There is also a gadget in the library that can do this , namely boost::thread_specific_ptr, Its function is to store per thread , And it will execute the preset callback when the thread ends , It is similar to a special smart pointer , Let's see how it works ：

       
       #include <bits/stdc++.h>
       
       #include <boost/thread/tss.hpp>
       
       #include <unistd.h>
       
       using 
       
       namespace 
       
       std;
       
       void 
       
       Delete_(
       
       int
       
       * 
       
       para){
       
       if(
       
       para 
       
       == 
       
       nullptr) 
       
       return;
       
       cout 
       
       << 
       
       "nihao\n";
       
       delete 
       
       para;
       
       return;
       
}
       
       boost::thread_specific_ptr
       
       <
       
       int
       
       > 
       
       env {
       
       &
       
       Delete_};
       
       void
       
       * 
       
       Routine(
       
       void
       
       * 
       
       para){
       
       if(
       
       !
       
       env.
       
       get()){
       
       env.
       
       reset(
       
       new 
       
       int(
       
       5));
       
    }
       
       cout 
       
       << 
       
       *
       
       env 
       
       << 
       
       endl;
       
       cout 
       
       << 
       
       " End of the function \n";
       
       return 
       
       0;
       
}
       
       int 
       
       main(){
       
       pthread_t 
       
       tid[
       
       5];
       
       for(
       
       size_t 
       
       i 
       
       = 
       
       0; 
       
       i 
       
       < 
       
       2; 
       
       i
       
       ++){
       
       pthread_create(
       
       tid 
       
       + 
       
       i, 
       
       nullptr, 
       
       Routine, 
       
       0);
       
    }
       
       for(
       
       size_t 
       
       i 
       
       = 
       
       0; 
       
       i 
       
       < 
       
       2; 
       
       i
       
       ++){
       
       pthread_join(
       
       tid[
       
       i], 
       
       nullptr);
       
    }
       
       sleep(
       
       1);
       
       return 
       
       0;
       
}
      
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.

Execute the following command ：

       
       g
       
       ++ 
       
       XXX.
       
       cpp 
       
       -
       
       pthread 
       
       -
       
       lboost_system 
       
       -
       
       lboost_thread
       
.
       
       /
       
       a.
       
       out
      
1.
2.

We can put thread_specific_ptr Use as a normal pointer , Because there are not many member functions , Compared with the smart pointer, it can be said that one sky and one earth . Remove the output for the pointer value , We can see that other outputs are the same ：

       
       5
       
        End of the function 
       
       nihao
       
       5
       
        End of the function 
       
       nihao
      
1.
2.
3.
4.
5.
6.