Unix——线程和线程控制

古城微笑少年丶 2022-06-18 01:41 146阅读 0赞

注：写得非常乱，以后有空再整理（在我们业界称为重构），没空就这样放着吧。

线程包含了表示进程内执行环境的必须信息。其中包括进程中的线程ID，一组寄存器值，栈，调度优先级和策略，  
信号屏蔽字，errno变量，线程私有数据。进程所有信息对该进程的所有线程都是共享的包括，可执行的程序文本，  
程序全局内存和堆内存，栈，文件描述符。  
线程接口-POSIX.1-2001,"pthread","POSIX线程"  
  
  
\#include <pthread.h>  
int pthread\_equal(pthread\_t id1, pthread\_t id2);//相等返回非0；否则返回0  
  
\#include <pthread.h>  
pthread\_t pthread\_self(void);//获得自身线程ID，参见getpid()  
  
  
\#include <pthread.h>  
int pthread\_create(pthread\_t \*restrict id,  
const pthread\_attr\_t \*restrict attr,//线程属性NULL  
void \*(\*fun)(void \*), void \*restrict arg);//新线程入口，函数fun,  
//如果函数参数有多个，则把这些参数放到一个结构中，然后把这个结构地址传入。  
成功返回0，每个线程都提供errno的副本  
  
  
C语言题外话：volatile和restrict  
方便编译器优化，  
restrict，C99引入，只可以用于限定指针，并表明指针是访问一个数据对象的唯一且初始的方式；  
指向的内容改变，则只能通过指针进行存取。  
volatile告诉编译器该变量除了可被程序修改以外还可能被其他代理修改，因此，当要求使用  
volatile 声明的变量的值的时候，系统总是重新从它所在的内存读取数据，而不是使用寄存器中的缓存。  
  
  
  
  
线程退出：  
1）线程从启动历程中返回，返回值是线程退出码。  
2）线程可以被统一进程中的其它线程取消。  
3）pthread\_exit(void \*rval\_ptr);  
线程被取消rval\_ptr指向单元置为PTHREAD\_CANCELED  
  
  
int pthread\_join(pthread\_t thread, void \*\*rval\_ptr);  
//调用线程阻塞，直到指定的线程调用pthread\_exit,从启动例程中返回或者被取消  
自动使线程处于分离状态。  
int pthread\_cancel(pthread\_t tid);//提出请求取消同一进程中的其他线程，不等待线程终止。  
  
  
线程清理处理程序  
void pthread\_cleanup\_push(void (\*fun)(void \*), void \*arg);--注册清理函数fun  
void pthread\_cleanup\_pop(int execute);--execute!=0执行清理，后注册先执行。  
清理函数的调用顺序由pthread\_cleanup\_push函数来安排，线程执行以下动作时调用清理函数：  
1）调用pthread\_exit  
2）响应取消请求时  
3）用非零execute调用pthread\_cleanup\_pop时  
  
  
int pthread\_detach（pthread\_t tid）；使线程进入分离状态。  
  
  
  
  
线程的状态：分离状态  
  
  
线程的同步问题（互斥量，读写锁，条件变量）  
互斥量  
\#include <pthread.h>  
int pthread\_mutex\_init(pthread\_mutex\_t \*restrict mutex,  
const pthread\_mutexattr\_t \*restrict attr);//默认attr=NULL  
int pthread\_mutex\_destroy(pthread\_mutex\_t \*mutex);//成功返回0  
  
  
int pthread\_mutex\_lock(pthread\_mutex\_t \*mutex);//加锁,互斥量已经上锁则线程阻塞，直到该互斥量解锁。  
int pthread\_mutex\_unlock(pthread\_mutex\_t \*mutex);//解锁  
int pthread\_mutex\_trylock(pthread\_mutex\_t \*mutex);//尝试加锁，不阻塞。已加锁，返回EBUSY  
  
  
避免死锁：两个线程同时请求两一个线程拥有的资源，从而产生死锁。  
产生死锁的必要条件：  
1）互斥  
2）占有并等待  
3）非抢先  
4）循环等待  
  
  
读写锁（共享独占锁），允许更高的并行性（三种状态，读模式下加锁，写模式下加锁，不加锁状态）  
读写锁同互斥锁一样，在使用前初始化，在释放底层内存时必须销毁。  
int pthread\_rwlock\_init(pthread\_rwlock\_t \*restrict rwlock,  
const pthread\_rwlock\_t \*restrict attr);  
int pthread\_rwlock\_destroy(pthread\_rwlock\_t \*rwlock);  
  
  
int pthread\_rwlock\_rdlock(pthread\_rwlock\_t \*rwlock);//读模式加锁  
int pthread\_rwlock\_wrlock(pthread\_rwlock\_t \*rwlock);//写模式加锁  
int pthread\_rwlock\_unlock(pthread\_rwlock\_t \*rwlock);//解锁  
  
  
int pthread\_rwlock\_tryrdlock(pthread\_rwlock\_t \*rwlock);//可以获取锁，返回0；否则返回EBUSY  
int pthread\_rwlock\_trywrlock(pthread\_rwlock\_t \*rwlock);  
  
  
条件变量：  
\#include <pthread.h>  
int pthread\_cond\_init(pthread\_cond\_t \*restrict cond,  
pthread\_cond\_t \*restrict attr);  
int pthread\_cond\_destroy(pthread\_cond\_t \*cond);  
  
  
int pthread\_cond\_wait(pthread\_cond\_t \*restrict cond,  
pthread\_mutex\_t \*restrict mutex);  
int pthread\_cond\_timedwait(pthread\_cond\_t \*restrict cond,  
pthread\_mutex\_t \*restrict mutex,  
const struct timespec \*restrict timeout);  
  
  
int pthread\_cond\_signal(pthread\_cond\_t \*cond);//向线程或条件发送信号  
int pthread\_cond\_broadcast(pthread\_cond\_t \*cond);  
  
  
线程限制（略）  
线程属性 struct pthread\_attr\_t\{\};该结构不透明  
\#include <pthread.h>  
int pthread\_attr\_init(pthread\_attr\_t \*attr);  
int pthread\_attr\_destroy(pthread\_attr\_t \*attr);  
  
  
detachstate 线程分离状态属性  
guardsize 线程栈末尾的警戒缓冲区大小（字节数）  
stackaddr 线程栈的最低地址  
stacksize 线程栈的大小（字节数）  
  
  
若对某个线程的终止状态不感兴趣，调用int pthread\_detach（pthread\_t id）函数，  
让OS在线程退出时，回收它所占用的资源。  
  
  
分离状态属性：  
int pthread\_attr\_getdetachstate(const pthread\_attr\_t \*restrict attr,  
int \*detachstate);  
创建线程，以分离状态启动  
int pthread\_attr\_setdetachstate(pthread\_attr\_t \*attr, int detachstate);  
detachstate=PTHREAD\_CANCEL\_DETACHE  
PTHREAD\_CREATE\_JOINABLE（默认）  
  
线程栈大小属性和线程栈最低地址：  
int pthread\_attr\_getstack(const pthread\_attr\_t \*restrict attr,  
void \*\*restrict stackaddr,  
size\_t \*restrict stacksize);  
int pthread\_attr\_setstack(pthread\_attr\_t \*attr,  
void \*stackaddr,  
size\_t \*stacksize)  
  
线程栈大小属性  
int pthread\_attr\_getstacksize(const pthread\_attr\_t \*restrict attr, size\_t \*restrict stacksize);  
int pthread\_attr\_setstacksize(pthread\_attr\_t \*attr, size\_t stacksize);  
  
  
guardsize属性，控制着线程末尾之后用以避免栈溢出的扩展内存的大小。默认PAGESIZE  
int pthread\_attr\_getguardsize(const pthread\_attr\_t \*restrict attr,  
size\_t \*restrict guardsize);  
int pthread\_attr\_setguardsize(pthread\_attr\_t \*attr, size\_t guardsize);  
  
  
有两个没有包含在pthread\_attr\_t结构中的属性——可取消状态和可取消类型，他们影响着pthread\_cancel函数  
调用时所呈现的行为。  
可取消状态：PTHREAD\_CANCEL\_ENABLE默认，PTHREAD\_CANCLE\_DISABLE  
\#include <pthread.h>  
int pthread\_setcancelstate(int state, int \*oldstate);  
void pthread\_testcancel(void);//手动添加取消点。  
可取消类型：PTHREAD\_CANCEL\_DEFERRED延迟取消，PTHREAD\_CANCEL\_ASYNCHRONOUS异步取消，任意时间取消  
int pthread\_setcanceltype(int type, int \*oldtype);  
  
  
  
  
同步属性  
互斥量属性pthread\_mutexattr\_t  
int pthread\_mutexattr\_init(pthread\_mutexattr\_t \*mutexattr);  
int pthread\_mutexattr\_destroy(pthread\_mutexattr\_t \*mutexattr);  
进程共享互斥量属性：PTHREAD\_PROCESS\_SHARED，PTHREAD\_PROCESS\_PRIVATE(default)  
int pthread\_mutexattr\_getpshared(const pthread\_mutexattr\_t \*restrict attr, int \*restrict pshared);  
int pthread-mutexattr\_setpshared(pthread\_mutexattr\_t \*attr, int pshared);  
类型互斥量属性：PTHREAD\_MUTEX\_NORMAL，PTHREAD\_MUTEX\_ERRORCHECK，  
PTHREAD\_MUTEX\_RECURSIVE使之等同于信号量的功能.递归锁。  
PTHREAD\_MUTEX\_DEFAULT，系统将其映射到其它类型  
int pthread\_mutexattr\_gettype(const pthread\_mutexattr\_t \*restrict attr, int \*restrict type);  
int pthread\_mutexattr\_settype(pthread\_mutexattr\_t \*attr, int type);  
  
  
  
  
  
  
  
  
读写锁属性pthread\_rwlockattr\_t  
读写锁的唯一属性是进程共享属性，参见互斥量。  
  
  
  
  
条件变量属性pthread\_condattr\_t  
也支持进程共享属性  
  
  
  
  
重入问题，有了信号处理程序和线程，多个控制线程在同一时间可能潜在的调用同一个函数。  
如果一个函数在同一时刻可以被多个线程安全的调用，则该函数是线程安全的。  
如果一个函数对多个线程来说是可重入的，则这个函数是线程安全的，但并不说明对信号处理程序来说该函数也是可重入的。  
若果函数对异步信号处理程序的重入是安全的，那么就可以说函数是异步信号安全函数。  
  
  
线程安全函数（线程可重入的）和异步信号安全函数（信号处理程序可重入的）  
POSIX.1不能保证是线程安全的函数，系统提供他们的线程安全版本