Linux线程API使用与分析

转载作者：来者不拒更新时间：2024-01-31 10:46:58

线程是操作系统进程调度器可调度的最小粒度的执行单元。

执行ps -eLF查看线程。

UID          PID    PPID     LWP  C NLWP    SZ   RSS PSR STIME TTY          TIME CMD
root      103724  103680  103724  0   14 23667 40048   1 Jan24 ?        00:00:13 /root/.vscode-server/extensions/ms-vscode.cpptools-1.18.5-linux-arm64/bin/cpptools
root      103724  103680  103725  0   14 23667 40048   1 Jan24 ?        00:00:01 /root/.vscode-server/extensions/ms-vscode.cpptools-1.18.5-linux-arm64/bin/cpptools
root      103724  103680  103726  0   14 23667 40048   0 Jan24 ?        00:00:28 /root/.vscode-server/extensions/ms-vscode.cpptools-1.18.5-linux-arm64/bin/cpptools
root      103724  103680  103727  0   14 23667 40048   0 Jan24 ?        00:00:30 /root/.vscode-server/extensions/ms-vscode.cpptools-1.18.5-linux-arm64/bin/cpptools
root      103724  103680  103728  0   14 23667 40048   3 Jan24 ?        00:00:29 /root/.vscode-server/extensions/ms-vscode.cpptools-1.18.5-linux-arm64/bin/cpptools
root      103724  103680  103729  0   14 23667 40048   3 Jan24 ?        00:00:27 /root/.vscode-server/extensions/ms-vscode.cpptools-1.18.5-linux-arm64/bin/cpptools
root      103724  103680  103730  0   14 23667 40048   3 Jan24 ?        00:00:14 /root/.vscode-server/extensions/ms-vscode.cpptools-1.18.5-linux-arm64/bin/cpptools
root      103724  103680  103731  0   14 23667 40048   3 Jan24 ?        00:00:00 /root/.vscode-server/extensions/ms-vscode.cpptools-1.18.5-linux-arm64/bin/cpptools
root      103724  103680  103732  0   14 23667 40048   3 Jan24 ?        00:00:14 /root/.vscode-server/extensions/ms-vscode.cpptools-1.18.5-linux-arm64/bin/cpptools
root      103724  103680  103814  0   14 23667 40048   2 Jan24 ?        00:00:00 /root/.vscode-server/extensions/ms-vscode.cpptools-1.18.5-linux-arm64/bin/cpptools
root      103724  103680  103815  0   14 23667 40048   0 Jan24 ?        00:00:00 /root/.vscode-server/extensions/ms-vscode.cpptools-1.18.5-linux-arm64/bin/cpptools
root      103724  103680  103816  0   14 23667 40048   2 Jan24 ?        00:00:00 /root/.vscode-server/extensions/ms-vscode.cpptools-1.18.5-linux-arm64/bin/cpptools
root      103724  103680  103817  0   14 23667 40048   2 Jan24 ?        00:00:00 /root/.vscode-server/extensions/ms-vscode.cpptools-1.18.5-linux-arm64/bin/cpptools
root      103724  103680  403265  0   14 23667 40048   1 10:14 ?        00:00:00 /root/.vscode-server/extensions/ms-vscode.cpptools-1.18.5-linux-arm64/bin/cpptools

通过输出看到是cpptools的进程 103724，它拥有多个线程，LWP就是线程ID，第一行的LWP 103724 == PID，表明是该线程组的主线程。NLWP表示该线程组有多少个线程（14个）.

LWP，Light Weighted Process的缩写，Linux的线程实现是NPTL（Native Posix Thread Library），该模型下的线程被称为LWP，每一个用户态线程对应内核中的一个调度实体，拥有自己的task_struct。

空间布局

线程之间共享一份全局内存区域，包括初始化数据段、未初始化数据段（bss）、堆内存段。 Linux中通过pthread_create创建线程，glibc要为每个线程独立分配线程栈，线程栈位于mmap区（位于栈和堆的中间，从高地址向低地址延伸）.

API

使用pthread_*API时，编译和链接时加-pthread选项

线程创建 pthread_create

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
                          void *(*start_routine) (void *), void *arg);
// thread：指向ptrhead_t结构体地址的指针，后续的API调用都通过该地址来操作

// void *arg：是start_routine函数的参数指针，如果需要传入多个参数，将多个参数放入结构体，将
// 结构体地址传入

// attr: 设置进程属性，调度策略等。man pthread_attr_init查看更多

// 返回值：成功返回0，否则返回错误状态码（不是<=-1的返回值）
//		EAGAIN:超过进程能创建线程的限制
//		EINVAL:attr值非法
//		EPERM:没有权限设置attr的调度策略或参数

线程标识 pthread_self、pthread_equal

int pthread_equal(pthread_t t1, pthread_t t2);
// 相等返回非0，不相等返回0

pthread_t pthread_self(void);
// 返回调用线程的线程ID，上面说了NTPL实现中，这个ID是一个指向pthread_t结构体的指针

可以组合使用于特定的场景，比如:

主线程创建一个工作队列，再分配给线程池中的线程去处理工作，但是线程不可以自行从队列中争抢任务，由主线程将工作分配给特定的任务，主线程可以在每个任务中存储对应的线程ID
工作线程就可以通过这两个函数来确定是不是自己该处理的任务

线程退出

线程start_routine函数执行return 返回值;，例：return ((void *)1);，如果使用return，那么清理函数pthread_cleanup_push()和pthread_cleanup_pop()无效
线程start_routine函数执行pthread_exit()
其他线程通过pthread_cancel(pthread_t thread)取消线程，是一个请求，立即返回并不会等待指定线程退出，如果指定的thread可取消，那么其行为类似于thread调用了pthread_exit()，不建议使用

void pthread_exit(void *retval);

retval记录线程的退出信息，记录方式:

不可以使用线程局部变量，因为线程退出会释放栈，该变量会消失，等到其他线程用pthread_join()接收时已经不存在了。
pthread_exit(NULL)，仅退出，不返回信息
使用全局变量
将返回的信息定义在堆空间，malloc分配，堆空间不会随着线程退出被释放，使用完信息后切记释放该空间，否则memory leak
字符串常量

退出的清理工作

// 执行清理函数，清理函数保存在线程栈中，所以先注册的后执行
void pthread_cleanup_push(void (*routine)(void *), void *arg);

// 移除清理函数
void pthread_cleanup_pop(int execute);

// 他们总是成对出现

以下情况会触发pthread_cleanup_push调用routine:

调用pthread_exit()
响应其他线程的pthread_cancel()
用pthread_cleanup_pop(int execute)主动执行，需要指定execute为非0

连接（释放）线程

join其他线程的时候会调用__nptl_free_tcb (pd);释放退出线程的资源。但是NPTL模型会缓存该线程的内存地址，并不会立即munmap，后创建的线程会复用这块内存地址，避免了频繁的mmap和munmap，所以:

使用pthread_join连接退出线程，后面启动的线程会复用前面joined栈内存空间。
如果不使用pthread_join连接线程，那么新的线程会分配新的栈空间，从而导致内存泄漏。

// 等待指定的线程的退出并接收它的返回值，如果等待的线程没有退出则阻塞。
int pthread_join(pthread_t thread, void **retval);

// retval 存放线程返回值的地址

// 返回值：成功返回0
/* 失败返回错误码:
      ESRCH：传入线程不存在
      EINVAL：不是一个可join的线程，或者已经有其他线程在等待
      EDEADLK：死锁，自己join自己或存在join环
*/

demo

创建2个线程，一个使用pthread_exit()退出，另一个使用return方式退出，使用pthread_join()接收他们的退出码，并使用pthread_cleanup_push()和pthread_cleanup_pop()做线程结束的清理工作。

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#define BUFF_SIZE 1024
void clean_up(void *arg) { printf("cleanup: %s\n", (char *)arg); }

void *test_func1(void *arg) {
  pthread_t thread = pthread_self();
  printf("thread1: %lu start\n", thread);
  // 构造push handler函数信息
  char s1[BUFF_SIZE];
  char s2[BUFF_SIZE];
  sprintf(s1, "thread1: %lu first handler", thread);
  sprintf(s2, "thread1: %lu second handler", thread);

  pthread_cleanup_push(clean_up, s1);
  pthread_cleanup_push(clean_up, s2);
  // return方式退出
  return ((void *)10);
  pthread_cleanup_pop(0);
  pthread_cleanup_pop(0);
}

void *test_func2(void *arg) {
  pthread_t thread = pthread_self();
  printf("thread2: %lu start\n", thread);
  // 构造push handler函数信息
  char s1[BUFF_SIZE];
  char s2[BUFF_SIZE];
  sprintf(s1, "thread2: %lu first handler", thread);
  sprintf(s2, "thread2: %lu second handler", thread);

  pthread_cleanup_push(clean_up, s1);
  pthread_cleanup_push(clean_up, s2);
  // pthread_exit()退出
  pthread_exit((void *)15);
  pthread_cleanup_pop(0);
  pthread_cleanup_pop(0);
}

int main() {
  int err;
  pthread_t tid1, tid2;
  void *ret_info;

  // 创建线程1
  err = pthread_create(&tid1, NULL, test_func1, (void *)NULL);
  if (err != 0) {
    printf("create thread failure\n");
  }
  // 后面省略错误判断。。。
  pthread_create(&tid2, NULL, test_func2, (void *)NULL);
  // 接收进程1的退出信息
  pthread_join(tid1, &ret_info);
  printf("thread %lu exit code %d\n", tid1, (int)ret_info);
  // 接收进程2的退出信息
  pthread_join(tid2, &ret_info);
  printf("thread %lu exit code %d\n", tid1, (int)ret_info);

  return 0;
}

执行结果:

root@yielde:~/workspace/code-container/cpp/blog_demo# ./test 
thread1: 281473444868384 start
thread2: 281473436414240 start
thread 281473444868384 exit code 10
cleanup: thread2: 281473436414240 second handler
cleanup: thread2: 281473436414240 first handler
thread 281473444868384 exit code 15

使用return退出的线程不会做清理工作，使用pthread_exit退出的线程会。

线程分离

不可以同时detach又joinable哦~ 。

通过pthread_join可以释放指定线程的资源，同时也可以获取退出线程的返回值。如果不关心其返回值，只是想让线程退出后由系统回收资源，有两种方法:

通过pthread_detach释放，可以线程自己调用，也可以通过其他线程调用

int pthread_detach(pthread_t thread);
// 返回值：成功返回0，失败返回错误编号，ESRCH表示无此线程、EINVAL表示线程不是joinable的

在创建线程时设置线程的属性

int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);

int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate);
/*
int stat;
pthread_attr_getdetachstate(&attr, &stat);
if (stat == PTHREAD_CREATE_DETACHED) {
printf("pthread detached\n");
} else if (stat == PTHREAD_CREATE_JOINABLE) {
printf("pthread joinable\n");
}
*/

demo1 join退出线程

设置线程为joinable，通过pmap观察进程为线程分配的空间，验证我们上面连接（释放）线程的结论。使用pthread_join回收线程后再启动新的线程，栈空间被复用。

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

void *start_thread(void *arg) {
  printf("thread %d start\n", (int *)arg);
  fflush(stdout);
  sleep(10);
  return NULL;
}

int main() {
  pthread_t thread;
  int ret;
  pthread_attr_t attr;
  pthread_attr_init(&attr);
  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); //设置joinable
  // pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
  sleep(15);
  ret = pthread_create(&thread, &attr, start_thread, (void *)1); // 创建线程1
  pthread_join(thread, NULL); // 连接线程
  sleep(10);
  pthread_create(&thread, &attr, start_thread, (void *)2); // 线程1退出后，创建线程2
  sleep(120);
  return 0;
}

输出结果:

// 线程启动前
root@yielde:~/workspace/othergit# pmap 441486
441486:   ./test
0000aaaacce40000      4K r-x-- test
0000aaaacce50000      4K r---- test
0000aaaacce51000      4K rw--- test
0000ffffb2830000   1568K r-x-- libc.so.6
0000ffffb29b8000     60K ----- libc.so.6
0000ffffb29c7000     16K r---- libc.so.6
0000ffffb29cb000      8K rw--- libc.so.6
0000ffffb29cd000     48K rw---   [ anon ]
0000ffffb29de000    172K r-x-- ld-linux-aarch64.so.1
0000ffffb2a13000      8K rw---   [ anon ]
0000ffffb2a15000      8K r----   [ anon ]
0000ffffb2a17000      4K r-x--   [ anon ]
0000ffffb2a18000      8K r---- ld-linux-aarch64.so.1
0000ffffb2a1a000      8K rw--- ld-linux-aarch64.so.1
0000ffffe582e000    132K rw---   [ stack ]
 total             2052K

// 线程1启动后
root@yielde:~/workspace/othergit# pmap 441486
441486:   ./test
0000aaaacce40000      4K r-x-- test
0000aaaacce50000      4K r---- test
0000aaaacce51000      4K rw--- test
0000aaaad3dea000    132K rw---   [ anon ]
0000ffffac000000    132K rw---   [ anon ]
0000ffffac021000  65404K -----   [ anon ]
0000ffffb2020000     64K -----   [ anon ] // 线程1
0000ffffb2030000   8192K rw---   [ anon ] // 线程2
0000ffffb2830000   1568K r-x-- libc.so.6
0000ffffb29b8000     60K ----- libc.so.6
0000ffffb29c7000     16K r---- libc.so.6
0000ffffb29cb000      8K rw--- libc.so.6
0000ffffb29cd000     48K rw---   [ anon ]
0000ffffb29de000    172K r-x-- ld-linux-aarch64.so.1
0000ffffb2a13000      8K rw---   [ anon ]
0000ffffb2a15000      8K r----   [ anon ]
0000ffffb2a17000      4K r-x--   [ anon ]
0000ffffb2a18000      8K r---- ld-linux-aarch64.so.1
0000ffffb2a1a000      8K rw--- ld-linux-aarch64.so.1
0000ffffe582e000    132K rw---   [ stack ]
 total            75976K

// 线程1被join之后，启动线程2
root@yielde:~/workspace/othergit# pmap 441486
441486:   ./test
0000aaaacce40000      4K r-x-- test
0000aaaacce50000      4K r---- test
0000aaaacce51000      4K rw--- test
0000aaaad3dea000    132K rw---   [ anon ]
0000ffffac000000    132K rw---   [ anon ]
0000ffffac021000  65404K -----   [ anon ]
0000ffffb2020000     64K -----   [ anon ] // 线程2，复用线程1的内存
0000ffffb2030000   8192K rw---   [ anon ] // 线程2，复用线程1的内存
0000ffffb2830000   1568K r-x-- libc.so.6
0000ffffb29b8000     60K ----- libc.so.6
0000ffffb29c7000     16K r---- libc.so.6
0000ffffb29cb000      8K rw--- libc.so.6
0000ffffb29cd000     48K rw---   [ anon ]
0000ffffb29de000    172K r-x-- ld-linux-aarch64.so.1
0000ffffb2a13000      8K rw---   [ anon ]
0000ffffb2a15000      8K r----   [ anon ]
0000ffffb2a17000      4K r-x--   [ anon ]
0000ffffb2a18000      8K r---- ld-linux-aarch64.so.1
0000ffffb2a1a000      8K rw--- ld-linux-aarch64.so.1
0000ffffe582e000    132K rw---   [ stack ]
 total            75976K

demo2 不join退出线程

设置线程为joinable，通过pmap观察进程为线程分配的空间，验证我们上面连接（释放）线程的结论。不使用pthread_join回收线程后再启动新的线程，栈空间不能被复用，内存泄漏!!.

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

void *start_thread(void *arg) {
  printf("thread %d start\n", (int *)arg);
  fflush(stdout);
  sleep(10);
  return NULL;
}

int main() {
  pthread_t thread;
  int ret;
  pthread_attr_t attr;
  pthread_attr_init(&attr);
  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
  // pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
  sleep(15);
  ret = pthread_create(&thread, &attr, start_thread, (void *)1);
  // pthread_join(thread, NULL);
  sleep(10);
  pthread_create(&thread, &attr, start_thread, (void *)2);
  sleep(120);
  return 0;
}

输出结果:

// 线程启动前
root@yielde:~/workspace/code-container/cpp/blog_demo# pmap 441707
441707:   ./test
0000aaaae39f0000      4K r-x-- test
0000aaaae3a00000      4K r---- test
0000aaaae3a01000      4K rw--- test
0000ffff9a0b0000   1568K r-x-- libc.so.6
0000ffff9a238000     60K ----- libc.so.6
0000ffff9a247000     16K r---- libc.so.6
0000ffff9a24b000      8K rw--- libc.so.6
0000ffff9a24d000     48K rw---   [ anon ]
0000ffff9a25f000    172K r-x-- ld-linux-aarch64.so.1
0000ffff9a294000      8K rw---   [ anon ]
0000ffff9a296000      8K r----   [ anon ]
0000ffff9a298000      4K r-x--   [ anon ]
0000ffff9a299000      8K r---- ld-linux-aarch64.so.1
0000ffff9a29b000      8K rw--- ld-linux-aarch64.so.1
0000ffffea091000    132K rw---   [ stack ]
 total             2052K
// 启动线程1
root@yielde:~/workspace/code-container/cpp/blog_demo# pmap 441707
441707:   ./test
0000aaaae39f0000      4K r-x-- test
0000aaaae3a00000      4K r---- test
0000aaaae3a01000      4K rw--- test
0000aaaaefa43000    132K rw---   [ anon ]
0000ffff94000000    132K rw---   [ anon ]
0000ffff94021000  65404K -----   [ anon ]
0000ffff998a0000     64K -----   [ anon ] // 线程1
0000ffff998b0000   8192K rw---   [ anon ] // 线程1
0000ffff9a0b0000   1568K r-x-- libc.so.6
0000ffff9a238000     60K ----- libc.so.6
0000ffff9a247000     16K r---- libc.so.6
0000ffff9a24b000      8K rw--- libc.so.6
0000ffff9a24d000     48K rw---   [ anon ]
0000ffff9a25f000    172K r-x-- ld-linux-aarch64.so.1
0000ffff9a294000      8K rw---   [ anon ]
0000ffff9a296000      8K r----   [ anon ]
0000ffff9a298000      4K r-x--   [ anon ]
0000ffff9a299000      8K r---- ld-linux-aarch64.so.1
0000ffff9a29b000      8K rw--- ld-linux-aarch64.so.1
0000ffffea091000    132K rw---   [ stack ]
 total            75976K
// 启动线程2
root@yielde:~/workspace/code-container/cpp/blog_demo# pmap 441707
441707:   ./test
0000aaaae39f0000      4K r-x-- test
0000aaaae3a00000      4K r---- test
0000aaaae3a01000      4K rw--- test
0000aaaaefa43000    132K rw---   [ anon ]
0000ffff94000000    132K rw---   [ anon ]
0000ffff94021000  65404K -----   [ anon ]
0000ffff99090000     64K -----   [ anon ] // 线程1退出，未被join，线程2启动分配新的内存
0000ffff990a0000   8192K rw---   [ anon ] // 线程1退出，未被join，线程2启动分配新的内存
0000ffff998a0000     64K -----   [ anon ] // 线程1
0000ffff998b0000   8192K rw---   [ anon ] // 线程1
0000ffff9a0b0000   1568K r-x-- libc.so.6
0000ffff9a238000     60K ----- libc.so.6
0000ffff9a247000     16K r---- libc.so.6
0000ffff9a24b000      8K rw--- libc.so.6
0000ffff9a24d000     48K rw---   [ anon ]
0000ffff9a25f000    172K r-x-- ld-linux-aarch64.so.1
0000ffff9a294000      8K rw---   [ anon ]
0000ffff9a296000      8K r----   [ anon ]
0000ffff9a298000      4K r-x--   [ anon ]
0000ffff9a299000      8K r---- ld-linux-aarch64.so.1
0000ffff9a29b000      8K rw--- ld-linux-aarch64.so.1
0000ffffea091000    132K rw---   [ stack ]
 total            84232K

demo3 分离线程且不join

分离线程，并且不join，应当是内核释放线程资源，新的线程复用旧的线程内存。

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

void *start_thread(void *arg) {
  printf("thread %d start\n", (int *)arg);
  fflush(stdout);
  sleep(10);
  return NULL;
}

int main() {
  pthread_t thread;
  int ret;
  pthread_attr_t attr;
  pthread_attr_init(&attr);
  // pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); // 分离线程
  sleep(15);
  ret = pthread_create(&thread, &attr, start_thread, (void *)1);
  // pthread_join(thread, NULL);
  sleep(10);
  pthread_create(&thread, &attr, start_thread, (void *)2);
  sleep(120);
  return 0;
}

运行结果:

// 启动线程前
root@yielde:~/workspace/code-container/cpp/blog_demo# pmap 441847
441847:   ./test
0000aaaac3640000      4K r-x-- test
0000aaaac3650000      4K r---- test
0000aaaac3651000      4K rw--- test
0000ffffbc680000   1568K r-x-- libc.so.6
0000ffffbc808000     60K ----- libc.so.6
0000ffffbc817000     16K r---- libc.so.6
0000ffffbc81b000      8K rw--- libc.so.6
0000ffffbc81d000     48K rw---   [ anon ]
0000ffffbc834000    172K r-x-- ld-linux-aarch64.so.1
0000ffffbc869000      8K rw---   [ anon ]
0000ffffbc86b000      8K r----   [ anon ]
0000ffffbc86d000      4K r-x--   [ anon ]
0000ffffbc86e000      8K r---- ld-linux-aarch64.so.1
0000ffffbc870000      8K rw--- ld-linux-aarch64.so.1
0000fffff3717000    132K rw---   [ stack ]
 total             2052K
// 启动线程1
root@yielde:~/workspace/code-container/cpp/blog_demo# pmap 441847
441847:   ./test
0000aaaac3640000      4K r-x-- test
0000aaaac3650000      4K r---- test
0000aaaac3651000      4K rw--- test
0000aaaaedee5000    132K rw---   [ anon ]
0000ffffb4000000    132K rw---   [ anon ]
0000ffffb4021000  65404K -----   [ anon ]
0000ffffbbe70000     64K -----   [ anon ] // 线程1
0000ffffbbe80000   8192K rw---   [ anon ] // 线程1
0000ffffbc680000   1568K r-x-- libc.so.6
0000ffffbc808000     60K ----- libc.so.6
0000ffffbc817000     16K r---- libc.so.6
0000ffffbc81b000      8K rw--- libc.so.6
0000ffffbc81d000     48K rw---   [ anon ]
0000ffffbc834000    172K r-x-- ld-linux-aarch64.so.1
0000ffffbc869000      8K rw---   [ anon ]
0000ffffbc86b000      8K r----   [ anon ]
0000ffffbc86d000      4K r-x--   [ anon ]
0000ffffbc86e000      8K r---- ld-linux-aarch64.so.1
0000ffffbc870000      8K rw--- ld-linux-aarch64.so.1
0000fffff3717000    132K rw---   [ stack ]
 total            75976K
// 启动线程2
root@yielde:~/workspace/code-container/cpp/blog_demo# pmap 441847
441847:   ./test
0000aaaac3640000      4K r-x-- test
0000aaaac3650000      4K r---- test
0000aaaac3651000      4K rw--- test
0000aaaaedee5000    132K rw---   [ anon ]
0000ffffb4000000    132K rw---   [ anon ]
0000ffffb4021000  65404K -----   [ anon ]
0000ffffbbe70000     64K -----   [ anon ] // 线程1退出，启动线程2，内存复用
0000ffffbbe80000   8192K rw---   [ anon ] // 线程1退出，启动线程2，内存复用
0000ffffbc680000   1568K r-x-- libc.so.6
0000ffffbc808000     60K ----- libc.so.6
0000ffffbc817000     16K r---- libc.so.6
0000ffffbc81b000      8K rw--- libc.so.6
0000ffffbc81d000     48K rw---   [ anon ]
0000ffffbc834000    172K r-x-- ld-linux-aarch64.so.1
0000ffffbc869000      8K rw---   [ anon ]
0000ffffbc86b000      8K r----   [ anon ]
0000ffffbc86d000      4K r-x--   [ anon ]
0000ffffbc86e000      8K r---- ld-linux-aarch64.so.1
0000ffffbc870000      8K rw--- ld-linux-aarch64.so.1
0000fffff3717000    132K rw---   [ stack ]
 total            75976K

总结

线程的优点

创建、终止线程比进程快
线程之间的上下文切换开销比进程小
线程间数据共享比进程间小

线程的缺点

linux系统中，如果一个线程触发segment fault，那么内核会认为该进程有问题，为了防止进一步破坏内存空间，内核会将整个进程杀掉。
多线程的设计通常比较复杂，一方面线程的负载在很多场景下很难平衡，另一方面如果出现顺序依赖问题，设计不当会出现数据破坏，性能下降的问题。

进程与线程API联想

进程API	线程API	备注
fork	pthread_create	创建新的
exit	pthread_exit	退出
waitpid	pthread_join	获取退出状态，释放指定ID资源
atexit	pthread_cleanup_push	退出前做的清理操作
getpid	pthread_self/syscall(SYS_gettid)	上面说过，pthread_self获取的是指向存放pthread_t内存的指针。如果要获得shell看到的线程ID号，使用syscall(SYS_gettid)
abort	pthread_cancel	被其他人终止

学习自：《UNIX环境高级编程》《Linux环境编程从应用到内核》高峰李彬著。

最后此篇关于Linux线程API使用与分析的文章就讲到这里了,如果你想了解更多关于Linux线程API使用与分析的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！。

文章推荐：【验证码逆向专栏】最新某验三代滑块逆向分析，干掉所有的w参数！

文章推荐： JS的垃圾回收机制

文章推荐：梳理拯救烂怂代码？我是这么做的

文章推荐： NextJs与Tailwind入门开发笔记

javascript - 使用 WebScriptEndpoint 使用 javascript 使用 WCF 服务
我在网上搜索但没有找到任何合适的文章解释如何使用 javascript 使用 WCF 服务，尤其是 WebScriptEndpoint。任何人都可以对此给出任何指导吗？谢谢最佳答案这是一篇关于
c - 没有结果!!使用 fork() 使用 dup2 使用 2 个管道运行 execlp()
我正在编写一个将运行 Linux 命令的 C 程序，例如: cat/etc/passwd | grep 列表 |剪切-c 1-5 我没有任何结果 *这里 parent 等待第一个 child (chi
python - 处理文件上传，使用 Pillow 调整大小，使用 SQLAlchemy 存储，使用 Flask 提供文件
所以我正在尝试处理文件上传，然后将该文件作为二进制文件存储到数据库中。在我存储它之后，我尝试在给定的 URL 上提供文件。我似乎找不到适合这里的方法。我需要使用数据库，因为我使用 Google 应用引
excel - 使用 IF 使用 VBA 在单元格中添加公式的问题
我正在尝试制作一个宏，将下面的公式添加到单元格中，然后将其拖到整个列中并在 H 列中复制相同的公式我想在 F 和 H 列中输入公式的数据 Range("F1").formula = "=IF(ISE
使用 OperatorPrecedenceParser 使用 FParsec 解析函数应用程序？
问题类似于this one ，但我想使用 OperatorPrecedenceParser 解析带有函数应用程序的表达式在 FParsec . 这是我的 AST: type Expression =
sql - 使用 sequelize 使用 where 查询编码计数
我想通过使用 sequelize 和 node.js 将这个查询更改为代码取决于在哪里 select COUNT(gender) as genderCount from customers where
bash - 使用 “let”分配Bash失败，使用 “/”
我正在使用GNU bash，版本5.0.3(1)-发行版(x86_64-pc-linux-gnu)，我想知道为什么简单的赋值语句会出现语法错误: #/bin/bash var1=/tmp
javascript - 使用 JavaScript 使用 FOR OF 数组循环时出现错误？
这里，为什么我的代码在 IE 中不起作用。我的代码适用于所有浏览器。没有问题。但是当我在 IE 上运行我的项目时，它发现错误。而且我的 jquery 类和 insertadjacentHTMl 也不
javascript - 使用 javascript 使用 for 属性更改表单标签内容
我正在尝试更改标签的innerHTML。我无权访问该表单，因此无法编辑 HTML。标签具有的唯一标识符是“for”属性。这是输入和标签的结构:
javascript - 使用 jquery 使用 .on() 将事件附加到页面上的动态插入按钮
我有一个页面，我可以在其中返回用户帖子，可以使用一些 jquery 代码对这些帖子进行即时评论，在发布新评论后，我在帖子下插入新评论以及删除按钮。问题是 Delete 按钮在新插入的元素上不起作用，
使用 awk 使用 sha1sum 进行散列
我有一个大约有 20 列的“管道分隔”文件。我只想使用 sha1sum 散列第一列，它是一个数字，如帐号，并按原样返回其余列。使用 awk 或 sed 执行此操作的最佳方法是什么？ Accounti
mysql - 使用 insert into 使用 mysql
我需要将以下内容插入到我的表中...我的用户表有五列 id、用户名、密码、名称、条目。 (我还没有提交任何东西到条目中，我稍后会使用 php 来做)但由于某种原因我不断收到这个错误:#1054 - U
jquery - 将输入字段值修剪为仅字母数字字符/使用 .使用 jQuery
所以我试图有一个输入字段，我可以在其中输入任何字符，但然后将输入的值小写，删除任何非字母数字字符，留下“。”而不是空格。例如，如果我输入: 地球的 70% 是水，-!*#$^^ & 30% 土地输
javascript - 使用 .innerHTML 使用 DOM
我正在尝试做一些我认为非常简单的事情，但出于某种原因我没有得到想要的结果？我是 javascript 的新手，但对 java 有经验，所以我相信我没有使用某种正确的规则。这是一个获取输入值、检查选择
php - 使用 angularjs 使用 where 子句从数据库获取数据
我想使用 angularjs 从 mysql 数据库加载数据。这就是应用程序的工作原理；用户登录，他们的用户名存储在 cookie 中。该用户名显示在主页上我想获取这个值并通过 angularjs
ios - 使用 UITableViewCell 使用 AutoLayout
我正在使用 autoLayout，我想在 UITableViewCell 上放置一个 UIlabel，它应该始终位于单元格的右侧和右侧的中心。这就是我想要实现的目标所以在这里你可以看到我正在谈论的
mysql - 使用 ElasticSearch 使用 or 和运算符搜索多个字段
我需要与 MySql 等效的 elasticsearch 查询。我的 sql 查询: SELECT DISTINCT t.product_id AS id FROM tbl_sup_price t
ios - 使用 Swift 使用 JSON
我正在实现代码以使用 JSON。 func setup() { if let flickrURL = NSURL(string: "https://api.flickr.com/
javascript - 使用 JavaScript 使用 for 循环声明变量
我尝试使用for循环声明变量，然后测试cols和rols是否相同。如果是，它将运行递归函数。但是，我在 javascript 中执行 do 时遇到问题。有人可以帮忙吗？现在，在比较 col.1 和
jquery - 使用 :after 使用 jquery 更改样式
我举了一个我正在处理的问题的简短示例。 HTML代码: 1 2 3 CSS 代码: .BB a:hover{ color: #000; } .BB > li:after {

来者不拒

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城