线程基础

这篇博客介绍了线程(thread)的基本概念

什么是线程

计算机中可能同时运行多个进程(process)，多个进程分别运行不同的任务。在一个进程内
部可能同时运行多个进程，多个进程也分别执行自己的任务。
初看起来，线程和进程似乎差不多，多线程的功能似乎都能被多进程取代，可实际上两者
还是有很大的区别。
最主要的区别是资源的共享。不同进程之间互相完全独立，不共享任何资源（例如内存）,
而同一个进程内的线程，则天生共享该进程的资源，当两个线程同时访问进程内同一个变量
时， 可能需要进行并发控制。而当两个进程需要进行资源共享时，则需要单独的技术(比如
管道)来实现进程之间的通信

进程的基本操作

• 基本操作

• 例子

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

/**
 * 编译时需要链接上pthread库
 * gcc -lpthread t.c
 */

/**
 * 进程退出前执行的函数
 */
void
cleanup(void *arg)
{
    printf("clean up thread\n");
}

/**
 * 新建进程后，开始执行的函数
 */
void *
thr_fn(void *arg)
{
    printf("new trhead, arg is %s\n", (char *)arg);
    pthread_cleanup_push(cleanup, NULL);
    //退出当前进程，状态码是1
    if (arg)
        pthread_exit((void *)1);
    pthread_cleanup_pop(0);
}

int
main(int argc, char *argv[])
{
    pthread_t tid;
    char *msg = "frostbite";
    int err;
    //创建进程
    err = pthread_create(&tid, NULL, thr_fn, msg);
    if (err != 0){
        printf("fail to create thread\n");
        exit(1);
    }

    void *tret;
    //获取进程退出的状态码
    err = pthread_join(tid, &tret);
    if (err != 0){
        printf("fail to get pthread exit status\n");
        exit(2);
    }

    printf("thread exit code is %ld\n", (long)tret);

    exit(0);

}

输出结果为：

[song@miPad unix]$ gcc -lpthread t.c
[song@miPad unix]$ ./a.out 
new trhead, arg is frostbite
clean up thread
thread exit code is 1

多线程的同步

多个线程之间会共享同一变量，由此带来了同步问题，思考下面的简单代码

//假设a的初始值为0
a = a + 1;

当两个线程分别执行上述代码后，a的值会是多少呢？可能的执行流程如下

   +---------+                   +---------+
   | thread1 |                   | thread2 |
   +---------+                   +---------+
       |                              |
       |                              |
     取到a=0                    等待cpu调度执行
       |                              |
       |                              |
       |                           取到a=0
       |                              |
  执行a=a+1,执行完成后a=1       等待cpu调度执行
  将a=1写入内存                       
       |                              |
       |                        执行a=a+1，执行完成后a=1      
       |                        将a=1写入内存
                                    

两个线程同步执行，a=a+1的操作一个机器周期无法完成，理论上存在上图所示的执行流
程，执行完成后，a等于1,而不是我们希望的2。
这就是多个进程同时访问一个变量造成的问题，因此我们需要借助一些同步机制(比如锁)，
保证同一时刻，只有一个进程在操作变量a。
锁的基本原理是访问变量a前，需要先获取锁，同一时刻，只有一个进程能够获取锁，进程
操作完成，释放锁，保证同一时刻，只有一个线程能够访问变量a

同步机制

1. 互斥量(Mutexes)
   这是一种最基本的锁，同一时刻只有一个线程能过获取到mutexes
2. 读写锁
   这种锁对变保护时，细分为读锁和写锁，同一时刻可以有多个线程获取到读锁，只有一个线
   程能获取到写锁。读锁和写锁互斥: 已经有线程获取写锁后，其他线程获取读锁或者写锁都
   必须等待；已经有线程获取到读锁后，其他线程尝试获取写锁也必须等待。
   这种类型的锁适用于读多写少的场合
3. 条件变量(Condition Variable)
   一个线程等待某个条件满足后，被自动唤醒。通常这个条件的满足依赖另外一个线程
4. 自旋锁(spin lock)
   功能和一般的锁相同，区别在于一般的锁在等待期间都是进入睡眠状态，不消耗cpu，这钟
   锁在等待期间，仍然占据cpu，适用于实时性要求高的场合
5. Barriers
   这种类型的锁用于协调多个线程的工作，只有多个线程都达到各自要求的状态，才进行下一
   步骤。
   比如，10个线程同时分工计算1加到100,只有这10线程都完成了各自计算后，才能合并他们
   的结果，得到最后的结果