Linux多线程实例

最新推荐文章于 2023-03-11 14:50:17 发布

YUE110YUE

最新推荐文章于 2023-03-11 14:50:17 发布

阅读量426

点赞数

分类专栏： Linux

本文链接：https://blog.csdn.net/YUE110YUE/article/details/104132885

版权

Linux 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

Linux多线程实例

线程介绍参考1

一、Linux线程介绍

1.进程：一个程序，系统进行资源分配和调度的基本单位（资源独占）
2.线程：在进程内部运行的一个分支，使用进程的地址空间，跟同一个进程的其他线程共享同一地址空间（线程的目的就是方便）
3.多线程好处：
（1）线程间地址空间相同，可以很方便共享大部分数据，也方便通信
（2）多线程方式相对于开辟新的进程而言，不用专门开辟资源导致浪费，速度还快

二、多线程的使用

1.函数介绍
#include <pthread.h>
( 1 )创建：pthread_create
int pthread_create(pthread_t * thread, const pthread_arrt_t* attr,void*(*start_routine)(void ), void arg)
【1】 thread,新线程的ID,为整型。
【2】attr, 新线程的属性。NULL为默认属性。
【3】start_routine和arg, 分别指定新线程将运行的函数和参数。start_routine返回时,这个线程就退出了
【4】返回值:成功返回0,失败返回错误号

（2）线程的终止：直接return 或 pthread_exit 或 pthread_cancle
【1】从线程调度函数直接return。这种方法对主线程不适应,从main函数return相当于调用exit。

【2】被同一进程中其他线程终止用 int pthread_cancel(pthread_t thread)
成功返回0，失败返回错误码

【3】自己终结 void pthread_exit(void * retval)
该函数永远不会失败
注意，retval指向的空间必须是全局或malloc或new的空间，不能是函数的栈空间。

( 3 ) 线程等待退出：pthread_join
void pthread_join(pthread_t thread,void ** retval);
【1】调用该函数的线程将挂起等待，直到该ID的线程终止
【2】线程以不同的方式终止，在此得到的终止状态将不同
如果线程是正常return，则retval得到的是线程的返回值
如果线程是被pthread_cancel函数异常终掉，则retval指向常量PTHREAD_CANCELED
如果线程是自己调用pthread_exit函数终止的，则retval指向pthread_exit的参数。
如果对线程返回的状态不感兴趣，则传入NULL。
【3】如果一个子线程结束没有调用 pthread_join，则会导致部分资源没有被释放
【4】条用pthread_join,如果该线程没有结束，则会一直阻塞（停在这，等待），如果不想这样，则应该调用 pthread_detach,且会立即返回，并在线程结束后释放资源
在子线程函数中自己调用 pthread_detach(pthread_self())
在其他地方则调用 pthread_detach(thread_id)

2.编程实例
# g++ thread03.cc -pthread
备注：-pthread 兼容 -lpthread, -lpthread以前用的

#include <iostream>
#include <pthread.h>

using namespace std;
char msg3[20] = {"thread exit"};

void* my_run(void *arg)
{
	int i = 20;
	while(i)
	{
		i--;
		cout<<"["<<i<<"] "<<"I'm "<< (char *)arg << endl;
		sleep(1);
	}
	pthread_exit((char *) msg3);
}

int main()
{
	pthread_t tid1;
	pthread_t tid2;
	char msg1[20] = {"thread01"};
	char msg2[20] = {"thread02"};
	void *thread_result;
	int res = 0;

	res = pthread_create(&tid1,NULL,my_run,msg1);
	res = pthread_create(&tid2,NULL,my_run,msg2);

	int i = 5;
	while(i)
	{
		cout<<"["<<i--<<"] "<<"--- main thread ---"<<endl;
		sleep(2);
	}
	res = pthread_join(tid1,&thread_result);
	cout<<"Thread joined, it returned! : "<<(char *) thread_result<<endl;
	res = pthread_join(tid2,&thread_result);
	cout<<"Thread joined, it returned! : "<<(char *) thread_result<<endl;
	return 0;
}

三、线程同步

线程的协作有时需要同步，如以下几种方式：互斥锁、信号量、条件变量
区别：
信号量：是流程上的概念。只要信号量的value大于0，其他线程就可以sem_wait成功，成功后信号量的value减一。若value值不大于0，则sem_wait阻塞，直到sem_post释放后value值加一
互斥锁： “锁住某一资源”的概念。只要被锁住，其他任何线程都不可以访问被保护的资源

1.互斥锁

（1）概述

在访问临界资源时，通过互斥，限制同一时刻最多只能有一个线程可以获取临界资源。
其实互斥的逻辑就是：如果访问临街资源发现没有其他线程上锁，就上锁，获取临界资源，期间如果其他线程执行到互斥锁发现已锁住，则线程挂起等待解锁，当前线程访问完临界资源后，解锁并唤醒其他被该互斥锁挂起的线程，等待再次被调度执行。
本质是个全局变量，只有lock和unlock两种状态。unlock的互斥锁可以由某个线程获得，一旦获得，这个互斥锁会锁上变成lock状态，此后只有该线程由权力打开该锁，其他线程想要获得互斥锁，必须得到互斥锁再次被打开之后。
用于保护同一时间内只允许某个线程访问的资源

（2）函数介绍

【1】互斥锁创建
a.创建并在编译阶段初始化：
pthread_mutex_t mutex_x=PTHREAD_MUTEX_INITIALIZER;
b.动态初始化：
int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr);
第二个参数传入NULL为默认属性

【2】加锁
int pthread_mutex_lock(pthread_mutex_t *mutex)

【3】解锁
　　int pthread_mutex_unlock(pthread_mutex_t *mutex)
　　
【4】试着加锁（测试加锁）
int pthread_mutex_trylock(pthread_mutex_t *mutex)
与pthread_mutex_lock()类似，不同的是在锁已经被占据时返回EBUSY而不是挂起等待

（3）代码实例

编译：
#g++ thread_mutex.cc -pthread
效果：加锁每次结果都一样，不加锁经常结果不一样

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

using namespace std;

long gNum = 0;
pthread_mutex_t mLock1 = PTHREAD_MUTEX_INITIALIZER;

void *increase(void *arg)
{
	long tmp = 0;

	for(long i = 0; i < 1000000; i++)
	{
		pthread_mutex_lock(&mLock1);
		tmp = gNum;
		tmp = tmp + 1;
		gNum = tmp;
		pthread_mutex_unlock(&mLock1);
	}
	pthread_exit(arg);
}

int main(void)
{
	pthread_t tid1,tid2,tid3;
	char msg1[20] = {"thread 01"};
	char msg2[20] = {"thread 02"};
	char msg3[20] = {"thread 03"};
	int res = 0;

	res = pthread_create(&tid1,NULL,increase,msg1);
	res = pthread_create(&tid2,NULL,increase,msg2);
	res = pthread_create(&tid3,NULL,increase,msg3);

	void *ret;
	pthread_join(tid1,&ret);	
	cout<<(char*)ret<<" out"<<endl;

	pthread_join(tid2,&ret);	
	cout<<(char*)ret<<" out"<<endl;

	pthread_join(tid3,&ret);	
	cout<<(char*)ret<<" out"<<endl;

	cout<<"gNum:"<<gNum<<endl;
	
	pthread_mutex_destroy(&mLock1);

	return 0;
}

2.信号量

（1）概述

信号量是一个整数计数器，其数值表示空闲临界资源的数量。
当有进程释放资源时，信号量增加，表示可用资源数增加；当有进程申请到资源时，信号量减少，表示可用资源数减少
当需要获取共享资源时，先检查信号量，如果值大于0，则值减1，访问共享资源，访问结束后，值加1，如果发现有被该信号量挂起的线程，则唤醒其中一个线程；如果检查到信号量为0，则挂起等待。
互斥锁其实相当于0-1信号量

（2）函数介绍

头文件 #include <semaphore.h>
【1】创建
sem_t sem;
初始化信号量：
int sem_init(sem_t * sem, int pshared, unsigned int value)

【2】信号量减一操作，有线程申请资源
int sem_wait(sem_t* sem);

【3】信号量加一操作，有线程释放资源
int sem_post(sem_t* sem);
【4】销毁信号量
int sem_destroy(sem_t *sem);

（3）代码实例（生产者-消费者）

#g++ thread_sem.cc -pthread

#include <stdio.h>
#include <pthread.h>
#include <iostream>
//#include <stdlib.h>
#include <semaphore.h>

using namespace std;

#define MAX_NUM  10
int stack[MAX_NUM] = {0};
int size = 0;
sem_t sem;

void *privide_data(void* arg)
{
	int i = 0;
	for(i = 0; i < MAX_NUM; i++)
	{
		stack[i] = i;
		sem_post(&sem);
		sleep(3);
	}
}

void *handle_data(void *arg)
{
	int i = 0;
	while((i = size++) < MAX_NUM)//Just for exit
	{
		sem_wait(&sem);
		cout<<(char *) arg<<stack[i]<<endl;
		sleep(1);	
	}
}

int main(void)
{
	pthread_t tid1,tid2,tid3;
	char msg2[20] = {"thread 02: "};
	char msg3[20] = {"thread 03: "};
	
	sem_init(&sem,0,0);
	pthread_create(&tid1,NULL,privide_data,NULL);
	pthread_create(&tid2,NULL,handle_data,msg2);
	pthread_create(&tid3,NULL,handle_data,msg3);
	
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
	pthread_join(tid3,NULL);
	
	sem_destroy(&sem);
}

3.条件变量

（1）概述

当线程需要某个条件才继续往下执行，否则挂起等待，这个时候就需要信号量

（2）函数介绍

头文件 #include <pthread.h>
【1】创建
静态初始化：
pthread_cond_t gCond = PTHREAD_COND_INITIALIZER;
动态初始化：int pthread_cond_init(&cond,NULL)

【2】等待
条件等待：int pthread_cond_wait(&gCond ,&mutex)
计时等待：int pthread_cond_timewait(&gCond ,&mutex,time)

无论哪种等待方式，都必须和一个互斥锁配合，以防止多个线程同时请求pthread_cond_wait()（或pthread_cond_timedwait()）形成竞争条件

【3】唤醒
唤醒一个等待线程：pthread_cond_signal(&gCond )
唤醒所有等待线程：pthread_cond_broadcast(&gCond )
a.唤醒线程的顺序由调度策略决定
b.必须在互斥锁的保护下使用相应的条件变量，否则可能造成死锁
c.如果没有线程被阻塞在条件变量上，那么调用pthread_cond_signal()将没有作用
d.由于pthread_cond_broadcast函数唤醒所有阻塞在某个条件变量上的线程，这些线程被唤醒后将再次竞争相应的互斥锁，所以必须小心使用pthread_cond_broadcast函数

（3）代码实例

#g++ thread_cond.cc -pthread

#include <pthread.h>
#include <iostream>

using namespace std;

pthread_mutex_t gLock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t gCond;
int gCount = 0;

void* decrement(void *arg)
{
	pthread_mutex_lock(&gLock);
	cout<<__FUNCTION__<<" mutex lock before"<<endl;
	while(gCount == 0)
	{
		cout<<__FUNCTION__<<" cond_wait before"<<endl;
		pthread_cond_wait(&gCond,&gLock);
		cout<<__FUNCTION__<<" cond_wait after"<<endl;
	}
	gCount = gCount - 1;
	pthread_mutex_unlock(&gLock);
	cout<<__FUNCTION__<<" mutex unlock before"<<endl;
}

void* increment(void *arg)
{
	pthread_mutex_lock(&gLock);
	cout<<__FUNCTION__<<" mutex lock before"<<endl;
	if(gCount == 0)
	{
		cout<<__FUNCTION__<<" cond_singal before"<<endl;
		//pthread_cond_signal(&gCond);
		pthread_cond_broadcast(&gCond);
		cout<<__FUNCTION__<<" cond_singal after"<<endl;
	}
	gCount = gCount + 1;
	pthread_mutex_unlock(&gLock);
	cout<<__FUNCTION__<<" mutex unlock before"<<endl;
}


int main()
{
	pthread_mutex_init(&gLock,NULL);
	pthread_cond_init(&gCond,NULL);

	pthread_t tid1;
	pthread_t tid2;
	int ret = 0;
	
	pthread_create(&tid1,NULL,decrement,NULL);
	sleep(3);
	pthread_create(&tid2,NULL,increment,NULL);
	
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);

	return 0;
}

四、死锁

1.概述

参考
死锁 (deallocks)：是指两个或两个以上的进程（线程）在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程（线程）称为死锁进程（线程）。

2.代码实例

参考1
死锁原因分析：
【1】thread1 一启动就上锁mutex1，然后Sleep 1S
【2】thread2 一启动就上锁mutex2，然后Sleep，过一会（没到1S）【3】thread1 Sleep结束，就要上锁mutex2，但是mutex2还没被 thread2释放，只能等待
【4】再过一小会，thread2 Sleep结束，准备上锁mutex1，但是mutex1还没被thread1释放，也只能等待
【5】最终，只能在互相等待，形成死锁

#g++ -g thread_deadlock.cc -pthread
编译时加上-g选项，以便能够得到符号对应的源码

使用GDB调试：
【1】查看进程ID：ps -ef | grep a.out
【2】attach到进程：gdb attach 9867
【3】查看进程当前有哪些线程：info thread
【4】换到线程2：thread 2
【5】查看调用栈：bt
【6】查看调用栈栈帧：frame 3（或 f 3）
【7】查看另外的线程

#include <pthread.h> 
#include <iostream>

using namespace std;

pthread_mutex_t mutex1; 
pthread_mutex_t mutex2;
int sequence1 = 0; 
int sequence2 = 0; 

void* thread1(void* arg) 
{ 
    while (1) 
    { 
	    cout<<(char *)arg<<" mutex1 lock"<<endl;
        pthread_mutex_lock(&mutex1); 
        cout<<"sequence1:"<< ++sequence1 <<endl;
        sleep(1);
	
	    cout<<(char *)arg<<" mutex2 lock"<<endl;
        pthread_mutex_lock(&mutex2); 
        cout<<"sequence2:"<< ++sequence2 <<endl;

	cout<<(char *)arg<<" mutex2 unlock"<<endl;
        pthread_mutex_unlock(&mutex2); 

	cout<<(char *)arg<<" mutex1 unlock"<<endl;
        pthread_mutex_unlock(&mutex1); 
    } 
} 

void* thread2(void* arg) 
{ 
    while (1) 
    { 
	    cout<<(char *)arg<<" mutex2 lock"<<endl;
        pthread_mutex_lock(&mutex2); 
        cout<<"sequence2:"<< ++sequence2 <<endl;
        sleep(1);

	    cout<<(char *)arg<<" mutex1 lock"<<endl;
        pthread_mutex_lock(&mutex1); 
        cout<<"sequence1:"<< ++sequence1 <<endl;

	    cout<<(char *)arg<<" mutex1 unlock"<<endl;
        pthread_mutex_unlock(&mutex1); 

	    cout<<(char *)arg<<" mutex2 unlock"<<endl;
        pthread_mutex_unlock(&mutex2); 
    } 
} 

int main() 
{ 
    pthread_t tid[2]; 
    char msg1[20] = {"thread 1:"};
    char msg2[20] = {"thread 2:"};

    pthread_create(&tid[0], NULL, thread1, msg1);
    pthread_create(&tid[1], NULL, thread2, msg2);

    pthread_join(tid[0], NULL); 
    pthread_join(tid[1], NULL); 

    return 0; 
}