Linux多线程编程

多线程

进程是资源管理的最小单位，线程是程序执行的最小单位。因此我们在程序中多用线程有利于节省运行的空间和时间，更好的支持SMP以及减小（进程/线程）上下文切换开销。

基本使用

//多线程所需的头文件:
#include<pthread.h>
//创建线程id：
pthread_t id;
//创建线程:
int pthread_create(pthread_t *restrict tidp,
const pthread_attr_t *restrict attr,
void *(*start_rtn)(void), 
void *restrict arg);// 0-成功；-1-失败；
//pthread_create(&id,NULL,function_name,NULL);

//让主进程等待此线程，并在进程结束后回收线程资源
int pthread_join(pthread_t thread, void **retval);// 0-成功；错误号-失败
//pthread_join(id,NULL);//第二个参数用来接返回值，如没有可直接接NULL;

//线程主动退出,可被return替代
void pthread_exit(void* retval);//可带字符串
//pthread_exit("function_name pthread exit")

注意点

编译时要链接pthread库

gcc name.c -lpthread

线程与主进程之间的通信

• 全局变量

• main里的变量通过pthread_create的第四个参数传参

  这里要注意要在此线程函数里做强转

  int num = *((int *)arg);
  char *ptr = (char *)arg;
  

多线程实例

#include<stdio.h>
#include<unistd.h>
#include<string.h>
#include<pthread.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>

char *ptr1="hello";
char *ptr2="wrold";
char *ptr3="wwwww";
char *ptr4="hhhhh";
char *ptr5="\n";
void *pthread1(void *arg)
{
	int fd = open("./a.txt",O_RDWR | O_CREAT);
	if(fd==-1)
	{
		perror("open");
		return 0;
	}
	for(int i=0;i<5;i++)
	{
		write(fd,ptr1,strlen(ptr1));
		write(fd,ptr2,strlen(ptr2));
		write(fd,ptr5,strlen(ptr5));
		sleep(1);
	}
	close(fd);
	return 0;
}
void *pthread2(void *arg)
{
	int fd = open("./a.txt",O_RDWR | O_CREAT | O_APPEND);
	if(fd==-1)
	{
		perror("open2");
		return 0;
	}
	for(int i=0;i<5;i++)
	{
		write(fd,ptr3,strlen(ptr3));
		write(fd,ptr4,strlen(ptr4));
		write(fd,ptr5,strlen(ptr5));
		sleep(1);
	}
	close(fd);
	return 0;
}

int main()
{
	pthread_t id1;
	pthread_t id2;
	pthread_create(&id1,NULL,pthread1,NULL);
	pthread_create(&id2,NULL,pthread2,NULL);
	pthread_join(id1,NULL);
	pthread_join(id2,NULL);

	return 0;
}

结果：
\

mutex线程互斥锁

1、pthread_mutex_init初始化互斥锁

1. 头文件：#include<pthread.h>

2. 函数原型：

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

3. 函数形参：

    mutex：互斥锁地址（需自定义，如：pthread_mutex_t mutex;）；
    attr：互斥锁的属性（一般设置为NULL表示使用默认属性）。 
   

   注：（1）pthread_mutex_t是一个结构体类型，所以mutex实际上是一个结构体变量。（2）attr也可设置一些互斥锁的特殊功能。

4. 函数返回值：总是返回0，所以这个函数不需要进行出错处理。

5. 注意事项：互斥锁尽量作为全局变量

2、pthread_mutex_(try/un)lock加锁/解锁操作

1. pthread_mutex_lock(&mutex)（阻塞加锁）访问临界区加锁操作。
2. pthread_mutex_trylock( &mutex)（非阻塞加锁），通常不使用。
   注：与pthread_mutex_lock()类似，不同：锁已经被占据时返回 EBUSY 而不是挂起等待。
3. pthread_mutex_unlock(&mutex): 访问临界区解锁操。
   注：mutex：互斥锁的地址。

3、pthread_mutex_destroy销毁互斥锁

1. 头文件：#include<pthread.h>
2. 函数原型：int pthread_mutex_destroy(pthread_mutex_t *mutex);
3. 函数形参： mutex：互斥锁地址。
4. 函数返回值：成功返回0，失败返回非零错误号。
5. 功能：销毁，即删除互斥锁相关的数据，释放互斥锁数据所占用的各种内存资源。

条件变量的使用

条件变量的使用步骤：
（1）定义一个条件变量（全局变量），pthread_cond_t；
注：由于条件变量需要互斥锁的配合，所以还需要定义一个线程互斥锁。
（2）初始化条件变量；
（3）使用条件变量;
（4）删除条件变量，也需要把互斥锁删除。

1、pthread_cond_init初始化条件变量

1. 头文件：#include<pthread.h>

2. 函数原型：

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

3. 函数形参：cond：条件变量；
   attr：用于设置条件变量的属性，设置为NULL，表示使用默认属性。

4. 函数返回值：成功返回0，失败返回非零错误号。

5. 补充：也可以直接初始化：

   pthread_cond_t cond = PTHREAD_COND_INITIALIZER;//与互斥锁的初始化的原理一样
   

6. 使用示例：

pthread_cond_t cond; //定义条件变量
pthread_cond_init(&cond, NULL); //第二个参数为NULL，表示不设置条件变量的属性

2、pthread_cond_wait等待条件

1. 头文件：#include<pthread.h>

2. 函数原型：

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

3. 函数形参：

    cond：条件变量；
    mutex：和条件变量配合使用的互斥锁。
   

4、函数返回值：成功返回0，失败返回非零错误号。

3、pthread_cond_signal设置条件变量

1. 头文件：#include<pthread.h>
2. 函数原型：int pthread_cond_signal(pthread_cond_t *cond);
3. 函数形参：cond：条件变量。
4. 函数返回值：成功返回0，失败返回非零错误号。
5. 功能：
   调用pthread_cond_signal去设置条件变量，相当是给pthread_cond_wait发送了一个线程间专用的信号，通知调用pthread_cond_wait的线程，某某条件满足了，不要再睡了，赶紧做事吧。
6. 补充：
   当调用pthread_cond_wait函数等待条件满足的线程只有一个时，就是用pthread_cond_signal来唤醒，如果说有多个线程都调用pthread_cond_wait在等待时，使用int pthread_cond_broadcast(pthread_cond_t *cond);
   注：pthread_cond_broadcast可以将所有调用pthread_cond_wait而休眠的线程都唤醒。

4、删除条件变量

1. 头文件：#include<pthread.h>
2. 函数原型：int pthread_cond_destroy(pthread_cond_t *cond);
3. 函数形参：cond：条件变量。
4. 函数返回值：成功返回0，失败返回非零错误号。

sem 线程信号量

线程信号量使用步骤：
（1）定义信号量集合（如：sem_t sem[3]）；
注：线程信号量集合其实就是一个数组，数组每个元素就是一个信号量。
（2）初始化集合中的每个信号量；
（3）p、v操作；
（4）进程结束时，删除线程信号量集合。

1、sem_init初始化信号量

1. 头文件：#include <semaphore.h>
2. 函数原型：int sem_init(sem_t *sem, int pshared, unsigned int value);
3. 函数形参：sem：信号量集合中的某个信号量地址；
   pshared：若为0：给线程使用 / 若为非0：可以给进程使用；
   value：初始化值。
   注：pshared：通常不用!0值。对于进程来说，更多的还是使用进程信号量，因为线程信号量用到进程上时，存在一些不稳定的情况。
4. 函数返回值：成功返回0，失败返回-1，errno被设置。

2、sem_wait信号量操作

1. P操作
   （1）头文件：#include <semaphore.h>
   （2）函数原型：int sem_wait(sem_t *sem);//阻塞p操作
   （3）函数形参：sem：信号量集合中的某个信号量地址；
   （4）函数返回值：成功返回0，失败返回-1，errno被设置。
   （5）功能：阻塞p操作集合中某个信号量，信号量的值-1。
   如果能够p操作成功最好，否则就阻塞直到p操作操作成功为止。
   （6）使用示例：sem_wait(&sem[0]);
2. V操作
   （1）头文件：#include <semaphore.h>
   （2）函数原型：int sem_post(sem_t *sem);
   （3）函数形参：sem：信号量集合中的某个信号量地址；
   （4）函数返回值：成功返回0，失败返回-1，errno被设置。
   （5）功能：v操作成功后，信号量的值+1。
   对某个信号量进行v操作，v操作不存在阻塞问题。
   （6）使用示例：sem_post(&sem[0]);