【Linux】线程控制分析：如何获取线程ID？线程如何自动回收？

最新推荐文章于 2024-05-01 15:13:50 发布
最新推荐文章于 2024-05-01 15:13:50 发布
阅读量1.6k 收藏 4
点赞数 1
分类专栏： Linux-系统编程 文章标签： linux c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dxyt2002/article/details/130172598
版权

Linux系统中, 线程是轻量级的进程. 我们已经介绍过了线程的相关概念, 见过了线程再Linux操作系统中的存在形式.

我们知道, 进程有自己相关控制接口, 等待、创建等

而线程作为轻量级的进程, 其实也是有控制接口的.

文章目录

线程控制

在介绍线程的相关概念的时候, 我们简单的演示了一下, 线程的创建和回收. 以及使用ps命令 展示了操作系统中正在运行的线程.

线程的创建与回收演示

使用 pthread_create() 和 pthread_join() 两个接口来创建和回收线程已经演示过了：

#include <iostream>
#include <string>
#include <pthread.h>
#include <unistd.h>
using std::cout;
using std::endl;
using std::string;

void* callBack1(void* args) {
    string str = (char*)args;
    while (true) {
        cout << str << ": " << getpid() << " " << endl;
        sleep(1);
    }
}

int main() {
    pthread_t tid1;

    pthread_create(&tid1, nullptr, callBack1, (void*)"thread_1");

    while (true) {
        cout << " 主线程运行: " << getpid() << " " << endl;
        sleep(1);
    }

    pthread_join(tid1, nullptr);

    return 0;
}

|wide

这段代码的执行结果, 是两个线程同时运行.

pthread_create() 的使用并不复杂, 只需要接收线程id, 并指定线程需要执行的回调函数 和 参数就可以了.

而pthread_join() 这个回收线程的函数也不复杂. 只不过 此函数的第二个参数是一个 二级指针.

int pthread_join(pthread_t thread, void** retval);

void** retval 参数是一个输出型参数, 是用来接收数据的.

不过为什么, retval是一个二级指针的类型呢？

其实原因很简单, 因为我们在使用 pthread_create() 接口创建线程的时候, 给线程指定的回调函数的返回值是 void* 类型的.

而 pthread_join() 的作用是回收线程, 既然要回收线程那么就一定要接收到线程运行的结果, 即 需要接收 线程执行的回调函数的返回值.

函数的参数要接收一个指针类型的内容, 就是要用二级指针来接收.

即, pthread_join() 接口的第二个参数, 实际上可以接收线程执行的回调函数的返回值.

我们可以使用下面这段代码测试一下：

#include <iostream>
#include <string>
#include <pthread.h>
#include <unistd.h>
using std::cout;
using std::endl;
using std::string;

void* callBack1(void* args) {
    string str = (char*)args;
    int cnt = 5;
    while (cnt) {
        cout << str << ": " << getpid() << " " << endl;
        sleep(1);
        cnt--;
    }

    return (void*)"thread_1 is over";
}

int main() {
    pthread_t tid1;

    pthread_create(&tid1, nullptr, callBack1, (void*)"thread_1");

    void* ret = nullptr;
    pthread_join(tid1, &ret);

    cout << "main thread join thread_1 , ready to print thread_1 ret" << endl; 

    sleep(2);
    cout << (char*)ret << endl;
    
    return 0;
}

这段代码的执行结果是：

thread_join_retval

可以看到, 我们输出传入 join接口的参数, 得到的结果是 thread_1 执行的回调函数的返回值.

pthread_create() 和 pthread_join() 这两个接口的使用都不算困难.

其实这两个接口都不是系统调用, 而是第三方库 pthread 中的接口. 不过虽然他们不是系统调用, 却胜似系统调用. 因为 Linux中其实是必须装载这个库的.

这两个不是系统调用, Linux操作系统提供的真正的系统调用是什么呢？

Linux操作系统的线程是轻量级进程, 也就是说 Linux其实并没有提供创建线程的系统调用, 因为根本就没有独立的线程这个概念.

所以, Linux操作系统给我们提供的创建线程的系统调用接口：

vfork():

这个系统调用接口是用来创建与父进程共享进程地址空间的子进程的, 其实就是一个线程.

clone():

还有clone() 系统调用. 这个接口作用是创建一个子进程来模拟线程.

不过看参数就可以看出来这个函数, 太麻烦了！

还需要自己定义方法, 自己定义一个子进程的栈(线程栈)等内容.

这个接口是为了更加细粒度的定制创建一个线程. 就是太麻烦了. 非常的麻烦. 看看就好.

我们更常用的还是 pthread库中的接口, pthread_create等

获取线程id

pthread_create() 接口的第一个参数是一个输出型参数, 其实就是为了接收线程id的.

也就是说, 创建完线程之后 其实就已经得到了创建的线程的id：

#include <iostream>
#include <string>
#include <pthread.h>
#include <unistd.h>
using std::cout;
using std::endl;
using std::string;

void* callBack1(void* args) {
    string str = (char*)args;
    int cnt = 5;
    while (cnt) {
        cout << str << ": " << getpid() << " " << endl;
        sleep(1);
        cnt--;
    }

    return (void*)"thread_1 is over";
}

int main() {
    pthread_t tid1;

    pthread_create(&tid1, nullptr, callBack1, (void*)"thread_1");

    cout << "thread_1 id: " << tid1 << endl;

    while (true) {
        cout << " 主线程运行: " << getpid() << " " << endl;
        sleep(1);
    }

    return 0;
}

thread_id

代码的执行结果显示, 线程的id是一个非常长的数值. 我们暂时不考虑其有什么含义.

上面这种方法是通过创建线程时接收到的id 来获取线程id.

除此之外, pthread 还提供了一个获取线程自己id的接口: pthread_self()

pthread_self() 获取线程id

此接口作用是：获取调用此接口的线程的ID, 并作为返回值返回.

那么, 我们就可以定义一个函数, 来输出哪个线程和此线程的ID.

#include <iostream>
#include <string>
#include <pthread.h>
#include <unistd.h>
using std::cout;
using std::endl;
using std::string;

void printTid(const char* threadName, const pthread_t &tid) {
    cout << threadName << " is runing, " << "tid: " << tid << endl;
}

void* callBack1(void* args) {
    char* threadName = (char*)args;
    int cnt = 5;
    while (cnt) {
        printTid(threadName, pthread_self());
        sleep(1);
        cnt--;
    }

    return (void*)"thread_1 is over";
}

int main() {
    pthread_t tid1;

    pthread_create(&tid1, nullptr, callBack1, (void*)"thread_1");

    while(true) {
        cout << "主线程运行: " << getpid() << endl;
        sleep(1);
    }

    pthread_join(tid1, nullptr);

    return 0;
}

代码的执行结果为：

pthread_self

线程成功获取了自己的ID

线程的状态

Linux中 不能使用ps像查看进程状态那样细致的查看线程的状态.

不过还是可以简单的判断一下的.

对于线程, 如果线程退出了但是没有回收, 线程会怎么样呢？

#include <iostream>
#include <string>
#include <pthread.h>
#include <unistd.h>
using std::cout;
using std::endl;
using std::string;

void printTid(const char* threadName, const pthread_t &tid) {
    cout << threadName << " is runing, " << "tid: " << tid << endl;
}

void* callBack1(void* args) {
    char* threadName = (char*)args;
    int cnt = 5;
    while (cnt) {
        printTid(threadName, pthread_self());
        sleep(1);
        cnt--;
    }
    cout << "thread_1 is over" << endl;

    int* ret = new int(123);
    return (void*)ret;				// 返回一个堆区数据 123
}

int main() {
    pthread_t tid1;

    pthread_create(&tid1, nullptr, callBack1, (void*)"thread_1");
    
    sleep(15);  // 等15s，让thread_1运行完

    void* ret = nullptr;
    pthread_join(tid1, &ret);
    cout << "main thread join thread_1 , ready to print thread_1 ret" << endl;
    
    sleep(2);

    cout << "print thread_1 ret: " << *((int*)ret) << endl;
    delete (int*)ret; 		// 释放堆区数据

    return 0;
}

我们可以使用命令行监控脚本, 然后在执行这段代码.

// 监控线程脚本
while :; do ps -aL |head -1 && ps -aL |grep myThread |grep -v grep; sleep 1; done;

线程退出之后, 但还未join

执行和监控结果是, 当线程退出但还未被回收时, 线程会立刻从ps打印的列表中消失.

这说明什么呢？能说明 线程会被操作系统自动回收, 我们不用join吗？

不能, 因为ps终究只是一个软件. 没有证据可以证明 线程退出之后会被立刻回收, 不用手动回收.

事实也的确如此, 线程退出之后, 并不是自动回收的, 如果不手动join, 就可能会造成类似进程不回收一般的内存泄漏问题

线程与进程共享信号处理方法

线程和进程是共享信号处理方法的. 这个概念在上一篇线程概念的文章中就已经提到过, 但是没有演示.

在本篇文章中, 我们可以演示一下这个特点.

#include <iostream>
#include <string>
#include <pthread.h>
#include <unistd.h>
using std::cout;
using std::endl;
using std::string;

void printTid(const char* threadName, const pthread_t &tid) {
    cout << threadName << " is runing, " << "tid: " << tid << endl;
}

void* callBack1(void* args) {
    char* threadName = (char*)args;
    while (true) {
        printTid(threadName, pthread_self());s
        sleep(1);
     }
}

int main() {
    pthread_t tid1;

    pthread_create(&tid1, nullptr, callBack1, (void*)"thread_1");

    while(true) {
        printTid("main thread", pthread_self());
        sleep(1);
    }
}

线程和进程接收信号相同状态

我们向进程发送19信号, 所有线程都会暂停运行.

我们向进程发送一个18信号, 所有线程又会恢复运行.

ps列表中, 表示进程状态的一栏 l 即表示 存在轻量化进程, 即多线程进程

+ 表示前台进程

线程异常

线程异常会影响整个进程, 原因是线程异常影响的是整个进程的代码和数据.

所以, 如果线程异常 则整个进程都会异常

#include <iostream>
#include <string>
#include <pthread.h>
#include <unistd.h>
using std::cout;
using std::endl;
using std::string;

void printTid(const char* threadName, const pthread_t &tid) {
    cout << threadName << " is runing, " << "tid: " << tid << ", pid: " << getpid() << endl;
}

void* callBack1(void* args) {
    char* threadName = (char*)args;
    int cnt = 5;
    while (true) {
        printTid(threadName, pthread_self());
        sleep(1);
        cnt--;
        if(cnt == 0) {
            int i = 1;
            i /= 0;
            // 段错误
            //int* pi = nullptr;
            //*pi = 123;
        }
     }
}

int main() {
    pthread_t tid1;

    pthread_create(&tid1, nullptr, callBack1, (void*)"thread_1");

    while(true) {
        printTid("main thread", pthread_self());
        sleep(1);
    }
    return 0;
}

线程浮点异常

线程发生段错误

当线程出现不同的异常, 会影响进程的终止.

这其实是线程的 健壮性较低

不过这其实还是因为出bug了.

线程退出

介绍进程时, 我们分析进程退出存在三种情况：

  1. 代码跑完, 结果正确, 正常退出
  2. 代码跑完, 结果不正确, 正常退出
  3. 代码没跑完, 进程异常退出

其实线程也是一样的, 线程退出也分为这三种.

其实, 这三种情况可以统称为 执行流的退出情况

在父子进程中, 子进程退出不论是正常退出还是异常退出, 都会向父进程发送退出信息.

而 线程中, 只有线程正常退出且回收时, 主线程可以接收到线程的退出信息.

那么, 为什么线程异常时 主线程不会接收到来自线程的退出信息？

答案其实很简单, 因为线程异常, 也就是进程异常, 进程也会随之退出. 接不接受线程的退出信息已经没有意义了

以正常退出的情况来说, 除了回调函数内 return.

线程退出还可以使用接口退出.

pthread_exit()

pthread_exit() 接口也是 pthread 库提供的, 作用就是 以指定的退出信息使线程退出.

#include <iostream>
#include <string>
#include <pthread.h>
#include <unistd.h>
using std::cout;
using std::endl;
using std::string;

void printTid(const char* threadName, const pthread_t &tid) {
    cout << threadName << " is runing, " << "tid: " << tid << ", pid: " << getpid() << endl;
}

void* callBack1(void* args) {
    char* threadName = (char*)args;
    int cnt = 5;
    while (true) {
        printTid(threadName, pthread_self());
        sleep(1);
        cnt--;
        if(cnt == 0) {
            pthread_exit((void*)123);
        }
     }
}

int main() {
    pthread_t tid1;

    pthread_create(&tid1, nullptr, callBack1, (void*)"thread_1");
    sleep(10);

    void* ret = nullptr;
    pthread_join(tid1, &ret);
    cout << "main thread join thread_1 , ready to print thread_1 ret" << endl;
    sleep(2);
    cout << "print thread_1 ret: " << (long long)ret << endl;
    
    return 0;
}

线程退出

pthread_cancel()

pthread_cancel() 接口可以向指定的线程发送取消请求.

此接口可以**同一进程内, 任意线程调用并向任意线程发送**. 即, 可以在主线程中调用向新线程发送请求. 也可以自己想自己发送请求

并且, 如果线程是被取消的, 那么此线程的退出信息就是-1.

#include <iostream>
#include <string>
#include <pthread.h>
#include <unistd.h>
using std::cout;
using std::endl;
using std::string;

void printTid(const char* threadName, const pthread_t &tid) {
    cout << threadName << " is runing, " << "tid: " << tid << ", pid: " << getpid() << endl;
}

void* callBack1(void* args) {
    char* threadName = (char*)args;
    int cnt = 5;
    while (true) {
        printTid(threadName, pthread_self());

        sleep(1);
        cnt--;
        if(cnt == 0) {
            pthread_exit((void*)123);
        }
     }
}

int main() {
    pthread_t tid1;

    pthread_create(&tid1, nullptr, callBack1, (void*)"thread_1");
    sleep(2);
	 pthread_cancel(tid1); 						// 主线程向新线程发送取消请求
   	cout << "main thread cancel thread_1" << endl;

    void* ret = nullptr;
    pthread_join(tid1, &ret);
    cout << "main thread join thread_1 , ready to print thread_1 ret" << endl;
    sleep(2);
    cout << "print thread_1 ret: " << (long long)ret << endl;

    return 0;
}

首先是, 主线程向新线程发送取消请求：

主线程向新线程发送取消请求

新线程被取消 退出, 退出信息为-1. 即为 取消退出.

即 主线程是可以向新线程发送取消信号的. 但是 有可能发生错误.

我们上述代码中, 向新线程发送取消信号的动作 是在创建新线程2s之后执行的.

如果将那2s的暂停取消(主线程中, cancel动作前的 sleep(2))：

主线程向新线程发送取消请求, 出现错误

可以发现, 线程、进程都不正常的退出了.

同一进程内的所有线程都可以调用pthread_cancel()像任意线程发送取消信号.

甚至可以向主线程发送取消信号. 线程自己也可以向自己发送取消信号.

可以自己去测试一下.

被取消的线程的退信息

当线程被成功的取消, 我们用 pthread_join() 接收线程的退出信息. 结果得到的退出信息是-1

那, 这个-1是从哪里来的呢？

我们知道, Linux中线程是由PCB模拟实现的, PCB中维护的都有自己执行流的退出信息.

我们return也好 或者 调用pthread_exit() 也好, 实际上都会修改PCB中维护的退出信息.

而pthread_cancel() 也是如此, 如果取消线程成功了, 操作系统就会修改线程PCB中的退出信息.

将退出信息改为 PTHREAD_CANCELED . 这是一个 pthread 库提供的宏, 其实就是 ((void*)-1) 的宏定义：

|wide

线程分离

操作系统中的线程, 在默认情况下是 joinable 的.

即, 线程退出之后 是需要调用 pthread_join 进行接收线程信息和资源回收的, 否则可能会造成内存泄漏问题.

不过, 如果一个线程不需要关心返回值, 如果不是需要回收资源, 其实 join 的必要没有那么大.

那么, 对于不关心返回值的线程, 可否不用 join回收资源, 可否让线程自动回收资源呢？

是可以的. 这样的操作叫 线程分离

pthread_detach()

此接口的作用, 其实可以理解为 将线程与主线程分离. 即 主线程不在管这个线程, 主线程也就不关心退出信息, 不关心资源回收.

这个接口一般线程自己调用或主线程调用.

不过, joinable 和 分离 是冲突的. 毕竟 joinable 表示线程需要调用join回收, 分离线程 则表示此线程是自动回收的. 很明显是两个冲突的状态

线程join成功

这是线程被正常join的现象.

如果我们设置分离：

#include <iostream>
#include <cstring>
#include <string>
#include <pthread.h>
#include <unistd.h>
using std::cout;
using std::endl;
using std::string;

void printTid(const char* threadName, const pthread_t& tid) {
    printf("%s is runing, tid: %lu, pid: %d\n", threadName, tid, getpid());
}

void* startRoutine(void* args) {
    pthread_detach(pthread_self());			// 线程分离
    string name = (char*)args;
    int cnt = 1;
    while (cnt--) {
        printTid(name.c_str(), pthread_self());
        sleep(1);
    }
    printf("%s is over\n", name.c_str());

    return nullptr;
}

int main() {
    pthread_t tid1, tid2, tid3, tid4;

    pthread_create(&tid1, nullptr, startRoutine, (void*)"thread_1");
    pthread_create(&tid2, nullptr, startRoutine, (void*)"thread_2");
    pthread_create(&tid3, nullptr, startRoutine, (void*)"thread_3");
    pthread_create(&tid4, nullptr, startRoutine, (void*)"thread_4");

    sleep(2);

    int joinRet = pthread_join(tid1, nullptr);
    cout << strerror(joinRet) << endl;
    joinRet = pthread_join(tid2, nullptr);
    cout << strerror(joinRet) << endl;
    joinRet = pthread_join(tid3, nullptr);
    cout << strerror(joinRet) << endl;
    joinRet = pthread_join(tid4, nullptr);
    cout << strerror(joinRet) << endl;

    return 0;
}

上面的这段代码, 在线程需要执行的回调函数内 调用pthread_detach(pthread_self());将线程自己分离, 然后主线程内依旧使用 pthread_join() 回收. 不过接收返回值, 判断join执行的结果：

分离和joinable状态不可共存

可以看到, 主线程中的 pthread_join() 并没有成功的将4个线程回收掉. 而是报出了 Invalid argument 无效参数 的错误.

这其实就意味着, 分离过的线程 在运行结束之后就自动被回收了, 无法再用 pthread_join() 回收.

上面举得例子是正确使用的情况.

如果, 我们将主线程中的 sleep(2); 语句删除了, 并且我们只创建、回收一个线程：

#include <iostream>
#include <cstring>
#include <string>
#include <pthread.h>
#include <unistd.h>
using std::cout;
using std::endl;
using std::string;

void printTid(const char* threadName, const pthread_t& tid) {
    printf("%s is runing, tid: %lu, pid: %d\n", threadName, tid, getpid());
}

void* startRoutine(void* args) {
    pthread_detach(pthread_self());
    string name = (char*)args;
    int cnt = 1;
    while (cnt--) {
        printTid(name.c_str(), pthread_self());
        sleep(1);
    }
    printf("%s is over\n", name.c_str());

    return nullptr;
}

int main() {
    pthread_t tid1;

    pthread_create(&tid1, nullptr, startRoutine, (void*)"thread_1");

    int joinRet = pthread_join(tid1, nullptr);
    cout << strerror(joinRet) << endl;

    return 0;
}

我们依旧在 回调函数内将线程分离, 那么这段代码的执行结果是：

分离了, 但是join执行成功

惊奇的发现, 线程退出之后成功得被 join 回收了.

这是什么原因？我们不是在线程内分离线程了吗？

其实是因为, 在主线程内 我们创建了线程之后 没有使主线程暂停一会, 直接就继续执行了 pthread_join(). 线程还没来得及 将自己分离.

所以线程退出时, 又会被主线程中的 pthread_join() 回收成功

要避免这种情况, 可以在创建线程之后将主线程等一会, 让新线程执行完分离再让主线程继续执行.

或者, 可以直接在主线程内将线程分离.

#include <iostream>
#include <cstring>
#include <string>
#include <pthread.h>
#include <unistd.h>
using std::cout;
using std::endl;
using std::string;

void printTid(const char* threadName, const pthread_t& tid) {
    printf("%s is runing, tid: %lu, pid: %d\n", threadName, tid, getpid());
}

void* startRoutine(void* args) {
    string name = (char*)args;
    int cnt = 1;
    while (cnt--) {
        printTid(name.c_str(), pthread_self());
        sleep(1);
    }
    printf("%s is over\n", name.c_str());

    return nullptr;
}

int main() {
    pthread_t tid1;

    pthread_create(&tid1, nullptr, startRoutine, (void*)"thread_1");
    pthread_detach(tid1);
    cout << "main thread detach thread_1" << endl;

    int joinRet = pthread_join(tid1, nullptr);
    cout << strerror(joinRet) << endl;
	
    sleep(5); 		// 防止主线程先退出
    
    return 0;
}

在主线程中分离线程

这样就可以解决 join 时, 新线程还未分离的问题.

线程分离之后, 主线程就不再管分离的线程了. 即使主线程先退出了, 也不会管分离的线程. 即主线程先退出, 被分离的线程可能还会运行.

所以, 存在线程被分离时, 我们的一般会将主线程不退出, 常驻内存

线程分离, 就像是给线程设置了一下让线程如何退出. 等线程执行完毕之后, 自动退出回收.

所以, 其实 线程分离也可以看作是线程的第四种退出方式, 延迟退出

第一种是, 回调函数返回

第二种是, pthread_exit()

第三种是, pthread_cancel()

到这里, 线程的概念和控制基本上介绍完了.

但是还有一个问题, 就是 如何理解线程id. 不过会是下一篇文章的内容.

感谢阅读~

七月.cc
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Linux多线程服务端编程：使用muduoC网络库
07-23
资源名称：Linux多线程服务端编程：使用muduo C 网络库资源截图： 资源太大，传百度网盘了，链接在附件中，有需要的同学自取。
c++ 获取线程id_高效获取当前线程的 id
热门推荐
weixin_39634132的博客
11-28 1万+
不同平台获取当前线程 id 的方法Windows可以利用微软提供的 api，轻松获取当前线程的 id：int LinuxLinux 平台一般用的是 pthread 线程库，但它并不提供获取线程内部 id 的方法。可以通过系统调用得到当前线程的 id：#include MacMac 平台也可以用 syscall 获取当前线程的 id，与 Linux 稍有区别：#include 不过在 mac os ...
Linux下获取线程id的方法总结
yinminsumeng的博客
04-21 3000
getpid()Linux系统调用，获取进程id，也是主线程id。gettid()Linux系统调用，获取线程id。C运行库没有封装这个接口…用syscall()方式调用。在主线程中，getpid = gettid。直接调用Linux系统调用（即上面的gettid）。pthread库函数，返回pthread中的线程id。这个id不同于gettid()的值。不同的实现可能返回不同的结果。使用这个函数，需要在编译时链接pthread库。
C++多线程：this_thread 命名空间
adminstate的博客
02-05 1151
C++11 多线程：this_thread 命名空间下的功能函数
linux 获取 当前线程id 和 当前线程名称
_
01-31 1116
linux 获取 当前线程id 和 当前线程名称。
C++笔记之获取线程ID以及线程ID的用处
小勇博客
10-14 1520
线程 ID 并不是直接用于线程同步的工具，而是用于标识不同的线程。在这种情况下，你可以使用线程 ID 来识别和区分不同的线程，并为它们分配不同的资源。线程同步是确保多线程程序安全运行的关键部分，使用线程 ID 和互斥锁可以帮助你实现正确的线程同步。这个示例使用线程 ID 辅助线程同步，但实际上线程同步可能涉及更复杂的逻辑和多个线程之间的交互，线程 ID 通常是用于确定特定线程的条件是否满足，从而执行或等待。在这个示例中，有四个线程执行任务，但奇数线程（线程1和线程3）被分配更多的计算资源。
linux命令如何查询某个线程,linux如何查看线程信息命令是什么
weixin_28772667的博客
04-29 2062
linux如何查看线程信息命令是什么？linux线程命令介绍。linux 查看线程信息在linux操作系统中可以使用ps -eLf命令来查看线程信息：下面的数据为db2数据库的db2sysc进程中所包括的线程：192.168.100.228 [sde ~]$ ps-eLf |grep db2sysc|grep -v grepUID PID PPID LWP C NLWP STIME TTY TIM...
获取线程 ID 和当前线程
实践求真知
02-19 3965
一 点睛 1 API // 获取线程唯一 ID public long getId() // 获取线程名称 public final String getName() // 当前执行线程的引用 public static native Thread currentThread() 2 说明 线程的 ID 在整个 JVM 进程中都会是唯一的，，并且从 0 开始逐次递增。 mian 线程的 getId() 并不等于0，这是因为在一个 JVM 进程启动的时候，实际上是开辟了很多个线程，自增序列已经有了一
Linux系统编程-线程：线程号
qq_33300585的博客
07-31 803
Linux系统编程-线程：线程号
linux中查询对应线程的线程id
YGG12022的博客
04-21 1149
linux中查询对应线程的线程id
【Linux】获取线程ID方法
sidemap的博客
06-06 2654
thread
java线程池:获取运行线程数并控制线程启动速度的方法
08-30
下面小编就为大家带来一篇java线程池:获取运行线程数并控制线程启动速度的方法。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Linux线程管理必备：互斥量与条件变量
01-09
而互斥量与条件变量在线程管理中必不可少，任务间的调度几乎都是由互斥量与条件变量控制。互斥量的实现与进程中的信号量（无名信号量）是类似的，当然，信号量也可以用于线程，区别在于初始化的时候，其本质都是P/V...
多线程编程之：Linux线程编程
08-02
这里要讲的线程相关操作都是用户空间中的线程的操作。在Linux中，一般pthread线程库是一套通用的线程库，是由POSIX提出的，因此具有很好的可移植性。
详解Linux获取线程的PID（TID、LWP）的几种方式
09-14
主要介绍了详解Linux获取线程的PID（TID、LWP）的几种方式，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
『Linux』 第一章 基本操作指令（上）
m0_54443558的博客
04-28 886
Linux 基本指令
linux-journal日志文件特别大怎么办，journal日志文件学习
你是我的天晴
04-28 210
今天发现磁盘容量不多了，就去清理磁盘，发现这个文件特别大：journal，特此来学习下。
Linux：浏览器访问网站的基本流程（优先级从先到后）
fox_kang的博客
04-28 677
浏览器访问网站的基本流程（优先级从先到后） 首先查找浏览器是否存在该网站的访问缓存 其次查找本机的域名解析服务器 windows：C:\Windows\System32\drivers\etc\hosts Linux：/etc/hosts 使用外部的域名解析服务器解析（例如：114.114.114.114） 第一步：浏览器使用域名访问www.bilibili.com.网站 第二步：首先去访问根域名解析服务器查询，根服务器返回.com域名解析服务器地址==（这里的根域名解析服务器不会直接给出域名对应的
Linux 第十八章
最新发布
一怀明月的博客
05-01 874
程序地址空间 区间的地址分布 真正理解同一个地址进行读取不同内容 地址空间 虚拟地址和物理地址 虚拟地址： 物理地址： struct mm_struct 页表
linux 获取线程id
05-19
在 Linux 中，获取线程 ID 的方法取决于你使用的编程语言和库。以下是一些常用语言和库的示例： 1. C 语言中使用 pthread 库创建线程，可以使用 pthread_self() 函数获取当前线程的 ID。示例代码如下： ``` #...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

七月.cc

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值