C/C++：多线程下使用dlopen、dlsym、dlclose装载动态库

最新推荐文章于 2024-04-23 23:48:36 发布

test1280

最新推荐文章于 2024-04-23 23:48:36 发布

阅读量5.3k

点赞数 2

分类专栏： C-C++ Linux 算法文章标签：多线程 pthread 多线程使用 dlopen 卸载动态库

本文为博主原创文章，未经博主允许不得转载。

本文链接：https://blog.csdn.net/test1280/article/details/78306655

版权

Linux 同时被 3 个专栏收录

124 篇文章 3 订阅

订阅专栏

C-C++

97 篇文章 7 订阅

订阅专栏

算法

17 篇文章 0 订阅

订阅专栏

C/C++：多线程下使用dlopen、dlsym、dlclose装载动态库

当在多线程下dlopen同一个动态库，使用的会是同一个动态库实例还是不同的动态库实例呢？

count.h

#ifndef _COUNT_H
#define _COUNT_H

#include <pthread.h>

int count;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;


int get();
void inc();

#endif

count.c

#include "count.h"

int get()
{
    return count;
}

void inc()
{
    pthread_mutex_lock(&mutex);
    count++;
    pthread_mutex_unlock(&mutex);
}

编译生成libcount.so

main.c

#include <stdio.h>
#include <dlfcn.h>
#include <pthread.h>

#define NUM 1000 
#define LIBPATH "/home/test1280/libcount.so"

static const char *threadA = "Thread-A";
static const char *threadB = "Thread-B";

void *ThreadRun(void *arg)
{
    usleep(500*1000);
    printf("Start:%s\n", (char *)arg);

    void *handler = dlopen(LIBPATH, RTLD_LAZY);
    if (handler == NULL)
    {
        printf("ERROR:%s:dlopen\n", dlerror());
    }

    void (*inc)() = (void (*)())dlsym(handler, "inc");
    if (inc == NULL)
    {
        printf("ERROR:%s:dlsym\n", dlerror());
    }

    int i = 0;
    for (; i < NUM; i++)
    {
        inc();
    }

    int (*get)() = (int (*)())dlsym(handler, "get");
    if (get == NULL)
    {
        printf("ERROR:%s:dlsym\n", dlerror());
    }
    printf("INFO:%s:get() return %d\n", (char *)arg, get());

    dlclose(handler);
}

int main()
{
    pthread_t tid1;
    pthread_t tid2;

    pthread_create(&tid1, NULL, ThreadRun, (void *)threadA);
    printf("create Thread-A OK!!!\n");
    pthread_create(&tid2, NULL, ThreadRun, (void *)threadB);
    printf("create Thread-B OK!!!\n");

    while (1);

    return 0;
}

[test1280@localhost ~]$ gcc -o main main.c -ldl -lpthread

[test1280@localhost ~]$ ./main
create Thread-A OK!!!
create Thread-B OK!!!
Start:Thread-A
INFO:Thread-A:get() return 1000
Start:Thread-B
INFO:Thread-B:get() return 1000
^C

这么看来同一进程实体不同线程dlopen相同的库会得到不同的实例？

一个动态库会在同一进程同一时刻同时被加载多次？

当然不对啦！

那按照我们期待的，希望输出的最后的值应该是2000，那为何是1000呢？

原因：

线程A或者线程B跑的太快了，在一个时间片内就已经做完：
1.装载动态库到当前进程；
2.获得函数地址；
3.调用inc指定次数；
4.输出get返回值；
5.dlclose卸载动态库；

注意：

dlclose时，此时此刻可能仅仅只有一个线程在跑着，另一个线程还没有dlopen那个动态库，此时只有一个线程持有libcount.so的句柄，然后做完所有操作，dlclose，发现对库的引用减少至0，就将libcount.so从当前进程卸载；

然后呢，就是另一个线程在跑，再打开dlopen同一个动态库，然后里面的全局变量（库内全局）静态初始化为0，然后inc，然后…

结果很明显：是由于某个线程跑的太快，导致另一个线程还没有执行dlopen时，前一个进程已经做完所有活了（包括卸载libcount.so库），当另一个线程执行dlopen时，完全不知道这个库曾经被加载到当前进程…于是库中全局变量又静态初始化…

这样的时序看来，输出两个1000合情合理.

如何验证我们刚刚说的时序呢？

修改下main.c：

#include <stdio.h>
#include <dlfcn.h>
#include <pthread.h>

#define NUM 1000 
#define LIBPATH "/home/test1280/libcount.so"

static const char *threadA = "Thread-A";
static const char *threadB = "Thread-B";

static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void *ThreadRun(void *arg)
{
    usleep(500*1000);
    printf("Start:%s\n", (char *)arg);

    void *handler = dlopen(LIBPATH, RTLD_LAZY);
    if (handler == NULL)
    {
        printf("ERROR:%s:dlopen\n", dlerror());
    }

    void (*inc)() = (void (*)())dlsym(handler, "inc");
    if (inc == NULL)
    {
        printf("ERROR:%s:dlsym\n", dlerror());
    }

    int i = 0;
    for (; i < NUM; i++)
    {
        inc();
    }

    int (*get)() = (int (*)())dlsym(handler, "get");
    if (get == NULL)
    {
        printf("ERROR:%s:dlsym\n", dlerror());
    }
    printf("INFO:%s:get() return %d\n", (char *)arg, get());

    pthread_mutex_lock(&mutex);
    dlclose(handler);
    printf("INFO:lib unload && %s END...\n", (char *)arg);
    pthread_mutex_unlock(&mutex);
}

int main()
{
    pthread_t tid1;
    pthread_t tid2;

    pthread_create(&tid1, NULL, ThreadRun, (void *)threadA);
    printf("create Thread-A OK!!!\n");
    pthread_create(&tid2, NULL, ThreadRun, (void *)threadB);
    printf("create Thread-B OK!!!\n");

    while (1);

    return 0;
}

[test1280@localhost ~]$ gcc -o main main.c -ldl -lpthread
[test1280@localhost ~]$ ./main
create Thread-A OK!!!
create Thread-B OK!!!
Start:Thread-A
INFO:Thread-A:get() return 1000
INFO:lib unload && Thread-A END...
Start:Thread-B
INFO:Thread-B:get() return 1000
INFO:lib unload && Thread-B END...
^C

另外，我想看看两个线程对同一个库实例进行操作是什么效果…？

我们只要让两个线程同时（同一时刻）对一个库保持打开状态即可（不dlclose）：

将ThreadRun中最后的dlclose删除，如下main.c所示：

void *ThreadRun(void *arg)
{
    usleep(500*1000);
    printf("Start:%s\n", (char *)arg);

    void *handler = dlopen(LIBPATH, RTLD_LAZY);
    if (handler == NULL)
    {
        printf("ERROR:%s:dlopen\n", dlerror());
    }

    void (*inc)() = (void (*)())dlsym(handler, "inc");
    if (inc == NULL)
    {
        printf("ERROR:%s:dlsym\n", dlerror());
    }

    int i = 0;
    for (; i < NUM; i++)
    {
        inc();
    }

    int (*get)() = (int (*)())dlsym(handler, "get");
    if (get == NULL)
    {
        printf("ERROR:%s:dlsym\n", dlerror());
    }
    printf("INFO:%s:get() return %d\n", (char *)arg, get());

    //delete...
    //dlclose(handler);
}

[test1280@localhost ~]$ ./main
create Thread-A OK!!!
create Thread-B OK!!!
Start:Thread-A
INFO:Thread-A:get() return 1000
Start:Thread-B
INFO:Thread-B:get() return 2000
^C