主线程退出，支线程会退出吗
在win系统中，主线程退出一般同进程的工作线程会退出。在linux系统中，主线程退出，同进程的工作线程不会有影响，但是这个进程会变成僵尸进程。
某个线程奔溃会导致整个进程退出。
线程创建方式
linux下使用pthread_create接口，创建好的线程需要在主线程调用pthread_join。
写好的程序编译的时候，如果用gcc需要带参数-lpthread，例如gcc -g -o linuxtls linuxtls.cpp -lpthread，因为pthread不是默认的库，需要指定一下。
win下不能用这个，是另外的接口。
c++11提供了thread类，不论win和linux都可以使用，直接定义std::thread t1(thread_func1);，然后t1.join()，在使用的时候一定注意定义thread 的时候最好不要在某个函数里面定义局部变量，因为该函数执行完了，作为局部变量也会销毁，会导致进程奔溃。
获取线程id的方式
linux下使用pthread_self接口，c11可以使用std::this_thread::get_id(),
定位进程cpu消耗过高的方式
首先用top看哪个进程高，例如：
Tasks: 130 total, 1 running, 129 sleeping, 0 stopped, 0 zombie %Cpu(s): 2.3 us, 9.1 sy, 0.0 ni, 88.6 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st MiB Mem : 1987.1 total, 146.2 free, 284.0 used, 1556.9 buff/cache MiB Swap: 0.0 total, 0.0 free, 0.0 used. 1511.5 avail Mem PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 399481 root 20 0 87956 1576 1416 S 5.3 0.1 0:04.44 c11threadlocal 395147 ubuntu 20 0 13956 6304 4712 S 2.7 0.3 0:02.38 sshd 399039 root 20 0 0 0 0 I 2.7 0.0 0:01.33 kworker/u2:1-events_power_efficient 2516252 root 20 0 966200 60720 30368 S 0.7 3.0 54:42.63 YDService 8759 root 20 0 493204 16860 4280 S 0.3 0.8 156:22.30 barad_agent 16437 root 20 0 1197100 40884 27936 S 0.3 2.0 55:35.86 containerd 2516643 root 20 0 1157292 7748 4160 S 0.3 0.4 1:21.42 sh 1 root 20 0 102996 12604 8324 S 0.0 0.6 0:39.58 systemd 2 root 20 0 0 0 0 S 0.0 0.0 0:01.09 kthreadd 3 root 0 -20 0 0 0 I 0.0 0.0 0:00.00 rcu_gp
上面的399481进程很高，是我运行的c11threadlocal，然后使用top -H
top - 16:27:43 up 42 days, 5:25, 3 users, load average: 0.09, 0.08, 0.02 Threads: 204 total, 2 running, 202 sleeping, 0 stopped, 0 zombie %Cpu(s): 6.7 us, 11.4 sy, 0.0 ni, 81.6 id, 0.0 wa, 0.0 hi, 0.3 si, 0.0 st MiB Mem : 1987.1 total, 152.4 free, 277.8 used, 1557.0 buff/cache MiB Swap: 0.0 total, 0.0 free, 0.0 used. 1517.8 avail Mem PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 395147 ubuntu 20 0 13956 6304 4712 S 4.3 0.3 0:05.83 sshd 396269 root 20 0 0 0 0 I 4.3 0.0 0:01.17 kworker/u2:2-events_power_efficient 400124 root 20 0 87956 1576 1416 S 4.0 0.1 0:00.48 c11threadlocal 400125 root 20 0 87956 1576 1416 S 4.0 0.1 0:00.49 c11threadlocal 502 root rt 0 280200 17992 8200 S 0.3 0.9 1:32.98 multipathd 16452 root 20 0 1197100 40884 27936 S 0.3 2.0 18:30.78 containerd 1 root 20 0 102996 12604 8324 S 0.0 0.6 0:39.56 systemd
可以看每个进程里面每个线程的消耗多少，例如c11threadlocal里面两个线程400124和400125和都很高，然后pstack 399481看调用堆栈，程序的每个线程都跑着哪里，例如：
ubuntu@VM-0-3-ubuntu:~$ sudo pstack 400925 Thread 3 (Thread 0x7fde9dad2700 (LWP 400927)): #0 0x00007fde9e5083bf in clock_nanosleep () from /lib/x86_64-linux-gnu/libc.so.6 #1 0x00007fde9dad1d48 in ?? () #2 0x00007fde00000000 in ?? () #3 0x00007fde9dad1d60 in ?? () #4 0x0000558cb634fca8 in std::chrono::duration<long, std::ratio<1l, 1000000000l> > std::chrono::__duration_cast_impl<std::chrono::duration<long, std::ratio<1l, 1000000000l> >, std::ratio<1000000000l, 1l>, long, false, true>::__cast<long, std::ratio<1l, 1l> >(std::chrono::duration<long, std::ratio<1l, 1l> > const&) () #5 0x00007fde9dad1da0 in ?? () #6 0x00007fde9dad1db0 in ?? () #7 0x0000000000000001 in ?? () #8 0x5a942470b5f95a00 in ?? () #9 0x0000000000000000 in ?? () Thread 2 (Thread 0x7fde9e2d3700 (LWP 400926)): #0 0x00007fde9e5083bf in clock_nanosleep () from /lib/x86_64-linux-gnu/libc.so.6 #1 0x00007fde9e2d2d48 in ?? () #2 0x00007fde00000000 in ?? () #3 0x00007fde9e2d2d60 in ?? () #4 0x0000558cb634fca8 in std::chrono::duration<long, std::ratio<1l, 1000000000l> > std::chrono::__duration_cast_impl<std::chrono::duration<long, std::ratio<1l, 1000000000l> >, std::ratio<1000000000l, 1l>, long, false, true>::__cast<long, std::ratio<1l, 1l> >(std::chrono::duration<long, std::ratio<1l, 1l> > const&) () #5 0x00007fde9e2d2da0 in ?? () #6 0x00007fde9e2d2db0 in ?? () #7 0x0000000000000001 in ?? () #8 0x5a942470b5f95a00 in ?? () #9 0x0000000000000000 in ?? () Thread 1 (Thread 0x7fde9e2d4740 (LWP 400925)): #0 0x00007fde9e821cd7 in __pthread_clockjoin_ex () from /lib/x86_64-linux-gnu/libpthread.so.0 #1 0x0000000000000000 in ?? ()
然后把源码打开这些位置，分析问题。
互斥体的使用
使用前先定义互斥体pthread_mutex_t mymutex;，然后初始化pthread_mutex_init(&mymutex, NULL);，然后就可以加锁解锁了，接口为：pthread_mutex_lock(&mymutex);和pthread_mutex_trylock(&mymutex);和pthread_mutex_unlock(&mymutex);，
使用完要销毁pthread_mutex_destroy(&mymutex);
互斥体使用的过程中有三种锁，普通锁、检错锁和可重入锁，设置方法：
pthread_mutexattr_t mutex_attr; pthread_mutexattr_init(&mutex_attr); pthread_mutexattr_settype(&mutex_attr, PTHREAD_MUTEX_NOMAL); pthread_mutex_init(&mymutex, &mutex_attr);
PTHREAD_MUTEX_NOMAL 是普通锁，当一个线程加锁后，其他线程加锁会阻塞线程；
PTHREAD_MUTEX_ERRORCHECK是检错锁，当一个线程加锁后，其他线程加锁不会阻塞，会返回一个EDEADLK；
PTHREAD_MUTEX_RECURSIVE是可重入锁，同一个线程可以多次加锁，每次加锁有一个引用计数加1，解锁引用计数减一，当引用计数为0会释放锁，加锁过程中，其他线程加锁会阻塞线程。
信号量的使用
#include <semaphore.h>
sem_t mysemaphore; //定义信号量
sem_init(&mysemaphore, 0, 0); //初始化信号量
sem_destroy(&mysemaphore); //销毁一个信号量
sem_post(&mysemaphore); //信号量资源加1，并释放信号量，sem_wait线程会被唤醒
sem_wait(&mysemaphore);//信号量资源为0时会阻塞线程，当资源不为0的时候线程被唤醒，然后资源减1
sem_trywait(&mysemaphore);//信号量资源为0时不会阻塞线程，返回值为-1，错误码为EAGAIN
struct timespec ts;
ts.tv_sec = 3;
ts.tv_nsec = 0;
sem_timedwait(&mysemaphore, &ts)信号量资源为0时会阻塞线程，超过ts时间后，返回值为-1，错误码为ETIMEDOUT
条件变量的使用
pthread_cond_t mycv; //定义一个条件变量
pthread_cond_init(&mycv, NULL); //条件变量初始化
pthread_mutex_destroy(&mymutex); //条件变量使用完要销毁
pthread_cond_wait(&mycv, &mymutex); // 会让线程阻塞等待下去
struct timespec ts;
ts.tv_sec = 3;
ts.tv_nsec = 0;
pthread_cond_timedwait(&mycv, &mymutex, &ts); // 会让线程阻塞ts时间并等待下去
pthread_cond_signal(&mycv); //释放条件变量，并让wait线程运行，只会让其中一个线程运行，具体哪个线程未知
pthread_cond_broadcast(&mycv); // 释放条件变量，并让所有wait线程运行
读写锁的使用
pthread_rwlock_t myrwlock; //定义一个读写锁
pthread_rwlock_init(&myrwlock, NULL); //一般主线程的主函数初始化读写锁
pthread_rwlock_destroy(&myrwlock); //程序退出的时候，要销毁读写锁
pthread_rwlock_rdlock(&myrwlock); //请求读锁，如果被写锁占有则线程阻塞
pthread_rwlock_tryrdlock(&myrwlock); //尝试请求读锁，不会阻塞线程
struct timespec ts;
ts.tv_sec = 3;
ts.tv_nsec = 0;
pthread_rwlock_timedtryrdlock(&myrwlock, &ts); //会让线程阻塞ts时间尝试获取读锁
pthread_rwlock_wrdlock(&myrwlock); //请求写锁，如果被写锁或者读锁占有则线程阻塞
pthread_rwlock_trywrdlock(&myrwlock); //尝试请求写锁，不会阻塞线程
struct timespec ts;
ts.tv_sec = 3;
ts.tv_nsec = 0;
pthread_rwlock_timedtrywrdlock(&myrwlock, &ts); //会让线程阻塞ts时间尝试获取写锁
pthread_rwlock_unlock(&myrwlock); //读写锁统一用该接口释放锁
pthread_rwlockattr_t attr;
pthread_rwlockattr_init(&attr);
//设置成请求写锁优先
pthread_rwlockattr_setkind_np(&attr, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP);
//PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP 写锁优先
//PTHREAD_RWLOCK_PREFER_READER_NP//读锁优先
pthread_rwlock_init(&myrwlock, &attr);
c++11的线程同步
以上的线程同步方式分为linux和win（没总结），c++11做了封装：
std::mutex g_num_mutex; //互斥锁 g_num_mutex.lock(); //加锁 g_num_mutex.unlock(); //解锁
std::condition_variable mycv; //条件变量 mycv.wait(guard); //等待信号 mycv.notify_one(); //释放信号
thread_local int g_mydata = 1; //每个线程都独立拥有该变量，每个线程的该变量值都不同