线程理论基础
1.多线程
优点:
1.是一种“节俭”的多任务操作方式。在Linux系统下,启动一个新的进程必须分配给它独立的地址空间,建立众多的数据表来维护它的代码段、堆栈段和数据段,这是一种“昂贵”的多任务工作方式。
2.线程间方便的通信机制,对不同进程来说,它们具有独立的数据空间,要进行数据的传递只能通过进程间通信的方式进行,这种方式不仅费时,而且很不方便。线程则不然,由于同一进程的线程之间共享数据空间,所以一个线程的数据可以直接为其它线程所用,这不仅快捷,而且方便。
多线程作为一种多任务,并发的工作方式,有如下优点:
3.使多CPU系统更加有效,操作系统会保证当线程数不大于CPU数目时,不同的线程运行于不同的CPU上;
4.改善程序结构,一个既长又复杂的进程可以考虑分为多个线程,成为几个独立或半独立的运行部分,这样的程序会有利于理解和修改。
2.注意
Linux系统下的多线程遵循POsiX线程接口,称为pthread,编写Linux下的多线程程序,需要使用头文件pthread.h,连接时需要使用库libpthread.a
3.线程创建
#include<pthread.h>
int pthread_create(pthread *tidp,const pthread_attr_t *attr,void *(*start_rtn)(void),void *arg)
tidp:线程id
attr:线程属性(通常为空NULL)
start_rtn:线程要执行的函数
arg:start_rtn的参数
因为pthread的库不是Linux系统的库,所以在进行编译的时候要加上:-lpthread
#gcc filename.c -lpthread -o filename
4.终止线程
如果进程中任何一个线程调用exit或_exit,那么整个进程都会终止,线程的正常退出方式有:
1)线程从启动例程中返回;//exit(1)退出进程
2)线程可以被另一个进程终止;//return
3)线程自己调用pthread_exit函数
#include <pthread.h>
void pthread_exit(void *rval_ptr)
功能:终止调用线程
rval_ptr:线程退出返回值的指针
5.线程等待
#include <pthread.h>
int pthread_join(pthread_t tid,void **rval_ptr)
功能:阻塞调用线程,直到指定的线程终止
tid:等待退出的线程id
rval_ptr:线程退出的返回值的指针
6.线程标识
#include<pthread.h>
pthread_t pthread_self(void)
功能:
获取调用线程的thread identitier
7.清除
线程终止有两种情况:正常终止和非正常终止。
正常终止:线程主动调用pthread_exit或者从线程函数中return都将使线程正常退出,这是可预见的退出方式。
非正常终止:线程在其它线程的干预下,或者由于自身运行出错(如访问非法地址)而退出,这种退出方式是不可预见的。
不论是可预见的线程终止还是异常终止,都会存在资源释放的问题,如何保证线程退出后能顺利释放掉自己所占的资源,是一个必须解决的问题。
可利用一组函数来解决异常终止的资源释放问题:
从pthread_cleanup_push的调用点到pthread_cleanup_pop之间的程序段中的终止动作(包括调用pthread_exit()和异常终止,不包括return)都将执行pthread_cleanup_push()所指定的清理函数。
#inlcude <pthread.h>
void pthread_cleanup_push(void (*rtn)(void*),void *arg)
功能:
将清除函数压入清除栈;
rtn:清除函数;
arg:清除函数的参数
#include <pthread.h>
void pthread_cleanup_pop(int execute)
功能:
将清除函数弹出清除栈
参数:
execute执行到pthread_cleanup_pop时是否在弹出清理函数的同时执行该函数,非0:执行;0:不执行。
8.线程同步
进行多线程编程,因为无法知道哪个线程会在哪个
时候对共享资源进行操作,因此让如何保护共享资
源变得复杂,通过下面这些技术的使用,可以解决
线程之间对资源的竞争:
1)互斥量Mutex
互斥量从本质上说就是一把锁, 提供对共享资源的保护访问
(1)创建
在Linux中,互斥量使用类型pthread_mutex_t表示。在使用前, 要对它进行初始化:
对于静态分配的互斥量, 可以把它设置为默认的mutex
对象PTHREAD_MUTEX_INITIALIZER
对于动态分配的互斥量, 在申请内存(malloc)之后, 通
过pthread_mutex_init进行初始化, 并且在释放内存
(free)前需要调用pthread_mutex_destroy。
#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t *mutex,
const pthread_mutexattr_t *attr)
int pthread_mutex_destroy(pthread_mutex_t *mutex)
(2)加锁
对共享资源的访问, 要使用互斥量进行加锁, 如果互斥量已经上了锁, 调用线程会阻塞, 直到互斥量被解锁。
int pthread_mutex_lock(pthread_mutex_t *mutex)
int pthread_mutex_trylock(pthread_mutex_t *mutex)
返回值: 成功则返回0, 出错则返回错误编号。
trylock是非阻塞调用模式, 如果互斥量没被锁住, trylock函数将对互斥量加锁, 并获得对共享资源的访问权限; 如果互斥量被锁住了, trylock函数将不会阻塞等待而直接返回EBUSY, 表示共享资源处于忙状态。
(3)解锁
在操作完成后,必须给互斥量解锁,也就是前面所说的释放。这样其他等待该锁的线程才有机会获得该锁,否则其他线程将会永远阻塞。
int pthread_mutex_unlock(pthread_mutex_t *mutex)
互斥量PK信号量
Mutex是一把钥匙,一个人拿了就可进入一个房
间,出来的时候把钥匙交给队列的第一个。
Semaphore是一件可以容纳N人的房间,如果人不
满就可以进去,如果人满了,就要等待有人出来。
对于N=1的情况,称为binary semaphore。
Binary semaphore与Mutex的差异:
1. mutex要由获得锁的线程来释放(谁获得,谁释
放)。而semaphore可以由其它线程释放
2. 初始状态可能不一样:mutex的初始值是1,而
semaphore的初始值可能是0(或者为1)。
2) 信号灯Semaphore
3) 条件变量Conditions
演示代码:
//**************线程创建*****************
#include <stdio.h>
#include <pthread.h>
void *myThread1(void)
{
int i;
for (i=0; i<100; i++)
{
printf("This is the 1st pthread,created by zieckey.\n");
sleep(1);//Let this thread to sleep 1 second,and then continue to run
}
}
void *myThread2(void)
{
int i;
for (i=0; i<100; i++)
{
printf("This is the 2st pthread,created by zieckey.\n");
sleep(1);
}
}
int main()
{
int i=0, ret=0;
pthread_t id1,id2;
/*创建线程1*/
ret = pthread_create(&id1, NULL, (void*)myThread1, NULL);
if (ret)
{
printf("Create pthread error!\n");
return 1;
}
/*创建线程2*/
ret = pthread_create(&id2, NULL, (void*)myThread2, NULL);
if (ret)
{
printf("Create pthread error!\n");
return 1;
}
pthread_join(id1, NULL);
pthread_join(id2, NULL);
return 0;
}
#include <pthread.h>
void *myThread1(void)
{
int i;
for (i=0; i<100; i++)
{
printf("This is the 1st pthread,created by zieckey.\n");
sleep(1);//Let this thread to sleep 1 second,and then continue to run
}
}
void *myThread2(void)
{
int i;
for (i=0; i<100; i++)
{
printf("This is the 2st pthread,created by zieckey.\n");
sleep(1);
}
}
int main()
{
int i=0, ret=0;
pthread_t id1,id2;
/*创建线程1*/
ret = pthread_create(&id1, NULL, (void*)myThread1, NULL);
if (ret)
{
printf("Create pthread error!\n");
return 1;
}
/*创建线程2*/
ret = pthread_create(&id2, NULL, (void*)myThread2, NULL);
if (ret)
{
printf("Create pthread error!\n");
return 1;
}
pthread_join(id1, NULL);
pthread_join(id2, NULL);
return 0;
}
/
每个线程有自己的栈空间,但共享数据段
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
//static int a=4;
int a = 1; //共享数据段
void *create(void *arg)
{
printf("new pthread ... \n");
printf("a=%d \n",a);
a++;
return (void *)0;
}
int main(int argc,char *argv[])
{
pthread_t tidp;
int error;
int a=5;
printf("int main 1:a = %d\n",a);
error=pthread_create(&tidp, NULL, create, NULL);
if(error!=0)
{
printf("new thread is not create ... \n");
return -1;
}
sleep(3);
printf("int main2: a = %d\n",a);
return 0;
}
#include <pthread.h>
#include <unistd.h>
//static int a=4;
int a = 1; //共享数据段
void *create(void *arg)
{
printf("new pthread ... \n");
printf("a=%d \n",a);
a++;
return (void *)0;
}
int main(int argc,char *argv[])
{
pthread_t tidp;
int error;
int a=5;
printf("int main 1:a = %d\n",a);
error=pthread_create(&tidp, NULL, create, NULL);
if(error!=0)
{
printf("new thread is not create ... \n");
return -1;
}
sleep(3);
printf("int main2: a = %d\n",a);
return 0;
}
/
****************线程等待********************
#include <pthread.h>
#include <unistd.h>
#include <stdio.h>
void *thread(void *str)
{
int i;
for (i = 0; i < 10; ++i)
{
sleep(2);
printf( "This in the thread : %d\n" , i );
}
return NULL;
}
int main()
{
pthread_t pth;
int i;
int ret = pthread_create(&pth, NULL, thread, (void *)(i));
pthread_join(pth, NULL);
printf("123\n");
for (i = 0; i < 10; ++i)
{
sleep(1);
printf( "This in the main : %d\n" , i );
}
return 0;
}
#include <unistd.h>
#include <stdio.h>
void *thread(void *str)
{
int i;
for (i = 0; i < 10; ++i)
{
sleep(2);
printf( "This in the thread : %d\n" , i );
}
return NULL;
}
int main()
{
pthread_t pth;
int i;
int ret = pthread_create(&pth, NULL, thread, (void *)(i));
pthread_join(pth, NULL);
printf("123\n");
for (i = 0; i < 10; ++i)
{
sleep(1);
printf( "This in the main : %d\n" , i );
}
return 0;
}
///
***************线程退出***********************
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
void *create(void *arg)
{
printf("new thread is created ... \n");
return (void *)8;
}
int main(int argc,char *argv[])
{
pthread_t tid;
int error;
void *temp;
error = pthread_create(&tid, NULL, create, NULL);
printf("main thread!\n");
if( error )
{
printf("thread is not created ... \n");
return -1;
}
error = pthread_join(tid, &temp);
if( error )
{
printf("thread is not exit ... \n");
return -2;
}
printf("thread is exit code %d \n", (int )temp);
return 0;
}
#include <pthread.h>
#include <unistd.h>
void *create(void *arg)
{
printf("new thread is created ... \n");
return (void *)8;
}
int main(int argc,char *argv[])
{
pthread_t tid;
int error;
void *temp;
error = pthread_create(&tid, NULL, create, NULL);
printf("main thread!\n");
if( error )
{
printf("thread is not created ... \n");
return -1;
}
error = pthread_join(tid, &temp);
if( error )
{
printf("thread is not exit ... \n");
return -2;
}
printf("thread is exit code %d \n", (int )temp);
return 0;
}
///
************************线程清除************************
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
void *clean(void *arg)
{
printf("cleanup :%s \n",(char *)arg);
return (void *)0;
}
void *thr_fn1(void *arg)
{
printf("thread 1 start \n");
pthread_cleanup_push( (void*)clean,"thread 1 first handler");
pthread_cleanup_push( (void*)clean,"thread 1 second hadler");
printf("thread 1 push complete \n");
if(arg)
{
return((void *)1);
}
pthread_cleanup_pop(0);
pthread_cleanup_pop(0);
return (void *)1;
}
void *thr_fn2(void *arg)
{
printf("thread 2 start \n");
pthread_cleanup_push( (void*)clean,"thread 2 first handler");
pthread_cleanup_push( (void*)clean,"thread 2 second handler");
printf("thread 2 push complete \n");
if(arg)
{
pthread_exit((void *)2);
}
pthread_cleanup_pop(0);
pthread_cleanup_pop(0);
pthread_exit((void *)2);
}
int main(void)
{
int err;
pthread_t tid1,tid2;
void *tret;
err=pthread_create(&tid1,NULL,thr_fn1,(void *)1);
if(err!=0)
{
printf("error .... \n");
return -1;
}
err=pthread_create(&tid2,NULL,thr_fn2,(void *)1);
if(err!=0)
{
printf("error .... \n");
return -1;
}
err=pthread_join(tid1,&tret);
if(err!=0)
{
printf("error .... \n");
return -1;
}
printf("thread 1 exit code %d \n",(int)tret);
err=pthread_join(tid2,&tret);
if(err!=0)
{
printf("error .... ");
return -1;
}
printf("thread 2 exit code %d \n",(int)tret);
return 1;
}
#include <pthread.h>
#include <unistd.h>
void *clean(void *arg)
{
printf("cleanup :%s \n",(char *)arg);
return (void *)0;
}
void *thr_fn1(void *arg)
{
printf("thread 1 start \n");
pthread_cleanup_push( (void*)clean,"thread 1 first handler");
pthread_cleanup_push( (void*)clean,"thread 1 second hadler");
printf("thread 1 push complete \n");
if(arg)
{
return((void *)1);
}
pthread_cleanup_pop(0);
pthread_cleanup_pop(0);
return (void *)1;
}
void *thr_fn2(void *arg)
{
printf("thread 2 start \n");
pthread_cleanup_push( (void*)clean,"thread 2 first handler");
pthread_cleanup_push( (void*)clean,"thread 2 second handler");
printf("thread 2 push complete \n");
if(arg)
{
pthread_exit((void *)2);
}
pthread_cleanup_pop(0);
pthread_cleanup_pop(0);
pthread_exit((void *)2);
}
int main(void)
{
int err;
pthread_t tid1,tid2;
void *tret;
err=pthread_create(&tid1,NULL,thr_fn1,(void *)1);
if(err!=0)
{
printf("error .... \n");
return -1;
}
err=pthread_create(&tid2,NULL,thr_fn2,(void *)1);
if(err!=0)
{
printf("error .... \n");
return -1;
}
err=pthread_join(tid1,&tret);
if(err!=0)
{
printf("error .... \n");
return -1;
}
printf("thread 1 exit code %d \n",(int)tret);
err=pthread_join(tid2,&tret);
if(err!=0)
{
printf("error .... ");
return -1;
}
printf("thread 2 exit code %d \n",(int)tret);
return 1;
}
线程的共享资源和私有资源/
线程共享的环境包括:进程代码段、进程的公有数据(利用这些共享的数据,线程很容易的实现相互之间的通讯)、进程打开的文件描述符、信号的处理器、进程的当前目录和进程用户ID与进程组ID。 进程拥有这许多共性的同时,还拥有自己的个性。有了这些个性,线程才能实现并发性。这些个性包括:
1.线程ID
每个线程都有自己的线程ID,这个ID在本进程中是唯一的。进程用此来标 识线程。
2.寄存器组的值
由于线程间是并发运行的,每个线程有自己不同的运行线索,当从一个线 程切换到另一个线程上时,必须将原有的线程的寄存器集合的状态保存,以便 将来该线程在被重新切换到时能得以恢复。
3.线程的堆栈
堆栈是保证线程独立运行所必须的。
线程函数可以调用函数,而被调用函数中又是可以层层嵌套的,所以线程 必须拥有自己的函数堆栈,使得函数调用可以正常执行,不受其他线程的影 响。
4.错误返回码
由于同一个进程中有很多个线程在同时运行,可能某个线程进行系统调用 后设置了errno值,而在该线程还没有处理这个错误,另外一个线程就在此时 被调度器投入运行,这样错误值就有可能被修改。
所以,不同的线程应该拥有自己的错误返回码变量。
5.线程的信号屏蔽码
由于每个线程所感兴趣的信号不同,所以线程的信号屏蔽码应该由线程自 己管理。但所有的线程都共享同样的信号处理器。
6.线程的优先级
由于线程需要像进程那样能够被调度,那么就必须要有可供调度使用的参 数,这个参数就是线程的优先级。