Linux—多线程编程

1.什么是线程：
　线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。线程包含了表示进程内执行环境必须的信息，其中包括进程中表示线程的线程ID、一组寄存器值、栈、调度优先级和策略、信号屏蔽字、errno常量以及线程私有数据。进程的所有信息对该进程的所有线程都是共享的，包括可执行的程序文本、程序的全局内存和堆内存、栈以及文件描述符。在Unix和类Unix操作系统中线程也被称为轻量级进程（lightweight processes），但轻量级进程更多指的是内核线程（kernel thread），而把用户线程（user thread）称为线程。

2.为什么要用线程：
1.和进程相比，它是一种非常"节俭"的多任务操作方式。它们彼此之间使用相同的地址空间，共享大部分数据，启动一个线程所花费的空间远远小于启动一个进程所花费的空间，而且，线程间彼此切换所需的时间也远远小于进程间切换所需要的时间
2.一个线程的数据可以直接为其它线程所用，这不仅快捷，而且方便。
3. 提高应用程序响应。这对图形界面的程序尤其有意义，当一个操作耗时很长时，整个系统都会等待这个操作，此时程序不会响应键盘、鼠标、菜单的操作，而使用多线程技术，将耗时长的操作（time consuming）置于一个新的线程，可以避免这种尴尬的情况。
4. 使多CPU系统更加有效。操作系统会保证当线程数不大于CPU数目时，不同的线程运行于不同的CPU上。
5. 改善程序结构。一个既长又复杂的进程可以考虑分为多个线程，成为几个独立或半独立的运行部分，这样的程序会利于理解和修改。

3.线程的API介绍:
线程一共有以上这些API
线程创建：pthread_create
原型：

int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);

第一个参数是哪一个线程地址，第二个是属性，默认NULL，第三个是线程要执行的函数，第四个是向函数传的参数
示例：

void *func1(void *arg)
{
}
int main()
{
ret=pthread_create(&t1,NULL,func1,(void *)&param);
}

线程退出：pthread_exit
一般在线程的执行函数末尾调用
原型：

int pthread_exit(void *rval_ptr);

示例：

pthread_exit（0）;

线程等待：pthread_join
原型：

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

示例;

 pthread_join(t1,NULL);

线程ID获取：

pthread_t pthread_self(void);

一般我们把它打印出来可以这么写

printf("t1:ld thread is create\n",(unsigned long)pthread_self());

创建及销毁互斥锁

int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
int pthread_mutex_destroy(pthread_mutex_t *mutex);

这里我们对互斥锁的初始化可以用动态初始化也可以用静态初始化：
动态：

pthread_mutex_t mutex//全局变量
int main()
{
pthread_mutex_init(&mutex,NULL);
}

静态：

pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;//全局变量

销毁互斥锁示例：

 pthread_mutex_destroy(&mutex);

加锁解锁：

int pthread_mutex_lock(pthread_mutex_t mutex);
int pthread_mutex_unlock(pthread_mutex_t mutex);

示例：

pthread_mutex_lock(&mutex);
pthread_mutex_unlock(&mutex);

互斥锁条件变量（控制在什么情况下开锁解锁）
创建及销毁条件变量

int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);
int pthread_cond_destroy(pthread_cond_t *cond);

同样对于创建变量初始化也有静态和动态：
动态：

pthread_cond_t cond;全局变量
int mian
{
pthread_cond_init(&cond,NULL);
}

静态：

pthread_cond_t cond=PTHREAD_COND_INITIALIZER;全局变量

销毁条件变量：

pthread_cond_destroy(&cond);

等待：
当条件变量发生某种改变或者满足某种要求时触发，该函数下面的语句得以执行
原型：

int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);

第一个参数是条件变量，第二个是互斥锁
示例：

pthread_cond_wait(&cond,&mutex);

触发：

int pthread_cond_signal(pthread_cond_t cond);
int pthread_cond_broadcast(pthread_cond_t cond);

用于通知线程条件已经满足。pthread_cond_signal函数将唤醒等待该条件的某个线程，而pthread_cond_broadcast函数将唤醒等待该条件的所有进程。
示例：

 pthread_cond_signal(&cond);

下面我们来讲一讲应用场景：
我们给定一个全局变量初值为0，让两个线程来改变它的值，满足每次自加到3的时候，又变成0，周而复始。

1. t2线程实现当全局变量<=3，全局变量++；
2. t1线程实现每次全局变量=3，使其变成0。

代码示例：

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

int g_data = 0;

pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond=PTHREAD_COND_INITIALIZER;

void *func1(void *arg)
{
        printf("t1:ld thread is create\n",(unsigned long)pthread_self());
        printf("t1:param is %d\n",*((int*)arg));

        while(1){
                pthread_cond_wait(&cond,&mutex);
                printf("t1 run========================\n");

                printf("t1: %d\n",g_data);
                g_data=0;
                sleep(1);
        }
}

void *func2(void *arg)
{
        printf("t2:ld thread is create\n",(unsigned long)pthread_self());
        printf("t2:param is %d\n",*((int*)arg));

        while(1){
                printf("t2:%d\n",g_data);
                pthread_mutex_lock(&mutex);
                g_data++;
                 if(g_data==3){
                        pthread_cond_signal(&cond);
                 }
                pthread_mutex_unlock(&mutex);
                sleep(1);
                }
}

int main(int argc, char **argv)
{
        int ret;
        int ret2;
        int param=100;
        pthread_t t1;
        pthread_t t2;

//      pthread_mutex_init(&mutex,NULL);
//      pthread_cond_init(&cond,NULL);

        ret=pthread_create(&t1,NULL,func1,(void *)&param);
        ret2=pthread_create(&t1,NULL,func2,(void *)&param);

        printf("main:%ld\n",(unsigned long)pthread_self());

        pthread_join(t1,NULL);
        pthread_join(t2,NULL);

        pthread_mutex_destroy(&mutex);
        pthread_cond_destroy(&cond);

return 0;
}

来讲一下原理：
如果线程t1先抢到资源， 那么会有一个wait来等待条件变量的改变，那么自然轮到t2线程执行。
如果t2线程先抢到资源，那么会开启互斥锁，一直运行全局变量++，直到全局变量=3，打开互斥锁，随后sleep（1），那么t1自然会抢到资源，这时条件变量已经改变，那么下面的语句就可以执行，全局变量重置为0，然后sleep（1），那么t2又得到运行，t1只能等到条件变量再次改变发出信号才能得到运行，周而复始。

让我们来看看运行结果：
以上就是关于Linux多线程编程的介绍，尚有不足之处，请各位大神指正。
文章参考：https://www.cnblogs.com/xiehongfeng100/p/4620852.html
salute CLC