Linux系统编程（四）Linux多线程编程

进程和线程的区别

进程有独立的地址空间，线程没有单独的地址空间（同一进程内的线程共享进程的地址空间）。

进程：
进程是一个具有一定独立功能的程序的一次运行活动，同时也是资源分配的最小单元；
进程是程序执行时的一个实例，即它是程序已经执行到某种程度的数据结构的汇集。
从内核的观点看，进程的目的就是担当分配系统资源（CPU时间、内存等）的基本单位。
Linux系统是一个多进程的系统，它的进程之间具有并行性、互不干扰等特点。也就是说，每个进程都是一个独立的运行单位，拥有各自的权利和责任。其中，各个进程都运行在独立的虚拟地址空间，因此，即使一个进程发生异常，它也不会影响到系统中的其他进程。
线程：
线程是进程的一个执行流，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。
一个进程由几个线程组成（拥有很多相对独立的执行流的用户程序共享应用程序的大部分数据结构），线程与同属一个进程的其他的线程共享进程所拥有的全部资源。
“进程——资源分配的最小单位，线程——程序执行的最小单位”
进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。
线程有自己的堆栈和局部变量，但线程没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。

线程的优点

使用多线程的理由之一是：
和进程相比，它是一种非常“节俭”的多任务操作方式.在Linux系统下，启动一个新的进程必须分配给它独立的地址空间，建立众多的数据表来维护它的代码段、堆栈段和数据段，这是一种"昂贵"的多任务工作方式
运行于一个进程中的多个线程，它们之间使用相同的地址空间，而且线程间彼此切换所需的时间也远远小于进程间切换所需要的时间.据统计，一个进程的开销大约是一个线程开销的30倍左右
使用多线程的理由之二是：
线程间方便的通信机制。对不同进程来说，它们具有独立的数据空间，要进行数据的传递只能通过进程间通信的方式进行，这种方式不仅费时，而且很不方便。线程则不然，由于同一进程下的线程之间共享数据空间，所以一个线程的数据可以直接为其它线程所用，这不仅快捷，而且方便

除了以上所说的优点外，多线程程序作为一种多任务、并发的工作方式，有如下优点：
使多CPU系统更加有效.操作系统会保证当线程数不大于CPU数目时，不同的线程运行于不同的CPU上.
改善程序结构.一个既长又复杂的进程可以考虑分为多个线程，成为几个独立或半独立的运行部分，这样的程序会利于理解和修改

多线程的创建

Linux系统下的多线程遵循POSIX线程接口，称为pthread。编写Linux下的多线程程序，需要使用头文件pthread.h，连接时需要使用libpthread.a

#include <stdio.h>

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

pthread_t tid[3];

void delay()
{
	int x = 10000, y;
	while (x > 0)
	{
		y = 30000;
		while (y > 0)
		{
			y--;
		}
		x--;
	}
}

void *mythread1(void *arg)
{
	int i = 5;
	while (i--)
	{
		printf("this is mythread1\n");
		//sleep(1);
		delay();
	}

	pthread_exit((void *)10);    //线程退出
}

void *mythread2(void *arg)
{
	int old;
	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &old);  //立即取消  old保存原来的属性
	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old);  //不允许被取消 old保存原来的属性
	int i = 5;
	while (i--)
	{
		printf("%s\n", (char *)arg);
		//usleep(500000);
		delay();
	}
}

struct Test
{
	char name[32];
	int a;
	char b;
};

void *mythread3(void *arg)
{
	struct Test *t = (struct Test *)arg;
	printf("%s %d %c\n", t->name, t->a, t->b);
	pthread_cancel(tid[1]);   //取消线程1  默认属性 线程运行到下一个取消点的时候被取消
}

int main()
{
	int ret;
	ret = pthread_create(&tid[0], NULL, mythread1, NULL);   //线程号 默认属性  线程函数   不需要传参
	if (ret != 0)
	{
		perror("pthread_create");
		exit(1);
	}

	ret = pthread_create(&tid[1], NULL, mythread2, "helloworld");
	if (ret != 0)
	{
		perror("pthread_create");
		exit(1);
	}

	struct Test t = {"aaa", 10, 'x'};
	ret = pthread_create(&tid[2], NULL, mythread3, (void *)&t);
	if (ret != 0)
	{
		perror("pthread_create");
		exit(1);
	}

	void *status;
	pthread_join(tid[0], &status);   //1、等待线程结束  2、回收线程资源
	printf("线程1退出，退出码是%d\n", (int)status);
	pthread_join(tid[1], &status);
	pthread_join(tid[2], &status);

	return 0;
}

因为pthread的库不是linux系统的库，所以在进行编译的时候要加上 -lpthread

表头文件：
#include <pthread.h>
定义函数：
int pthread_create(pthread_t* tidp,constpthread_attr_tattr,void(start_rtn)(void),voidarg)

tidp：线程id
attr： 线程属性(通常为空)
start_rtn：线程要执行的函数
arg：start_rtn的参数

线程退出
#include <pthread.h>
void pthread_exit(void * rval_ptr)
功能：终止调用线程
Rval_ptr:线程退出返回值的指针

线程等待
#include <pthread.h>
int pthread_join(pthread_t tid,void **rval_ptr)
功能：阻塞调用线程，直到指定的线程终止。
Tid :等待退出的线程id
Rval_ptr：线程退出的返回值的指针

线程的分离

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

void *thread(void *arg)
{
	pthread_detach(pthread_self());  //线程分离，线程运行结束后，自动释放资源
}

int main()
{
	int ret;
	pthread_t tid;

	while (1)
	{
		ret = pthread_create(&tid, NULL, thread, NULL);

		//void *status;
		//pthread_join(tid, &status);  //阻塞的函数  不能在循环中使用
	}
	return 0;

线程同步

进行多线程编程，因为无法知道哪个线程会在哪个时候对共享资源进行操作，因此让如何保护共享资源变得复杂，通过下面这些技术的使用，可以解决线程之间对资源的竞争：
1 互斥量Mutex
2 信号灯Semaphore
3 条件变量Conditions
为什么需要互斥量：
Item * p =queue_list;
Queue_list=queue_list->next;
process_job§;
free§;
当线程1处理完Item *p=queue_list后，系统停止线程1的运行，改而运行线程2。线程2照样取出头节点，然后进行处理，最后释放了该节点。过了段时间，线程1重新得到运行。而这个时候，p所指向的节点已经被线程2释放掉，而线程1对此毫无知晓。他会接着运行process_job§。而这将导致无法预料的后果！
对于这种情况，系统给我们提供了互斥 量.线程在取出头节点前必须要等待互斥量,如果此时有其他线程已经获得该互斥量,那么该线程将会阻塞在这里.只有等到其他线程释放掉该互斥量后，该线程才有可能得到该互斥量。互斥量从本质上说就是一把锁, 提供对共享资源的保护访问
过程：进去一个线进程，把锁锁上，运行完，把锁打开，下一个线进程进去，把锁锁上，运行完在打开。。。
加锁

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

#define SIZE   10

int Ticket = 100;
pthread_mutex_t mutex;    //定义互斥锁

void delay()
{
	int x = 1000, y;
	while (x > 0)
	{
		x--;
		y = 5000;
		while (y > 0)
		{
			y--;
		}
	}
}

void *SaleTicket(void *arg)
{
	int cur_ticket;

	while (1)
	{
		pthread_mutex_lock(&mutex);
		cur_ticket = Ticket;   //获取票数
		if (cur_ticket <= 0)
		{
			pthread_mutex_unlock(&mutex);
			break;
		}

		printf("%u get %d-th ticket!\n", pthread_self(), cur_ticket);
		delay();
		cur_ticket--;
		Ticket = cur_ticket;   //写回数据
		pthread_mutex_unlock(&mutex);
	}
}

int main()
{
	pthread_mutex_init(&mutex, NULL);       //初始化互斥锁

	int i, ret;
	pthread_t tid[SIZE];
	for (i = 0; i < SIZE; i++)
	{
		ret = pthread_create(&tid[i], NULL, SaleTicket, NULL);   //多个线程使用相同的线程函数
		if (ret != 0)
		{
			perror("pthread_create");
			exit(1);
		}
	}

	for (i = 0; i < SIZE; i++)
	{
		void *status;
		pthread_join(tid[i], &status);
	}

	pthread_mutex_destroy(&mutex);   //销毁互斥锁

	return 0;
}

创建锁（互斥量）
#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t 、*mutex,const pthread_mutexattr_t *attr)
int pthread_mutex_destroy(pthread_mutex_t *mutex)
加锁
对共享资源的访问, 要使用互斥量进行加锁, 如果互斥量已经上了锁, 调用线程会阻塞, 直到互斥量被解锁。
int pthread_mutex_lock(pthread_mutex_t *mutex)
int pthread_mutex_trylock(pthread_mutex_t *mutex)
返回值: 成功则返回0, 出错则返回错误编号。
trylock是非阻塞调用模式, 如果互斥量没被锁住, trylock函数将对互斥量加锁, 并获得对共享资源的访问权限; 如果互斥量被锁住了,trylock函数将不会阻塞等待而直接返回EBUSY, 表示共享资源处于忙状态
解锁
在操作完成后，必须给互斥量解锁，也就是前面所说的释放。这样其他等待该锁的线程才有机会获得该锁，否则其他线程将会永远阻塞。
int pthread_mutex_unlock(pthread_mutex_t *mutex)

互斥量和信号量的区别
互斥量mutex要由获得锁的进程来释放（谁获得，谁释放）
而信号量可以由其他线程释放，而且互斥量也就上锁解锁一种变换，mutex的初始值是1；但信号量有多个变化，初始值就不确定。

条件变量加锁
条件变量是指线程达到哪个条件才运行

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

void delay()
{
	int x = 5000, y;
	while (x > 0)
	{
		x--;
		y = 5000;
		while (y > 0)
		{
			y--;
		}
	}
}

int Ticket = 100;
pthread_mutex_t mutex;
pthread_cond_t cond;    //定义条件变量

void *SaleTicketA(void *arg)
{
	int cur_ticket;

	while (1)
	{
		pthread_mutex_lock(&mutex);
		cur_ticket = Ticket;
		if (cur_ticket <= 0)
		{
			pthread_mutex_unlock(&mutex);
			break;
		}
		if (cur_ticket == 50)
		{
			pthread_cond_signal(&cond);    //唤醒睡眠的线程
		}
		printf("A get %d-th ticket\n", cur_ticket);
		cur_ticket--;
		Ticket = cur_ticket;
		pthread_mutex_unlock(&mutex);
		delay();
	}
}

void *SaleTicketB(void *arg)
{
	int cur_ticket;

	while (1)
	{
		pthread_mutex_lock(&mutex);
		cur_ticket = Ticket;
		if (cur_ticket <= 0)
		{
			pthread_mutex_unlock(&mutex);
			break;
		}
		if (cur_ticket >= 50)
		{
			pthread_cond_wait(&cond, &mutex);    //让线程等待
			cur_ticket = Ticket;
		}
		printf("B get %d-th ticket\n", cur_ticket);
		cur_ticket--;
		Ticket = cur_ticket;
		pthread_mutex_unlock(&mutex);
		delay();
	}
}


int main()
{
	pthread_mutex_init(&mutex, NULL);
	pthread_cond_init(&cond, NULL);   //初始化条件变量

	int ret;
	pthread_t tid[2];

	ret = pthread_create(&tid[0], NULL, SaleTicketA, NULL);
	if (ret != 0)
	{
		perror("pthread_create");
		exit(1);
	}

	ret = pthread_create(&tid[1], NULL, SaleTicketB, NULL);
	if (ret != 0)
	{
		perror("pthread_create");
		exit(1);
	}

	void *status;
	pthread_join(tid[0], &status);
	pthread_join(tid[1], &status);

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

	return 0;
}