线程概述

最新推荐文章于 2024-05-10 08:33:59 发布

Gin

最新推荐文章于 2024-05-10 08:33:59 发布

阅读量316

点赞数

文章标签： thread null join struct asynchronous signal

本文链接：https://blog.csdn.net/hadesgin/article/details/6787702

版权

Linux程序设计专栏收录该内容

20 篇文章 0 订阅

订阅专栏

clone函数调用
    #include <sched.h>
    int clone(int (*fn)(void *fnarg), void *child_stack, int flags, void *arg, ...
                 /* pid_t *pid, struct user_desc *tls, pid_t *ctid */ );
    int __clone2(int (*fn)(void *), void *child_stack_base,size_t stack_size, int flags, void *arg, ...
                 /* pid_t *pid, struct user_desc *tls, pid_t *ctid */ );
    指向子进程执行时调用的函数，fnarg是传给该函数的参数，child_stack是你为子进程分配的堆栈指针，flags通过将下表中的值相或得到，arg被传送给子函数，他的取值和用法完全有你决定，因为他为函数提供了上下文，用他从父进程向任何子进程传送数据，clone返回创建进程的进程ID，出错的话返回－1，设置errno，并不建立子进程。
    CLONE_VM                若设置，父子进程运行在同一段内存
    CLONE_FS                若设置，父子进程共享在root文件系统，当前工作目录以及umask信息
    CLONE_FILES         若设置，父子信息共享文件描述服
    CLONE_SIGHAND       若设置，父子进程共享在父进程上的信号处理器
    CLONE_PID           若设置，父子进程具有相同的PID

pthread接口
    一，建立一个新的线程
        #include <pthread.h>
        int pthread_create(pthread_t *restrict thread,
              const pthread_attr_t *restrict attr,
              void *(*start_routine)(void*), void *restrict arg);
        thread用来保存新线程的标识符，attr决定了对线程应用哪种线程属性，start_routine指向线程要执行的函数的指针，arg他是传递给前面的函数的参数，如果他有意义，则由用户来定义。pthread_create()执行成功返回0，并在thread中保存线程的标识符，失败则返回一个非零的退出码。
    二，结束一个线程
        #include <pthread.h>
        void pthread_exit(void *value_ptr);
        pthread_exit()函数用来终止当前的线程，并返回valure_ptr，该值可由父线程或其他线程通过pthread_join来检索。一个线程也可以简单的从其初始化函数的返回来终止。
    三，等待一个线程结束
        #include <pthread.h>
        int pthread_join(pthread_t thread, void **value_ptr);
        函数pthread_join()用来挂起当前的线程，直到thread指定的线程运行结束为止。thread用来指定线程，value_ptr为用户定义的一个指针，他可以用来存储等待进程的返回值。其他线程不能对同一线程再应用pthread_join函数。
    四，登记函数
        #include <pthread.h>
        int pthread_atfork( void (*prepare)(void), /*在创建新线程之前调用*/
                                    void (*parent)(void),   /*在父线程中随后调用*/
                                    void (*child)(void));   /*建立好子线程后立即在子线程中调用*/
        pthread_atfork()函数登记三个函数，用来在某个时间来调用。他们都可以为NULL，此时，对应的函数将不发生调用。可以通过多次调用pthread_atfork函数登记多组处理函数。如果执行成功返回0，否则返回出错代码。注意，在即将出台的POSIX线程标准中，将不再包含pthread_atfork的调用。
    五，取消线程
        #include <pthread.h>
        int pthread_cancel(pthread_t thread);
        int pthread_setcancelstate(int state, int *oldstate);
        int pthread_setcanceltype(int type, int *oldtype);
        void pthread_testcancel(void);
        pthread_cancel用来取消thread指定的线程，pthread_setcancelstate用来设置他的取消状态，state是新状态，oldstate用来保存旧的状态，他可以是NULL，state的值可以是：
            PTHREAD_CANCEL_ENABLE   允许请求取消
            PTHREAD_CANCEL_DISABLE 忽略取消请求
        pthread_setcanceltype用来改变一个线程对取消请求的响应方式，type的取值可以是：
            PTHREAD_CANCEL_ASYNCHRONOUS 立即取消
            PTHREAD_CANCEL_DEFERRED         延迟取消直至下一个取消点，取消点用pthread_setcancel来建立，如果有任何正被挂起的取消请求，这个函数就会取消当前的线程，还类函数中，如果成功返回0，否则返回出错代码。
    六，线程结束处理
        #include <pthread.h>
        void pthread_cleanup_pop(int execute);
        void pthread_cleanup_push(void (*routine)(void*), void *arg);
        当在线程中调用pthread_exit或者线程允许取消请求，而又到达一个取消点时，就调用routine函数，并将arg作为参数。处理函数被压入一个栈中，所以，当使用pthread_cleanup_pop时，取消最近的一个压入的函数，如果execute不为0，表明栈中还有可用的处理函数，此时，也会被执行，POSIX标准要求，每一个入栈操作都要对应一个出栈操作。
    七，线程挂起
        #include <pthread.h>
        pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
        int pthread_cond_destroy(pthread_cond_t *cond);
        int pthread_cond_init(pthread_cond_t *restrict cond,
              const pthread_condattr_t *restrict attr);
        int pthread_cond_broadcast(pthread_cond_t *cond);
        int pthread_cond_signal(pthread_cond_t *cond);
        int pthread_cond_timedwait(pthread_cond_t *restrict cond,
              pthread_mutex_t *restrict mutex,
              const struct timespec *restrict abstime);
        int pthread_cond_wait(pthread_cond_t *restrict cond,
              pthread_mutex_t *restrict mutex);
        函数pthread_cond_init()用来初始化一个cond_t类型的对象，Linux中会忽略第二个参数，大多数的Linux的pthread程序只是简单的把PTHREAD_COND_INITIALIZER复制给attr，函数pthread_cond_destory()是cond_t类型对象的析构器，检查有没有线程正在等待条件的情况。pthread_cond_signal用来重启一个并且唯一的一个正在等待条件的进程，pthread_cond_broatcase与pthread_cond_signal的区别是他会重启所有正在等待条件的线程。这两个函数中的cond参数表示条件。pthread_cond_wait用来解开mutex指出的一个互斥锁，然后等待变量cond上的信号，pthread_cond_timedwait函数的功能与此类似，但他只等待abstime指定的时间。上述所有的函数成功后返回0，而在出错时返回错误代码。
    八，线程比较
        #include <pthread.h>
        int pthread_equal(pthread_t t1, pthread_t t2);
        这个函数用来比较线程ID t1，t2引用的是不是同一个线程，是则返回0，否则返回非0；
    九，线程属性
        线程的属性控制着一个线程在他整个生命周期的行为，
        属性                值                                  含义
        datachstatc     PTHREAD_CREATE_JOINABLE     可切入的状态
                            PTHREAD_CREATE_DETACHED     被分离的状态
        schedpolicy     SCHED_OTHER                     正常，非实时
                            SCHED_RR                            实时，循环
                            SCHED_FIFO                      实时，先入先出
        schedparam      与策略有关
        inheritsched    PTHREAD_EXPLICIT_SCHED      由schedpolice和schedparam设置，从
                            PTHREAD_INHERIT_SCHED       父进程继承
        scope               PTHREAD_SCOPE_SYSTEM            一个线程一个系统时间片，线程共享系统
                            PTHREAD_SCOPE_PROCESS       时间片（Linux不支持）
        下列函数控制者线程属性对象，注意，这些调用不能控制和线程直接相关联的属性，产生的属性对象通常要传递给pthread_create函数。
        #include <pthread.h>
        int pthread_attr_destroy(pthread_attr_t *attr);
        int pthread_attr_init(pthread_attr_t *attr);
        int pthread_attr_getdetachstate(const pthread_attr_t *attr,
            int *detachstate);
        int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);
        int pthread_attr_getschedpolicy(const pthread_attr_t *restrict attr,
              int *restrict policy);
        int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy);
        int pthread_attr_getschedparam(const pthread_attr_t *restrict attr,
              struct sched_param *restrict param);
        int pthread_attr_setschedparam(pthread_attr_t *restrict attr,
              const struct sched_param *restrict param);
        int pthread_attr_getinheritsched(const pthread_attr_t *restrict attr,
              int *restrict inheritsched);
        int pthread_attr_setinheritsched(pthread_attr_t *attr,
              int inheritsched);
        int pthread_attr_getscope(const pthread_attr_t *restrict attr,
              int *restrict contentionscope);
        int pthread_attr_setscope(pthread_attr_t *attr, int contentionscope);
    十，互斥
        用来保护被多个线程共享的数据不会被同时修改。一个互斥锁只有两种状态，加锁与解锁，加锁的互斥不但不让其他线程访问，而且互斥也规上锁进程所有，任何进程都能访问解锁互斥，但他却不归任何线程所有。
        #include <pthread.h>
        pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
        int pthread_mutex_destroy(pthread_mutex_t *mutex);
        int pthread_mutex_init(pthread_mutex_t *restrict mutex,
              const pthread_mutexattr_t *restrict attr);
        int pthread_mutex_lock(pthread_mutex_t *mutex);
        int pthread_mutex_trylock(pthread_mutex_t *mutex);
        int pthread_mutex_unlock(pthread_mutex_t *mutex);
        pthread_mutex_init函数创建指针mutex指向的互斥，并且用mutexattr指定的属性初始化该互斥。
        互斥属性
        属性                                                    描述                    备注
        PTHREAD_MUTEX_INITIALIZER                       创建一个快速互斥        调用线程被阻塞直至拥有互斥的线程解锁为止
        PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP      创建一个递归互斥        不阻塞调用进程，但返回一个出错代码EDEADLK
        PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP 创建一个检错互斥        成功返回并增加调用线程上锁的次数，但必须拥有同样次数的解锁
        除了使用mutex参数，还可以使用下面的初始化过程静态创建pthread_mutex_t变量。
        pthread_mutex_t fastmutex = PTHREAD_MUTEX_INITIALIZER;
        pthread_mutex_t recmutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
        pthread_mutex_t errchkmutex ＝ PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP；