线程基础

线程是进程的一个执行单元，执行一段程序片段，线程共享全局变量；线程的查看可以使用命令或者文件来进行查看；命令：ps -T -p <pid> -T:表示用于开启线程查看；top -H -p <pid> -H 用于开启线程查看；还可以通过htop 使用F2开启树状图查看选项，或者开启显示自定义线程名选项；F10用于退出设置；文件：/proc/PID/task 线程的名字默认和进程相同；/proc/PID/task/comm线程名称；

线程的相关函数

线程标识

pthread_t pthread_self(void)；返回值是当前线程ID，可以使用%lu打印线程pid的值；设置线程名称：int prctl(int option,unsigned long arg2)；PR_GET_NAME用于获得当前线程的名字，PR_SET_NAME，用于设置当前线程的名字；arg2：线程名称最大长度为15个字节，并且应该以'\0'结尾，一共16个字符；返回值：0表示成功非0表示出错；
thread01.c

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/prctl.h>

int main(){
    printf("PID:%d,TID:%lu\n",getpid(),pthread_self());
    char name[16] = {0};
    prctl(PR_SET_NAME,"test");
    prctl(PR_GET_NAME,name);
    printf("TNAME:%s\n",name);
}

thread02.c

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/prctl.h>

int info(){
    printf("PID:%d,TID:%lu",getpid(),pthread_self());
    char name[16] = {0};
    prctl(PR_GET_NAME,name);
    printf("TNAME:%s\n",name);
}

void* method(void* arg){
    info();
}

int main(){
    info();
    pthread_t tid;
    pthread_create(&tid,NULL,method,NULL);
    printf("new tid:%lu\n",tid);
    sleep(1);
}

线程创建

int pthread_create(pthread_t *tidp,pthread_attr_t *attr,void (start_rtn)(void),void *arg)；tidp：线程ID指针；
 attr：线程属性：绑定：pthread_attr_setscope(pthread_attr_t *attr, int scope)；scope：PTHREAD_SCOPE_PROCESS：表示不进行绑定，这个是默认的选项；PTHREAD_SCOPE_SYSTEM表示绑定轻进程(LWP)/内核线程；
 分离：pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate)；detachstate：PTHREAD_CREATE_DETACHED：表示分离线程；PTHREAD_CREATE_JOINABLE表示非分离线程；
 线程使用的是缺省的堆栈，线程的优先级和父进程同级别；
线程的ID指针返回值是void类型的指针函数；arg：表示的是start_rtn的形式参数；返回值0表示成功，非0表示出错；

线程消亡

线程的消亡分为正常终止和线程取消两种情况；线程正常终止：对于子线程来说线程处理函数return 返回一个返回值，线程可以终止，线程终止还可以调用pthread_exit(void* retval);来进行处理，retval：表示函数的返回指针，只要pthread_join中的第二个参数retval不是NULL，这个值江北传递给retval，如果用在线程回调函数中，将返回线程数据；

对于主线程：线程合并：int pthread_join(pthread_t tid, void **retval)；tid：被等待的线程标识符，retval一个用户定义的指针，它可以用来存储被等待线程的返回值，返回值：0表示成功，非0表示错误码；当进行线程合并时，可以由其他线程来终止，并且回收资源；
pthread_join.c：线程取消函数

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/prctl.h>

int info(){
    printf("PID:%d,TID:%lu",getpid(),pthread_self());
    char name[16] = {0};
    prctl(PR_GET_NAME,name);
    printf("TNAME:%s\n",name);
}

void* method(void* arg){
    sleep(5);
    info();
}

int main(){
    info();
    pthread_t tid;
    pthread_create(&tid,NULL,method,NULL);
    printf("new tid:%lu\n",tid);
    //sleep(1);
    pthread_join(tid,NULL);
}

主线程终止的另一种方式是线程分离int pthread_detach(ppthread_t tid)；tid：表示要释放线程的标识符，返回值0表示成功，非0表示错误码；但是这样是不能被其他线程终止的，存储在它终止时，有系统自动的回收释放；

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

线程取消：取消点取消，如果线程接收到取消信号，到达指定位置才能能取消，取消点取消分为手动：void pthread_testcancle(void)；自动：通过引起阻塞的系统调用来取消；
 线程取消：发送取消信号：int pthread_cancel(pthread_t pthread)，需要注意的是：发送成功并不一定意味着thread线程就会终止，发送CANCEL指令后，使用pthread_join 函数，等待指定的线程完全退出以后，在继续执行，否则容易产生段错误；函数的返回值0表示成功，非0值表示失败；
 设置当前线程的取消类型：int pthread_setcancelstate(int state，int *oldstate)；state：PTHREAD_CANCEL_ENABLE：线程取消启用；PTHREAD_CANCEL_DISABLE：表示线程取消禁用；oldstate：表示线程之前的状态；
 设置当前线程的取消类型：int pthread_setcanceltype(int type,int *oldtype)；type：PTHREAD_CANCEL_DEFFERED：表示取消点取消；PTHREAD_CANCEL_ASYNCHRONOUS：表示立即退出；oldstate：表示之前的取消类型；
 设置取消点：void pthread_testcanel(void)；
pthread_cancel.c

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

long count = 0;

void* default_func(void* arg){
    for(;;){
        pthread_testcancel();
        count++;
    }
}

void* disable_func(void* arg){
    pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,NULL);
    for(;;){
        pthread_testcancel();
        count++;
    }
}
void* force_func(void* arg){
    pthread_setcanceltype( PTHREAD_CANCEL_ASYNCHRONOUS,NULL);
    for(;;){
        count++;
    }
}

void* disable_force_func(void* arg){
    pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,NULL);
    pthread_setcanceltype( PTHREAD_CANCEL_ASYNCHRONOUS,NULL);
    for(;;){
        count++;
    }
}
void* watch(void* arg){
    for(;;){
        sleep(1);
        printf("count:%d\n",count);
    }
}

void* cancel(void* arg){
    sleep(5);
    pthread_t* ptid = arg;
    printf("cancel %lu\n",ptid[0]);
    pthread_cancel(ptid[0]);    
}

int main(int argc,char* argv[]){
    typedef void* (*Func)(void*); 
    Func funcs[3] = {default_func,watch,cancel}; 

    int c;
    while((c=getopt(argc,argv,"dp"))!=-1){
        switch(c){
            case 'd':
                funcs[0] = (funcs[0] == default_func?disable_func:disable_force_func);
                break;
            case 'p':
                funcs[0] = (funcs[0] == default_func?force_func:disable_force_func);
                break;
        }
    }

    pthread_t tids[3];
    int i=0;
    for(;i<3;i++){
        pthread_create(&tids[i],NULL,funcs[i],&tids);
        printf("create thread %lu\n",tids[i]);
    }
    for(i=0;i<3;i++){
        pthread_join(tids[i],NULL);
    }

}

发送信号：int pthread_kill(pthread_t tid, int sig)；tid：表示线程ID，sig：信号，0表示保留信号，用于测试线程是否存在，信号为正数表示系统自定义信号或者系统自定义信号；返回值：0表示调用成功，ESRCH：表示线程不存在；EINVAL：表示信号不合法；

设置线程并发度：并发度表示线程并发的数目，int pthread_setconcurrency(int level)；获取线程并发度：int pthread_getconcurrency(void)；
 void pthread_cleanup_push(void (routine)(void),void *arg)；void pthread_cleanup_pop(int execute)；execute通常为0；关于线程的信息可以man 7 threads；
 线程间通信使用全局变量的方式进行；

线程同步

信号量

信号量的创建：int sem_init(sem_t *sem,int pshared,unsigned int value)；sem：表示信号量对象；pshared：表示信号量的类型，0表示线程共享，<0：表示进程共享；value：用于表示初始值；返回值0表示成功，-1表示失败；

Ã销毁：int sem_destory(sem_t *sem)；sem：表示信号量对象；返回值0表示成功，-1表示失败；

等待：包括三种：阻塞等待，int sem_wait(sem_t *sem)；sem：标识信号量对象；返回值0表示成功，-1表示失败；非阻塞等待：int sem_trywait(sem_t *sem)；sem：表示信号量对象；返回值0表示成功，-1表示失败；超时等待：int sem_timedwait(sem_t *sem，struct timespec *abstime)；sem：表示信号量对象；abstime：表示等待时间；-1表示等待超时，0表示成功；
̳触发：sem：信号量对象；0：表示成功；-1：表示成功；

互斥量

互斥量和信号量的区别：
 1、互斥量用于线程的互斥，信号用于线程的同步互斥：是指某一资源同时只允许一个访问者对其进行访问，具有唯一性和排他性，但是沪指无法限制资源访问者对其资源的访问顺序，也就是访问是无序的；同步：是指在互斥的基础上，通过其它机制实现访问者对资源的有序访问，在大多数情况下，同步已经实现了互斥，特别是所有写入资源的情况 都是互斥的，少数情况是指可以允许多个访问者同时访问资源；
 2、互斥量值只能是0或者1，信号量值可以作为非负整数，也就是说，一个互斥量只能用于一个资源的互斥访问，它不能解决多个资源的多线程互斥问题，信号量可以实现多个同类资源的多线程互斥和同步。当信号量为单值信号量时，也可以完成一个资源的互斥访问；
 3、互斥量的加锁和解锁必须有同一个线程使用，信号量可以由一个线程释放，另一个线程得到；
 4、信号量可以允许多个线程进入临界区，互斥体只能允许一个线程进入临界区；
 ATM取款，toilet；互斥量分为静态分配互斥量，实现特点是简单，pthread_mutex = PTHREAD_MUTEX_INITIAVIZER；动态分配互斥量：特点是可以设置更多的选项；pthread_mutex_init(&mutex,NULL)或者pthread_mutex_destory(&mutex)；
 互斥量的操作：加锁：互斥锁int pthread_mutex_lock(pthread_t *mutex)；尝试加锁 int pthread_mutex_trylock(pthread_t *mutex)，mutex：表示的也是互斥锁；解锁：int pthread_mutex_unlock(pthread_t *mutex)，mutex同样表示的是互斥锁；
mutex01.c

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

void* func(void* arg){
    pthread_mutex_lock(arg);
    printf("enter func\n");
    sleep(1);
    printf("do something\n");
    sleep(1);
    printf("level func\n");
    pthread_mutex_unlock(arg);
}

int main(int argc,int argv[]){
    pthread_mutex_t mutex;
    pthread_mutex_init(&mutex,NULL);
    
    pthread_t tids[3];
    int i;
    for(i=0;i<3;i++){
        pthread_create(&tids[i],NULL,func,&mutex);
    }
    for(i=0;i<3;i++){
        pthread_join(tids[i],NULL);
    }
    pthread_mutex_destroy(&mutex);

}

mutex02.c

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

void* func(void* arg){
    pthread_cleanup_push(pthread_mutex_unlock,arg);

    pthread_mutex_lock(arg);
    printf("enter func\n");
    sleep(1);
    printf("do something\n");
    sleep(1);
    printf("level func\n");
    pthread_exit(0);

    pthread_cleanup_pop(0);
}

int main(int argc,int argv[]){
    pthread_mutex_t mutex;
    pthread_mutex_init(&mutex,NULL);
    
    pthread_t tids[3];
    int i;
    for(i=0;i<3;i++){
        pthread_create(&tids[i],NULL,func,&mutex);
    }
    for(i=0;i<3;i++){
        pthread_join(tids[i],NULL);
    }
    pthread_mutex_destroy(&mutex);

}

条件变量

线程挂起直到共享数据的某些条件得到满足；条件变量分为静态分配条件变量，pthread_cond_t_cond = PTHREAD_COND_INITIALIZER特点是比较简单；动态分配静态变量：特点是可以设置更多的选项，pthread_cond_init(&cond,NULL)；或者使用pthread_cond_destory(&cond)；
操作：
 条件等待：int pthrad_cond_wait(pthread_cond_t *cond，pthread_mutex_t *mutex)；cond：表示条件变量；mutex：表示互斥锁；
 计时等待：int pthread_cond_timedwait(pthread_cond_t *cond,pthread_muex_t *mutex,const struct timespec *abstime)；cond：表示条件变量；mutex：表示互斥锁；abstime：表示等待时间；返回值：ETIMEDOUT：表示超时等待结束；
激活操作：
 单个激活：int pthread_cond_signal(pthread_cond_t *cond)；cond：表示条件变量，返回值0表示成功，正数表示错误码；
Ϳ全部激活： int pthread_cond_broadcast(pthread_cond_t *cond)；cond：表示条件变量，返回值0表示成功，正数表示错误码；

线程读写锁

读取锁是共享锁，写入锁是独占锁；
 静态分配读写锁：pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER,特点是实现简单；动态分配读写锁：pthread_rwlock_init(&rwlock,NULL)；pthread_rwlock_destory(&rwlock)；可以用于设置更多选项

关于锁的操作

读取锁：加读取锁：int pthread_rwlock_rdlock(pthread_rwlock *rwlock)，int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock)；加写入锁：int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock)；int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock)；解锁操作：int pthread_rwlock_unlock(pthread_rwlock_t *rwlock)；

线程和进程的区别

接口对比：

1、进程是资源分配和拥有的基本单位，线程是处理器调度的基本单位；
2、进程拥有独立的地址空间，线程共性进程的地址空间；
3、线程上下文切换比进程上下文切换要快得多；
4、子进程崩溃不会影响其它子进程，但是任何一个线程崩溃，整个程序都会崩溃；