小记——linux线程

矫情吗；* 2022-09-23 13:49 131阅读 0赞

linux线程标准是POSIX threads, 也就是著名的 Pthreads。

Pthreads实现于glibc库中，分别有两个版本：LinuxThreads和Native POSIX Thread Library (NPTL) 。libc2.6后包含了NPTL。后续版本是NGPL(Next Generation POSIX Threads)。

现在一般说的linux线程多指NPTL版本，本文也只讨论NPTL版本的线程及其相关API。

头文件\#include <pthread.h>

**APIS:**

1. 创建线程

int pthread_create (pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);

Upon successful invocation, a new thread is created and begins executing the function provided by start\_routine, passed the sole argument arg.

线程创建API的特别之处在于其失败时并不设置errno。下面是示例代码：

pthread_t tread;
    int ret;
    ret = pthread_create (&thread, NULL, start_routine, NULL);
    if (!ret) {
    errno = ret;
    perror("pthread_create");
    return -1;
    }

2. 获得自身线程

pthread_t pthread_self (void);

Usage is simple, because the function cannot fail  
3. 线程相等性判断

int pthread_equal (pthread_t t1, pthread_t t2);

通过线程ID来判断其相等性，相等则返回非零

4. 线程本身退出

Threads may terminate under several circumstances, all of which have analogues to process termination:  
• If a thread returns from its start routine, it terminates. This is akin to “falling off the end” of main().  
• If a thread invokes the pthread\_exit() function (discussed subsequently), it terminates. This is akin to calling exit().  
• If the thread is canceled by another thread via the pthread\_cancel() function, it terminates. This is akin to being sent the SIGKILL signal via kill().

4.1 结束自己

void pthread_exit (void *retval);

4.2 结束其它线程

int pthread_cancel (pthread_t thread);

该函数会阻塞直到指定的线程结束，当指定的线程是不可被其它线程结束时，该函数会一直阻塞。

一个线程可以设置为可被其它线程结束和不可被其它线程结束，缺省为可以被其它线程结束。

4.2.1

int pthread_setcancelstate (int state, int *oldstate);

设置线程可被其它线程结束与否

state may be PTHREAD\_CANCEL\_ENABLE or PTHREAD\_CANCEL\_DISABLE, to enable or disable cancellation, respectively.

4.2.2

int pthread_setcanceltype (int type, int *oldtype);

设置结束类型：异步或者延迟

type may be PTHREAD\_CANCEL\_ASYNCHRONOUS or PTHREAD\_CANCEL\_DEFERRED, to use asynchronous or deferred cancellation, respectively

5. 等待线程结束

int pthread_join (pthread_t thread, void **retval);

如果等待的线程已经结束，函数将立刻返回。

Once thread terminates, the invoking thread is woken up and, if retval is not NULL, provided the return value the terminated thread passed to pthread\_exit() or returned from its start routine.

6. 分离线程

int pthread_detach (pthread_t thread);

对于不希望join的线程，可将其detach.

On success, pthread\_detach() detaches the thread specified by thread and returns zero. Results are undefined if you call pthread\_detach() on a thread that is already detached. On error, the function returns ESRCH indicating that thread is invalid.  
**EXAMPLE:**

#include <stdlib.h>
    #include <stdio.h>
    #include <pthread.h>
    void * start_thread (void *message)
    {
    printf ("%s\n", (const char *) message);
    return message;
    }
    int main (void)
    {
    pthread_t thing1, thing2;
    const char *message1 = "Thing 1";
    const char *message2 = "Thing 2";
    /* Create two threads, each with a different message. */
    pthread_create (&thing1, NULL, start_thread, (void *) message1);
    pthread_create (&thing2, NULL, start_thread, (void *) message2);
    /*
    * Wait for the threads to exit. If we didn't join here,
    * we'd risk terminating this main thread before the
    * other two threads finished.
    */
    pthread_join (thing1, NULL);
    pthread_join (thing2, NULL);
    return 0;
    }

7. 互斥变量（Pthread Mutexes）

互斥变量仅仅能被一个线程使用。

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
    int pthread_mutex_lock (pthread_mutex_t *mutex);
    int pthread_mutex_unlock (pthread_mutex_t *mutex);

实现局部锁：

class ScopedMutex {
    public:
    ScopedMutex (pthread_mutex_t& mutex)
    :mutex_ (mutex)
    {
        pthread_mutex_lock (&mutex_);
    }
     ~ScopedMutex ()
    {
        pthread_mutex_unlock (&mutex_);
    }
    private:
        pthread_mutex_t& mutex_;
    };