文章目录

• 一、线程
• • 1、线程概述（与进程的区别及线程的优势）
  • 2、线程创建等待及退出
  • 3、线程共享内存空间的代码验证
  • 4、线程同步之互斥量加锁解锁
  • 5、互斥锁限制共享资源的访问
  • 6、什么情况造成死锁
  • 7、线程条件控制实现线程的同步
• 二、往期文章

一、线程

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系统编程–网络编程