一、线程

1、线程概述（与进程的区别及线程的优势）

多线程开发在 Linux 平台上已经有成熟的 pthread 库支持。其涉及的多线程开发的最基本概念主要包含三点：线程，互斥锁，条件。其中，线程操作又分线程的创建，退出，等待 3 种。互斥锁则包括 4 种操作，分别是创建，销毁，加锁和解锁。条件操作有 5 种操作：创建，销毁，触发，广播和等待。其他的一些线程扩展概念，如信号灯等，都可以通过上面的三个基本元素的基本操作封装出来。详细请见表：

线程与进程的区别:
典型的UNIX/Linux进程可以看成只有一个控制线程：一个进程在同一时刻只做一件事情。有了多个控制线程后，在程序设计时可以把进程设计成在同一时刻做不止一件事，每个线程各自处理独立的任务。

进程是程序执行时的一个实例，是担当分配系统资源（CPU时间、内存等）的基本单位。在面向线程设计的系统中，进程本身不是基本运行单位，而是线程的容器。程序本身只是指令、数据及其组织形式的描述，进程才是程序（那些指令和数据）的真正运行实例。

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

“进程——资源分配的最小单位，线程——程序执行的最小单位”

进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。
　　
线程的优势：
进程与线程的区别就是我们使用线程的理由。总的来说就是：进程有独立的地址空间，线程没有单独的地址空间（同一进程内的线程共享进程的地址空间）。

使用多线程的理由之一是和进程相比，它是一种非常**“节俭”**的多任务操作方式。我们知道，在Linux系统下，启动一个新的进程必须分配给它独立的地址空间，建立众多的数据表来维护它的代码段、堆栈段和数据段，这是一种"昂贵"的多任务工作方式。而运行于一个进程中的多个线程，它们彼此之间使用相同的地址空间，共享大部分数据，启动一个线程所花费的空间远远小于启动一个进程所花费的空间，而且，线程间彼此切换所需的时间也远远小于进程间切换所需要的时间。据统计，总的说来，一个进程的开销大约是一个线程开销的30倍左右，当然，在具体的系统上，这个数据可能会有较大的区别。

使用多线程的理由之二是线程间方便的通信机制。对不同进程来说，它们具有独立的数据空间，要进行数据的传递只能通过通信的方式进行，这种方式不仅费时，而且很不方便。线程则不然，由于同一进程下的线程之间共享数据空间，所以一个线程的数据可以直接为其它线程所用，这不仅快捷，而且方便。当然，数据的共享也带来其他一些问题，有的变量不能同时被两个线程所修改，有的子程序中声明为static的数据更有可能给多线程程序带来灾难性的打击，这些正是编写多线程程序时最需要注意的地方。

除了以上所说的优点外，不和进程比较，多线程程序作为一种多任务、并发的工作方式，当然有以下的优点：

• 提高应用程序响应。这对图形界面的程序尤其有意义，当一个操作耗时很长时，整个系统都会等待这个操作，此时程序不会响应键盘、鼠标、菜单的操作，而使用多线程技术，将耗时长的操作（time
  consuming）置于一个新的线程，可以避免这种尴尬的情况。
• 使多CPU系统更加有效。操作系统会保证当线程数不大于CPU数目时，不同的线程运行于不同的CPU上。
• 改善程序结构。一个既长又复杂的进程可以考虑分为多个线程，成为几个独立或半独立的运行部分，这样的程序会利于理解和修改。

2、线程创建等待及退出

线程创建函数:

• 当pthread_create成功返回时，新创建线程的线程D会被设置成tidp指向的内存单元。attr参数用于定制各种不同的线程属性。现在我们把它置为NULL，创建一个具有默认属性的线程。
• 新创建的线程从start_rtn函数的地址开始运行，该函数只有一个无类型指针参数arg。如果需要向start_rtn函数传递的参数有一个以上，那么需要把这些参数放到一个结构中，然后把这个结构的地址作为arg参数传入。
• 线程创建时并不能保证哪个线程会先运行:是新创建的线程，还是调用线程。新创建的线程可以访问进程的地址空间，并且继承调用线程的浮点环境和信号屏蔽字，但是该线程的挂起信号集会被清除。

//create.c
#include<stdio.h>
#include<pthread.h>//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
void *func1(void *arg)
{static int ret = 10;printf("t1:%ld thread is create\n",(unsigned long)pthread_self());printf("t1:param is %d\n",*((int *)arg));pthread_exit((void *)&ret);
}int main()
{int ret;int param = 100;pthread_t t1;int *pret = NULL;ret = pthread_create(&t1,NULL,func1,(void *)&param);if(ret == 0){printf("main:create t1 successful\n");}printf("main:%ld\n",(unsigned long)pthread_self());pthread_join(t1,(void **)&pret);return 0;
}

输出结果:

3、线程共享内存空间的代码验证

//Test1.c
#include<stdio.h>
#include<pthread.h>
#include <unistd.h>
//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
int g_data = 0;             //定义一个全局变量
void *func1(void *arg)
{static int ret = 10;    //定义一个静态变量printf("t1:%ld thread is create\n",(unsigned long)pthread_self());printf("t1:param is %d\n",*((int *)arg));while(1){printf("t1:%d\n",g_data++);sleep(1);}pthread_exit((void *)&ret);}void *func2(void *arg)
{static int ret = 10;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++);sleep(1);}pthread_exit((void *)&ret);
}int main()
{int ret;int param = 100;pthread_t t1;pthread_t t2;int *pret = NULL;ret = pthread_create(&t1,NULL,func1,(void *)&param);if(ret == 0){printf("main:create t1 successful\n");}	ret = pthread_create(&t2,NULL,func2,(void *)&param);if(ret == 0){printf("main:create t2 successful\n");}while(1){printf("main:%d\n",g_data++);sleep(1);}printf("main:%ld\n",(unsigned long)pthread_self());pthread_join(t1,NULL);pthread_join(t2,NULL);return 0;
}

输出结果:

从上面运行结果可以知道，线程是共享内存空间的。

4、线程同步之互斥量加锁解锁

//Test3.c
#include<stdio.h>
#include<pthread.h>
#include <unistd.h>//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
int g_data = 0;
pthread_mutex_t mutex;void *func1(void *arg)
{int i;;pthread_mutex_lock(&mutex);for(i=0;i<5;i++){printf("t1:%ld thread is create\n",(unsigned long)pthread_self());printf("t1:param is %d\n",*((int *)arg));sleep(1);}pthread_mutex_unlock(&mutex);
}
void *func2(void *arg)
{pthread_mutex_lock(&mutex);printf("t2:%ld thread is create\n",(unsigned long)pthread_self());printf("t2:param is %d\n",*((int *)arg));pthread_mutex_unlock(&mutex);}void *func3(void *arg)
{pthread_mutex_lock(&mutex);printf("t3:%ld thread is create\n",(unsigned long)pthread_self());printf("t3:param is %d\n",*((int *)arg));pthread_mutex_unlock(&mutex);}int main()
{int ret;int param = 100;pthread_t t1;pthread_t t2;pthread_t t3;pthread_mutex_init(&mutex,NULL);int *pret = NULL;ret = pthread_create(&t1,NULL,func1,(void *)&param);if(ret == 0){printf("main:create t1 successful\n");}	ret = pthread_create(&t2,NULL,func2,(void *)&param);if(ret == 0){printf("main:create t2 successful\n");}ret = pthread_create(&t3,NULL,func3,(void *)&param);if(ret == 0){printf("main:create t3 successful\n");}printf("main:%ld\n",(unsigned long)pthread_self());pthread_join(t1,NULL);pthread_join(t2,NULL);pthread_join(t3,NULL);pthread_mutex_destroy(&mutex);return 0;
}

输出结果:

5、互斥锁限制共享资源的访问

实现功能:当全局变量g_data等于3时，线程t1退出

//Test3.c
#include<stdio.h>
#include<pthread.h>#include <unistd.h>
#include<stdlib.h>//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
int g_data = 0;
pthread_mutex_t mutex;void *func1(void *arg)
{	printf("t1:%ld thread is create\n",(unsigned long)pthread_self());printf("t1:param is %d\n",*((int *)arg));pthread_mutex_lock(&mutex);while(1){printf("t1:%d\n",g_data++);sleep(1);if(g_data == 3){pthread_mutex_unlock(&mutex);printf("t1 quit==============\n");//pthread_exit(NULL);exit(0);}}
}
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++;pthread_mutex_unlock(&mutex);sleep(1);}
}int main()
{int ret;int param = 100;pthread_t t1;pthread_t t2;pthread_mutex_init(&mutex,NULL);int *pret = NULL;ret = pthread_create(&t1,NULL,func1,(void *)&param);if(ret == 0){printf("main:create t1 successful\n");}	ret = pthread_create(&t1,NULL,func2,(void *)&param);if(ret == 0){printf("main:create t2 successful\n");}while(1){printf("main:%d\n",g_data);sleep(1);}pthread_join(t1,NULL);pthread_join(t2,NULL);pthread_mutex_destroy(&mutex);return 0;
}

输出结果:

6、什么情况造成死锁

如果线程试图对同一个互斥量加锁两次，那么它自身就会陷入死锁状态，但是使用互斥量时，还有其他不太明显的方式也能产生死锁。例如，程序中使用一个以上的互斥量时，如果允许一个线程–直占有第一个互斥量，并且在试图锁住第二个互斥量时处于阻塞状态，但是拥有第二个互斥量的线程也在试图锁住第一个互斥量。因为两个线程都在相互请求另一个线程拥有的资源，所以这两个线程都无法向前运行,于是就产生死锁。

//Test4.c
#include<stdio.h>
#include<pthread.h>
#include <unistd.h>
#include<stdlib.h>//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
int g_data = 0; //定义一个全局变量
pthread_mutex_t mutex1;
pthread_mutex_t mutex2;void *func1(void *arg)
{	pthread_mutex_lock(&mutex1);pthread_mutex_lock(&mutex2);	
}
void *func2(void *arg)
{pthread_mutex_lock(&mutex2);pthread_mutex_lock(&mutex1);
}int main()
{int ret;int param = 100;pthread_t t1;pthread_t t2;//创建两个互斥锁pthread_mutex_init(&mutex1,NULL);pthread_mutex_init(&mutex2,NULL);int *pret = NULL;ret = pthread_create(&t1,NULL,func1,(void *)&param);if(ret == 0){printf("main:create t1 successful\n");}	ret = pthread_create(&t2,NULL,func2,(void *)&param);if(ret == 0){printf("main:create t2 successful\n");}pthread_join(t1,NULL);pthread_join(t2,NULL);pthread_mutex_destroy(&mutex1);pthread_mutex_destroy(&mutex2);return 0;
}

输出结果:

可以看出程序卡住了

7、线程条件控制实现线程的同步

//Test5.c
#include<pthread.h>
#include <unistd.h>
#include<stdlib.h>
#include<stdio.h>
//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
int g_data = 0;
pthread_cond_t cond;
pthread_mutex_t mutex;void *func1(void *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)
{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 ret;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);ret = pthread_create(&t2,NULL,func2,(void *)&param);pthread_join(t1,NULL);pthread_join(t2,NULL);pthread_mutex_destroy(&mutex);pthread_cond_destroy(&cond);return 0;
}

输出结果:

二、往期文章

1、入门Linux系统编程–文件
2、入门Linux系统编程–进程
3、入门Linux系统编程–线程
4、入门Linux系统编程–进程间通信
5、入门Linux系统编程–网络编程