tianmo2010
tianmo2010

Linux多线程实践

①线程基础

一．什么是线程

       在一个程序里的多个执行路线就叫做线程。更准确的定义是：线程是“一个进程内部的一个控制序列”。

       典型的unix进程可以看成只有一个控制线程：一个进程在同一时刻只做一件事情。有了多个控制线程以后，在程序设计时可以把进程设计成在同一时刻能够做不止一件事，每个线程处理各只独立的任务。 

二．线程的优点

（1）       通过为每种事件类型的处理分配单独的线程，能够简化处理异步时间的代码。

（2）       多个线程可以自动共享相同的存储地址空间和文件描述符。

（3）       有些问题可以通过将其分解从而改善整个程序的吞吐量。

（4）       交互的程序可以通过使用多线程实现相应时间的改善，多线程可以把程序中处理用户输入输出的部分与其它部分分开。 

三．线程的缺点

       线程也有不足之处。编写多线程程序需要更全面更深入的思考。在一个多线程程序里，因时间分配上的细微偏差或者因共享了不该共享的变量而造成不良影响的可能性是很大的。调试一个多线程程序也比调试一个单线程程序困难得多。 

四．线程的结构

       线程包含了表示进程内执行环境必需的信息，其中包括进程中标识线程的线程ID，一组寄存器值、栈、调度优先级和策略、信号屏蔽子，errno变量以及线程私有数据。进程的所有信息对该进程的所有线程都是共享的，包括可执行的程序文本，程序的全局内存和堆内存、栈以及文件描述符。

 五．线程标识

       就像每个进程有一个进程ID一样，每个线程也有一个线程ID，进程ID在整个系统中是唯一的，但线程不同，线程ID只在它所属的进程环境中有效。线程ID用pthread_t数据类型来表示，实现的时候可以用一个结构来代表pthread_t数据类型，所以可以移植的操作系统不能把它作为整数处理。因此必须使用函数来对来对两个线程ID进行比较。

名称:：

pthread_equal

 

功能：

比较两个线程ID

 

头文件：

#include

函数原形：

int pthread_equal(pthread_t tid1,pthread_t tid2);

参数：

tid1 进程1id

tid2 进程2id

返回值：

若相等返回非0值，否则返回0

 


名称:：

pthread_self

功能：

获取自身线程的id

头文件：

#include

函数原形：

pthread_t pthread_self(void);

参数：

 无

返回值：

调用线程的线程id

六．线程的创建

名称:：

pthread_create

功能：

创建线程

头文件：

#include

函数原形：

int pthread_create(pthread_t *restrict tidp,const pthread _attr_t *restrict attr,void *(*start_rtn)(void),void *restrict arg);

参数：

  
返回值： 若成功返回则返回0，否则返回错误编号

当pthread_creat成功返回时， tidp指向的内存单元被设置为新创建线程的线程ID。attr参数用于定制各种不同的线程属性。可以把它设置为NULL，创建默认的线程属性。

       新创建的线程从start_rtn函数的地址开始运行，该函数只有一个无类型指针参数arg,如果需要向start_rtn函数传递的参数不止一个，那么需要把这些参数放到一个结构中，然后把这个结构的地址作为arg参数传入。

[cpp]  view plain copy
  1. #include   
  2.    
  3. void printids(const char *s)  
  4. {  
  5. printf(“%s pid:%u  tid:%u \n“, getpid(),pthread_self());  
  6. }  
  7.    
  8. void *thr_fn(void *arg)  
  9. {  
  10. printf (“new thread: “);  
  11. }  
  12.    
  13. int main()  
  14. {  
  15. int err;  
  16. pthread_t tid;  
  17. err=pthread_create(&tid,NULL,thr_fn,NULL);  
  18. if(err=0)  
  19.     printf(“can’t create thread:%s\n”,strerror(err));  
  20. printids(“main thread: “);  
  21. sleep(1);  
  22. exit(0);  
  23. }  

关于进程的编译我们都要加上参数 –lpthread 否则提示找不到函数的错误。

具体编译方法是 cc –lpthread –o gettid gettid.c

运行结果为

main thread: pid 14954 tid 134529024  
new thread: pid 14954 tid 134530048 

七．.线程的终止

       线程是依进程而存在的，当进程终止时，线程也就终止了。当然也有在不终止整个进程的情况下停止它的控制流。

       （1）线程只是从启动例程中返回，返回值是线程的退出码。

       （2）县城可以被同一进程中的其他线程取消。

       （3）线程调用pthread_exit.

名称:：

pthread_exit

功能：

终止一个线程

头文件：

#include

函数原形：

void pthread_exit(void *rval_ptr);

参数：

  

返回值：

无

rval_prt是一个无类型指针，与传给启动例程的单个参数类似。进程中的其他线程可以调用pthread_join函数访问到这个指针。

名称:：

pthread_join

功能：

获得进程的终止状态

头文件：

#include

函数原形：

int pthread_join(pthread_t thread,void **rval_ptr);

参数：

  

返回值：

若成功返回0，否则返回错误编号。

当一个线程通过调用pthread_exit退出或者简单地从启动历程中返回时，进程中的其他线程可以通过调用pthread_join函数获得进程的退出状态。调用pthread_join进程将一直阻塞，直到指定的线程调用pthread_exit,从启动例程中或者被取消。

如果线程只是从它的启动历程返回，rval_ptr将包含返回码。

[cpp]  view plain copy
  1. #include   
  2. #include   
  3.    
  4. void *thr_fn1(void *arg)  
  5. {  
  6. printf(“thread 1 returning\n”);  
  7. return((void *)1);  
  8. }  
  9.    
  10. void *thr_fn2(void *arg)  
  11. {  
  12. printf(“thread 2 exiting\n”);  
  13. return((void *)2);  
  14. }  
  15.    
  16. int main()  
  17. {  
  18. pthread_t tid1,tid2;  
  19. void *tret;  
  20.    
  21. pthread_create(&tid1,NULL,thr_fn1,NULL);  
  22. pthread_create(&tid2,NULL,thr_fn2,NULL);  
  23. pthread_join(tid1,&tret);  
  24. printf(“thread 1 exit code %d\n”,(int)tret);  
  25. pthread_join(tid2,&tret);  
  26. printf(“thread 2 exit code %d\n”,(int)tret);  
  27. exit(0);  
  28. }  

运行结果是：

thread 1 returning  
thread 2 exiting  
thread 1 exit code 1  
thread 2 exit code 2  

名称:：

pthread_detach

功能：

使线程进入分离状态。

头文件：

#include

函数原形：

int pthread_detach(pthread_t tid);

参数：

  

返回值：

 若成功则返回0，否则返回错误编号。

 在默认情况下，线程的终止状态会保存到对该线程调用pthread_join,如果线程已经处于分离状态，线程的底层存储资源可以在线程终止时立即被收回。当线程被分离时，并不能用pthread_join函数等待它的终止状态。对分离状态的线程进行pthread_join的调用会产生失败，返回EINVAL.pthread_detach调用可以用于使线程进入分离状态。

名称:：

pthread_cancel

功能：

取消同一进程中的其他线程

头文件：

#include

函数原形：

int pthread_cancel(pthread_t tid);

参数：

tid  线程id

返回值：

若成功返回0，否则返回错误编号。

 

在默认的情况下，pthread_cancel函数会使由tid标识的线程的行为表现为如同调用了参数为PTHEAD_CANCELED的pthread_exit函数，但是，线程可以选择忽略取消方式和控制取消方式。pthread_cancel并不等待线程终止，它仅仅提出请求。 

名称:：

pthread_cancel_push/ pthread_cancel_push_pop

功能：

线程清理处理程序

头文件：

#include

函数原形：

void pthread_cancel_push(void (*rtn)(void *)，void *arg);

void pthread_cancel_pop(int execute);

参数：

rtn 处理程序入口地址

arg 传递给处理函数的参数

返回值：

无

  线程可以安排它退出时需要调用的函数，这样的函数称为线程清理处理程序，线程可以建立多个清理处理程序。处理程序记录在栈中，也就是说它们的执行顺序与它们注册时的顺序相反。

       要注意的是如果线程是通过从他的启动例程中返回而终止的，它的处理程序就不会调用。还要注意清理处理程序是按照与它们安装时相反的顺序调用的。

[cpp]  view plain copy
  1. #include   
  2. #include    
  3.   
  4. void cleanup(void *arg)  
  5. {    
  6.     printf(“cleanup: %s\n”,(char *)arg);   
  7. }    
  8. void *thr_fn(void *arg) /*线程入口地址*/  
  9. {    
  10. printf(“thread start\n”);    
  11. pthread_cleanup_push(cleanup,”thread first handler”);/*设置第一个线程处理程序*/   
  12. pthread_cleanup_push(cleanup,”thread second handler”); /*设置第二个线程处理程序*/ 
  13.   
  14. printf(“thread push complete\n”);    
  15. pthread_cleanup_pop(0); /*取消第一个线程处理程序*/   
  16. pthread_cleanup_pop(0); /*取消第二个线程处理程序*/    
  17. }   
  18.   
  19. int main()   
  20. {    
  21. pthread_t tid;    
  22. void *tret;    
  23. pthread_creat(&tid,NULL,thr_fn,(void *)1); /*创建一个线程*/    
  24. pthread_join(tid,&tret); /*获得线程终止状态*/    
  25. ptinrf(“thread exit code %d\n”,(int)tret);    
  26. }  

八、一次性初始化

       有时候我们需要对一些posix变量只进行一次初始化，如线程键（我下面会讲到）。如果我们进行多次初始化程序就会出现错误。

       在传统的顺序编程中，一次性初始化经常通过使用布尔变量来管理。控制变量被静态初始化为0，而任何依赖于初始化的代码都能测试该变量。如果变量值仍然为0，则它能实行初始化，然后将变量置为1。以后检查的代码将跳过初始化。

       但是在多线程程序设计中，事情就变的复杂的多。如果多个线程并发地执行初始化序列代码，2个线程可能发现控制变量为0，并且都实行初始话，而该过程本该仅仅执行一次。初始化的状态必须由互斥量保护。

       如果我们需要对一个posix变量静态的初始化，可使用的方法是用一个互斥量对该变量的初始话进行控制。但有时候我们需要对该变量进行动态初始化，pthread_once就会方便的多。 

名称:：

pthread_once

功能：

一次性初始化

头文件：

#include

函数原形：

pthread_once_t once_control=PTHREAD_ONCE_INIT;

int pthread_once(pthread_once_t *once_control,void(*init_routine)(void));

参数：

once_control         控制变量

init_routine          初始化函数

返回值：

若成功返回0，若失败返回错误编号。

 类型为pthread_once_t的变量是一个控制变量。控制变量必须使用PTHREAD_ONCE_INIT宏静态地初始化。

       pthread_once函数首先检查控制变量，判断是否已经完成初始化，如果完成就简单地返回；否则，pthread_once调用初始化函数，并且记录下初始化被完成。如果在一个线程初始时，另外的线程调用pthread_once，则调用线程等待，直到那个现成完成初始话返回。       

下面就是该函数的程序例子：

[cpp]  view plain copy
  1. #include     
  2. pthread_once_t once=PTHREAD_ONCE_INIT;  
  3. pthread_mutex_t mutex;)　/*互斥量，我们后面会讲到*/   
  4. void once_init_routine(void)　/*一次初始化函数*/   
  5. {    
  6.     int status;    
  7.     status=pthread_mutex_init(&mutex,NULL);/*初始化互斥量*/   
  8.     if(status==0)    
  9.         printf(“Init success!,My id is %u”,pthread_self());   
  10. }  
  11.   
  12. void *child_thread(void *arg)    
  13. {    
  14.     printf(“I’m child ,My id is %u”,pthread_self());   
  15.     pthread_once(&once,once_init_routine); /*子线程调用一次性初始化函数*/  
  16. }    
  17. int main(int argc,char *argv[ ])    
  18. {    
  19. pthread_t child_thread_id;    
  20. pthread_create(&child_thread_id,NULL,child_thread,NULL);/*创建子线程*/  
  21.   
  22. printf(“I’m father,my id is %u”,pthread_self());  
  23.   
  24. pthread_once(&once_block,once_init_routine);/*父线程调用一次性初始化函数*/   
  25. pthread_join(child_thread_id,NULL);    
  26. }  

程序运行结果如下：

./once

I’m father,My id is 3086874304    
Init success!,My id is 3086874304    
I’m child, My id is 3086871472  

从上面的结果可以看到当主函数初始化成功后，子函数初始化失败。 

九、线程的私有数据

       在进程内的所有线程共享相同的地址空间，任何声明为静态或外部的变量，或在进程堆声明的变量，都可以被进程所有的线程读写。那怎样才能使线程序拥有自己的私有数据呢。

       posix提供了一种方法，创建线程键。 

名称:：

pthread_key_create

功能：

建立线程私有数据键

头文件：

#include

函数原形：

int pthread_key_create(pthread_key *key,void(*destructor)(void *));

参数：

key         私有数据键

destructor    清理函数

返回值：

若成功返回0，若失败返回错误编号。

  第一个参数为指向一个键值的指针，第二个参数指明了一个destructor函数（清理函数），如果这个参数不为空，那么当每个线程结束时，系统将调用这个函数来释放绑定在这个键上的内存块。这个函数常和函数pthread_once一起使用，为了让这个键只被创建一次。函数pthread_once声明一个初始化函数，第一次调用pthread_once时它执行这个函数，以后的调用将被它忽略。 

下面是程序例子：

[cpp]  view plain copy
  1. #include     
  2. pthread_key_t tsd_key;   
  3. pthread_once_t key_once=PTHREAD_ONCE_INIT;  
  4.   
  5. void once_routine(void)    
  6. {    
  7. int status;    
  8. status=pthread_key_create(&tsd_key,NULL);/*初始化线程私有数据键*/  
  9. if(status=0)    
  10.     printf(“Key create success! My id is %u\n”,pthread_self());    
  11. }    
  12. void *child_thread(void *arg)  
  13. {    
  14. printf(“I’m child,My id is %u\n”,pthread_self());    
  15. pthread_once(&key_once,once_routine);/* 调用一次性初始化函数*/   
  16. }    
  17. int main(int argc,char *argv[ ])    
  18. {    
  19. pthread_t child_thread_id;     
  20. pthread_create(&child_thread_id,NULL,child_thread,NULL);    
  21. printf(“I’m father,my id is%u\n”,pthread_self());    
  22. pthread_once(&key_once,once_routine);    
  23. }  

程序运行结果如下：

I’m father,My id is 3086231232    
Key create success! My id is 3086231232    
I’m child,My id is 2086228400   

②线程属性

一．线程属性

       线程具有属性，用pthread_attr_t表示，在对该结构进行处理之前必须进行初始化，在使用后需要对其去除初始化。我们用pthread_attr_init函数对其初始化，用pthread_attr_destroy对其去除初始化。

名称:：

pthread_attr_init/pthread_attr_destroy

功能：

对线程属性初始化/去除初始化

头文件：

#include

函数原形：

int pthread_attr_init(pthread_attr_t *attr);

int pthread_attr_destroy(pthread_attr_t *attr);

参数：

Attr   线程属性变量

返回值：

若成功返回0，若失败返回-1。
       调用pthread_attr_init之后，pthread_t结构所包含的内容就是操作系统实现支持的线程所有属性的默认值。

       如果要去除对pthread_attr_t结构的初始化，可以调用pthread_attr_destroy函数。如果pthread_attr_init实现时为属性对象分配了动态内存空间，pthread_attr_destroy还会用无效的值初始化属性对象，因此如果经pthread_attr_destroy去除初始化之后的pthread_attr_t结构被pthread_create函数调用，将会导致其返回错误。 

线程属性结构如下：

typedef struct    
{    
	int    detachstate;   //线程的分离状态  
	int    schedpolicy;  //线程调度策略   
	struct sched_param  schedparam;    // 线程的调度参数   
	int    inheritsched;  //线程的继承性    
	int    scope;       //线程的作用域    
	size_t guardsize;   //线程栈末尾的警戒缓冲区大小  
	int    stackaddr_set;    
	void * stackaddr;   //线程栈的位置  
	size_t stacksize;    //线程栈的大小    
}pthread_attr_t;

每个个属性都对应一些函数对其查看或修改。下面我们分别介绍。 

二、线程的分离状态

       线程的分离状态决定一个线程以什么样的方式来终止自己。在默认情况下线程是非分离状态的，这种情况下，原有的线程等待创建的线程结束。只有当pthread_join（）函数返回时，创建的线程才算终止，才能释放自己占用的系统资源。

而分离线程不是这样子的，它没有被其他的线程所等待，自己运行结束了，线程也就终止了，马上释放系统资源。程序员应该根据自己的需要，选择适当的分离状态。所以如果我们在创建线程时就知道不需要了解线程的终止状态，则可以pthread_attr_t结构中的detachstate线程属性，让线程以分离状态启动。 

名称:：

pthread_attr_getdetachstate/pthread_attr_setdetachstate

功能：

获取/修改线程的分离状态属性

头文件：

#include

函数原形：

int pthread_attr_getdetachstate(const pthread_attr_t * attr,int *detachstate);

int pthread_attr_setdetachstate(pthread_attr_t *attr,int detachstate);

参数：

Attr   线程属性变量

Detachstate  线程的分离状态属性

返回值：

若成功返回0，若失败返回-1。

可以使用pthread_attr_setdetachstate函数把线程属性detachstate设置为下面的两个合法值之一：设置为PTHREAD_CREATE_DETACHED,以分离状态启动线程；或者设置为PTHREAD_CREATE_JOINABLE,正常启动线程。可以使用pthread_attr_getdetachstate函数获取当前的datachstate线程属性。

 以分离状态创建线程

#include    
  
void *child_thread(void *arg) 
{    
	printf("child thread run!\n");   
}       
  
int main(int argc,char *argv[ ])   
{    
	pthread_t tid;    
	pthread_attr_t attr;     
	pthread_attr_init(&attr);    
	pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);    
	pthread_create(&tid,&attr,fn,arg);    
	pthread_attr_destroy(&attr);    
	sleep(1);   
}

三、线程的继承性

       函数pthread_attr_setinheritsched和pthread_attr_getinheritsched分别用来设置和得到线程的继承性，这两个函数的定义如下： 

名称:：

pthread_attr_getinheritsched

pthread_attr_setinheritsched

功能：

获得/设置线程的继承性

头文件：

#include

函数原形：

int pthread_attr_getinheritsched(const pthread_attr_t *attr,int *inheritsched);

int pthread_attr_setinheritsched(pthread_attr_t *attr,int inheritsched);

参数：

attr            线程属性变量

inheritsched     线程的继承性

返回值：

若成功返回0，若失败返回-1。

      这两个函数具有两个参数，第1个是指向属性对象的指针，第2个是继承性或指向继承性的指针。继承性决定调度的参数是从创建的进程中继承还是使用在schedpolicy和schedparam属性中显式设置的调度信息。Pthreads不为inheritsched指定默认值，因此如果你关心线程的调度策略和参数，必须先设置该属性。

       继承性的可能值是PTHREAD_INHERIT_SCHED（表示新现成将继承创建线程的调度策略和参数）和PTHREAD_EXPLICIT_SCHED（表示使用在schedpolicy和schedparam属性中显式设置的调度策略和参数）。

       如果你需要显式的设置一个线程的调度策略或参数，那么你必须在设置之前将inheritsched属性设置为PTHREAD_EXPLICIT_SCHED.

       下面我来讲进程的调度策略和调度参数。我会结合下面的函数给出本函数的程序例子。

四、线程的调度策略

       函数pthread_attr_setschedpolicy和pthread_attr_getschedpolicy分别用来设置和得到线程的调度策略。 

名称:：

pthread_attr_getschedpolicy

pthread_attr_setschedpolicy

功能：

获得/设置线程的调度策略

头文件：

#include

函数原形：

int pthread_attr_getschedpolicy(const pthread_attr_t *attr,int *policy);

int pthread_attr_setschedpolicy(pthread_attr_t *attr,int policy);

参数：

attr             线程属性变量

policy         调度策略

返回值：

若成功返回0，若失败返回-1。

 这两个函数具有两个参数，第1个参数是指向属性对象的指针，第2个参数是调度策略或指向调度策略的指针。调度策略可能的值是先进先出（SCHED_FIFO）、轮转法（SCHED_RR）,或其它（SCHED_OTHER）。

       SCHED_FIFO策略允许一个线程运行直到有更高优先级的线程准备好，或者直到它自愿阻塞自己。在SCHED_FIFO调度策略下，当有一个线程准备好时，除非有平等或更高优先级的线程已经在运行，否则它会很快开始执行。

    SCHED_RR(轮循)策略是基本相同的，不同之处在于：如果有一个SCHED_RR

策略的线程执行了超过一个固定的时期(时间片间隔)没有阻塞，而另外的SCHED_RR或SCHBD_FIPO策略的相同优先级的线程准备好时，运行的线程将被抢占以便准备好的线程可以执行。

    当有SCHED_FIFO或SCHED_RR策赂的线程在一个条件变量上等持或等持加锁同一个互斥量时，它们将以优先级顺序被唤醒。即，如果一个低优先级的SCHED_FIFO线程和一个高优先织的SCHED_FIFO线程都在等待锁相同的互斥且，则当互斥量被解锁时，高优先级线程将总是被首先解除阻塞。 

五、线程的调度参数

       函数pthread_attr_getschedparam 和pthread_attr_setschedparam分别用来设置和得到线程的调度参数。 

名称:：

pthread_attr_getschedparam

pthread_attr_setschedparam

功能：

获得/设置线程的调度参数

头文件：

#include

函数原形：

int pthread_attr_getschedparam(const pthread_attr_t *attr,struct sched_param *param);

int pthread_attr_setschedparam(pthread_attr_t *attr,const struct sched_param *param);

参数：

attr              线程属性变量

param          sched_param结构

返回值：

若成功返回0，若失败返回-1。

这两个函数具有两个参数，第1个参数是指向属性对象的指针，第2个参数是sched_param结构或指向该结构的指针。结构sched_param在文件/usr/include /bits/sched.h中定义如下：     

[cpp]  view plain copy
  1. struct sched_param    
  2. {    
  3.     int sched_priority;   
  4. };  

结构sched_param的子成员sched_priority控制一个优先权值，大的优先权值对应高的优先权。系统支持的最大和最小优先权值可以用sched_get_priority_max函数和sched_get_priority_min函数分别得到。 

注意：如果不是编写实时程序，不建议修改线程的优先级。因为，调度策略是一件非常复杂的事情，如果不正确使用会导致程序错误，从而导致死锁等问题。如：在多线程应用程序中为线程设置不同的优先级别，有可能因为共享资源而导致优先级倒置。

名称:：

sched_get_priority_max

sched_get_priority_min

功能：

获得系统支持的线程优先权的最大和最小值

头文件：

#include

函数原形：

int sched_get_priority_max(int policy);

int sched_get_priority_min(int policy);

参数：

policy           系统支持的线程优先权的最大和最小值

返回值：

若成功返回0，若失败返回-1。

     下面是上面几个函数的程序例子：

#include 
#include  

void *child_thread(void *arg)
{
	int policy;
	int max_priority,min_priority;
	struct sched_param param;
	pthread_attr_t attr; 

	pthread_attr_init(&attr); /*初始化线程属性变量*/
	pthread_attr_setinheritsched(&attr,PTHREAD_EXPLICIT_SCHED); /*设置线程继承性*/
	pthread_attr_getinheritsched(&attr,&policy); /*获得线程的继承性*/

	if(policy==PTHREAD_EXPLICIT_SCHED)
		printf(“Inheritsched:PTHREAD_EXPLICIT_SCHED\n”);

	if(policy==PTHREAD_INHERIT_SCHED)
		printf(“Inheritsched:PTHREAD_INHERIT_SCHED\n”); 

	pthread_attr_setschedpolicy(&attr,SCHED_RR);/*设置线程调度策略*/
	pthread_attr_getschedpolicy(&attr,&policy);/*取得线程的调度策略*/

	if(policy==SCHED_FIFO)
		printf(“Schedpolicy:SCHED_FIFO\n”);

	if(policy==SCHED_RR)
		printf(“Schedpolicy:SCHED_RR\n”);

	if(policy==SCHED_OTHER)
		printf(“Schedpolicy:SCHED_OTHER\n”); 

	sched_get_priority_max(max_priority);/*获得系统支持的线程优先权的最大值*/
	sched_get_priority_min(min_priority);/* 获得系统支持的线程优先权的最小值*/

	printf(“Max priority:%u\n”,max_priority);
	printf(“Min priority:%u\n”,min_priority);

	param.sched_priority=max_priority;
	pthread_attr_setschedparam(&attr,?m);/*设置线程的调度参数*/ 
	printf("sched_priority:%u\n",param.sched_priority);/*获得线程的调度参数*/

	pthread_attr_destroy(&attr);
}

int main(int argc,char *argv[ ])
{
	pthread_t child_thread_id; 
	pthread_create(&child_thread_id,NULL,child_thread,NULL);
	pthread_join(child_thread_id,NULL);
}

六、线程的作用域

       函数pthread_attr_setscope和pthread_attr_getscope分别用来设置和得到线程的作用域，这两个函数的定义如下：      

名称:：

pthread_attr_setscope

pthread_attr_getscope

功能：

获得/设置线程的作用域

头文件：

#include

函数原形：

int pthread_attr_setscope(pthread_attr_t *attr,int scope);

int pthread_attr_getscope(const pthread_attr_t *attr,int *scope);

参数：

attr           线程属性变量

scope         线程的作用域

返回值：

若成功返回0，若失败返回-1。

       这两个函数具有两个参数，第1个是指向属性对象的指针，第2个是作用域或指向作用域的指针，作用域控制线程是否在进程内或在系统级上竞争资源，可能的值是PTHREAD_SCOPE_PROCESS（进程内竞争资源）PTHREAD_SCOPE_SYSTEM.（系统级上竞争资源）。 

七、线程堆栈的大小

       函数pthread_attr_setstacksize和pthread_attr_getstacksize分别用来设置和得到线程堆栈的大小，这两个函数的定义如下所示：

名称:：

pthread_attr_getdetstacksize

pthread_attr_setstacksize

功能：

获得/修改线程栈的大小

头文件：

#include

函数原形：

int pthread_attr_getstacksize(const pthread_attr_t *restrict attr,size_t *restrict stacksize);

int pthread_attr_setstacksize(pthread_attr_t *attr ,size_t *stacksize);

参数：

attr                线程属性变量

stacksize       堆栈大小  

返回值：

若成功返回0，若失败返回-1。

     这两个参数具有两个参数，第1个是指向属性对象的指针，第2个是堆栈大小或指向堆栈大小的指针

如果希望改变栈的默认大小，但又不想自己处理线程栈的分配问题，这时使用pthread_attr_setstacksize函数就非常用用。

八、线程堆栈的地址

       函数pthread_attr_setstackaddr和pthread_attr_getstackaddr分别用来设置和得到线程堆栈的位置，这两个函数的定义如下：

名称:：

pthread_attr_setstackaddr

pthread_attr_getstackaddr

功能：

获得/修改线程栈的位置

头文件：

#include

函数原形：

int pthread_attr_getstackaddr(const pthread_attr_t *attr,void **stackaddf);

int pthread_attr_setstackaddr(pthread_attr_t *attr,void *stackaddr);

参数：

attr           线程属性变量

stackaddr      堆栈地址

返回值：

若成功返回0，若失败返回-1。

 这两个函数具有两个参数，第1个是指向属性对象的指针，第2个是堆栈地址或指向堆栈地址的指针。

九、线程栈末尾的警戒缓冲区大小

       函数pthread_attr_getguardsize和pthread_attr_setguardsize分别用来设置和得到线程栈末尾的警戒缓冲区大小，这两个函数的定义如下：

名称:：

pthread_attr_getguardsize

pthread_attr_setguardsize

功能：

获得/修改线程栈末尾的警戒缓冲区大小

头文件：

#include

函数原形：

int pthread_attr_getguardsize(const pthread_attr_t *restrict attr,size_t *restrict guardsize);

int pthread_attr_setguardsize(pthread_attr_t *attr ,size_t *guardsize);

参数：

  

返回值：

若成功返回0，若失败返回-1。

 线程属性guardsize控制着线程栈末尾之后以避免栈溢出的扩展内存大小。这个属性默认设置为PAGESIZE个字节。可以把guardsize线程属性设为0，从而不允许属性的这种特征行为发生：在这种情况下不会提供警戒缓存区。同样地，如果对线程属性stackaddr作了修改，系统就会假设我们会自己管理栈，并使警戒栈缓冲区机制无效，等同于把guardsize线程属性设为0。

③信号灯

Posix有名信号灯

       函数sem_open创建一个新的有名信号灯或打开一个已存在的有名信号灯。有名信号灯总是既可用于线程间的同步，又可以用于进程间的同步。 

1.posix有名信号灯函数

名称:：

sem_open

功能：

创建并初始化有名信号灯

头文件：

#include

函数原形：

sem_t *sem_open(const char *name,int oflag,/*mode_t mode,unsigned int value*/);

参数：

name  信号灯的外部名字

oflag  选择创建或打开一个现有的信号灯

mode 权限位

value 信号灯初始值

返回值：

成功时返回指向信号灯的指针，出错时为SEM_FAILED

      oflag参数可以是0、O_CREAT（创建一个信号灯）或O_CREAT|O_EXCL（如果没有指定的信号灯就创建），如果指定了O_CREAT，那么第三个和第四个参数是需要的；其中mode参数指定权限位，value参数指定信号灯的初始值，通常用来指定共享资源的书面。该初始不能超过SEM_VALUE_MAX，这个常值必须低于为32767。二值信号灯的初始值通常为1，计数信号灯的初始值则往往大于1。

       如果指定了O_CREAT（而没有指定O_EXCL），那么只有所需的信号灯尚未存在时才初始化它。所需信号灯已存在条件下指定O_CREAT不是一个错误。该标志的意思仅仅是“如果所需信号灯尚未存在，那就创建并初始化它”。但是所需信号灯等已存在条件下指定O_CREAT|O_EXCL却是一个错误。

       sem_open返回指向sem_t信号灯的指针，该结构里记录着当前共享资源的数目。

[cpp]  view plain copy
  1. /*semopen.c*/  
  2.   
  3. #include    
  4. #include    
  5. #include     
  6. #include     
  7. #include      
  8.   
  9. int main(int argc,char **argv)   
  10. {  
  11.   
  12. sem_t *sem;   
  13.   
  14. if(argc!=2)   
  15. {    
  16.     printf(“please input a file name!\n”);   
  17.     exit(1);  
  18. }  
  19.   
  20. sem=sem_open(argv[1],O_CREAT,0644,1);    
  21. exit(0);  
  22.   
  23. }    

#gcc –lpthread –o semopen semopen.c

#./semopen

名称:：

sem_close

功能：

关闭有名信号灯

头文件：

#include

函数原形：

int sem_close(sem_t *sem);

参数：

sem 指向信号灯的指针

返回值：

若成功则返回0，否则返回-1。

  一个进程终止时，内核还对其上仍然打开着的所有有名信号灯自动执行这样的信号灯关闭操作。不论该进程是自愿终止的还是非自愿终止的，这种自动关闭都会发生。

       但应注意的是关闭一个信号灯并没有将它从系统中删除。这就是说，Posix有名信号灯至少是随内核持续的：即使当前没有进程打开着某个信号灯，它的值仍然保持。 

名称:：

sem_unlink

功能：

从系统中删除信号灯

头文件：

#include

函数原形：

int sem_unlink(count char *name);

参数：

name  信号灯的外部名字

返回值：

若成功则返回0，否则返回-1。

     有名信号灯使用sem_unlink从系统中删除。

每个信号灯有一个引用计数器记录当前的打开次数，sem_unlink必须等待这个数为0时才能把name所指的信号灯从文件系统中删除。也就是要等待最后一个sem_close发生。

[cpp]  view plain copy
  1. /*semunlink.c*/    
  2. #include   
  3. #include     
  4. #include     
  5. #include    
  6. #include      
  7.   
  8. int main(int argc,char **argv)   
  9. {   
  10. sem_t *sem;   
  11. int val;    
  12. if(argc!=2)   
  13. {  
  14.     printf(“please input a file name!\n”);    
  15.     exit(1);  
  16. }  
  17.   
  18. if((sem_unlink(argv[1]))!=0)    
  19.     perror(“sem_unlink”);   
  20. else    
  21.     printf(“success”);  
  22.   
  23. exit(0);    
  24. }     

名称:：

sem_getvalue

功能：

测试信号灯

头文件：

#include

函数原形：

int sem_getvalue(sem_t *sem,int *valp);

参数：

sem 指向信号灯的指针

返回值：

若成功则返回0，否则返回-1。

sem_getvalue在由valp指向的正数中返回所指定信号灯的当前值。如果该信号灯当前已上锁，那么返回值或为0，或为某个负数，其绝对值就是等待该信号灯解锁的线程数。

/*semgetvalue.c*/  
#include   
#include     
#include     
#include     
#include     
  
int main(int argc,char **argv)    
{    
	sem_t *sem;    
	int val;  
  
	if(argc!=2)    
	{    
		printf(“please input a file name!\n”);    
		exit(1);   
	}    
	sem=sem_open(argv[1],0);   
	sem_getvalue(sem,&val);    
	printf(“getvalue:value=%d\n”,val);  
	exit(0);    
}


名称:：

sem_wait/sem_trywait

功能：

等待共享资源

头文件：

#include

函数原形：

int sem_wait(sem_t *sem);

int sem_trywait(sem_t *sem);

参数：

sem 指向信号灯的指针

返回值：

若成功则返回0，否则返回-1。

我们可以用sem_wait来申请共享资源，sem_wait函数可以测试所指定信号灯的值，如果该值大于0，那就将它减1并立即返回。我们就可以使用申请来的共享资源了。如果该值等于0，调用线程就被进入睡眠状态，直到该值变为大于0，这时再将它减1，函数随后返回。sem_wait操作必须是原子的。sem_wait和sem_trywait的差别是：当所指定信号灯的值已经是0时，后者并不将调用线程投入睡眠。相反，它返回一个EAGAIN错误。 

下面的程序我们先不去运行，稍后再运行。

/*semwait.c*/    
#include   
#include     
#include     
#include    
#include    
  
int main(int argc,char **argv)  
{    
	sem_t *sem;   
	int val;    
  
	if(argc!=2)    
	{    
		printf("please input a file name!\n");    
		exit(1);    
	}  
  
	sem=sem_open(argv[1],0);   
	sem_wait(sem);    
	sem_getvalue(sem,&val);   
	printf("pid %ld has semaphore,value=%d\n",(long)getpid(),val); 
 
	pause();  
	exit(0);   
}

名称:：

sem_post

功能：

挂出共享资源

头文件：

#include

函数原形：

int sem_post(sem_t *sem);

int sem_getvalue(sem_t *sem,int *valp);

参数：

sem 指向信号灯的指针

返回值：

若成功则返回0，否则返回-1。

 当一个线程使用完某个信号灯时，它应该调用sem_post来告诉系统申请的资源已经用完。本函数和sem_wait函数的功能正好相反，它把所指定的信号灯的值加1，然后唤醒正在等待该信号灯值变为正数的任意线程。 

下面的程序我们先不去运行，稍后再运行。

/*sempost.c*/    
#include     
#include   
#include     
#include    
#include     
  
int main(int argc,char **argv)   
{    
	sem_t *sem;    
	int val;    
  
	if(argc!=2)    
	{  
		printf("please input a file name!\n");   
		exit(1);    
	}  
  
	sem=sem_open(argv[1],0);  
	sem_post(sem);    
	sem_getvalue(sem,&val);   
	printf("value=%d\n", val);  
	exit(0);    
}

2.关于posix有名信号灯使用的几点注意

我们要注意以下几点：

1.Posix有名信号灯的值是随内核持续的。也就是说，一个进程创建了一个信号灯，这个进程结束后，这个信号灯还存在，并且信号灯的值也不会改变。

下面我们利用上面的几个程序来证明这点

#./semopen test

#./semgetvalue test

value=1  信号的值仍然是1 

2. 当持有某个信号灯锁的进程没有释放它就终止时，内核并不给该信号灯解锁。

#./semopen test

#./semwait test&

pid 1834 has semaphore,value=0

#./semgetvalue test

value=0   信号量的值变为0了 

3.posix有名信号灯应用于多线程

[cpp]  view plain copy
  1. #include  
  2. #include     
  3. #include     
  4. #include     
  5. #include      
  6.   
  7. void *thread_function(void *arg); /*线程入口函数*/   
  8. void print(pid_t); /*共享资源函数*/    
  9. sem_t *sem; /*定义Posix有名信号灯*/    
  10. int val; /*定义信号灯当前值*/     
  11.   
  12. int main(int argc,char *argv[])    
  13. {    
  14. int n=0;    
  15. if(argc!=2)    
  16. {    
  17.     printf(“please input a file name!\n”);   
  18.     exit(1);    
  19. }    
  20. sem=sem_open(argv[1],O_CREAT,0644,3); /*打开一个信号灯*/   
  21. while(n++<5) /*循环创建5个子线程，使它们同步运行*/   
  22. {    
  23.     if（（pthread_create(&a_thread,NULL,thread_function,NULL)）!=0）   
  24.     {    
  25.          perror(“Thread creation failed”);    
  26.          exit(1);    
  27.     }    
  28. }    
  29. pthread_join(a_thread,NULL);    
  30. sem_close(bin_sem);    
  31. sem_unlink(argv[1]);    
  32. }     
  33.   
  34. void *thread_function(void *arg)   
  35. {    
  36.     sem_wait(sem); /*申请信号灯*/  
  37.     print(); /*调用共享代码段*/  
  38.     sleep(1);    
  39.     sem_post(sem); /*释放信号灯*/    
  40.     printf(“I’m finished,my tid is %d\n”,pthread_self());    
  41. }    
  42. void print()    
  43. {    
  44.     printf(“I get it,my tid is %d\n”,pthread_self());    
  45.     sem_getvalue(sem,&val);    
  46.     printf(“Now the value have %d\n”,val);    
  47. }     

程序用循环的方法建立5个线程，然后让它们调用同一个线程处理函数thread_function，在函数里我们利用信号量来限制访问共享资源的线程数。共享资源我们用print函数来代表，在真正编程中它有可以是一个终端设备（如打印机）或是一段有实际意义的代码。

运行结果为：

#gcc –lpthread –o 8_1 8_1.c

#./8_1 test

I get it,my tid is 1082330304   
Now the value have 2    
Iget it,my pid is 1894    
Now the value have 1    
Iget it,my pid is 1895    
Now the value have 0    
I’m finished,my pid is 1893   
I’m finished,my pid is 1894   
I’m finished,my pid is 1895   
I get it,my pid is 1896    
Now the value have 2    
I get it,mypid is 1897    
Now the value have 1    
I’m finished,my pid is 1896    
I’m finished,my pid is 1897 

4.posix有名信号灯应用于多进程

下面就是应用Posix有名信号灯的一个小程序。用它来限制访问共享代码的进程数目。

#include 
#include 
#include 
#include 
void print(pid_t);
sem_t *sem; /*定义Posix有名信号灯*/
int val; /*定义信号灯当前值*/
int main(int argc,char *argv[])
{
int n=0;
if(argc!=2)
{
    printf(“please input a file name!\n”);
    exit(1);
}
sem=sem_open(argv[1],O_CREAT,0644,2); /*打开一个信号灯, 初值设为2*/
while(n++<5) /*循环创建5个子进程，使它们同步运行*/
{
    if(fork()==0) 
    {
        sem_wait(sem); /*申请信号灯*/
        print(getpid()); /*调用共享代码段*/
        sleep(1); 
        sem_post(sem); /*释放信号灯*/
        printf(“I’m finished,my pid is %d\n”,getpid());
        return 0; 
    }
wait(); /*等待所有子进程结束*/
sem_close(sem);
sem_unlink(argv[1]);
exit(0);
}
void print(pid_t pid)
{
printf(“I get it,my pid is %d\n”,pid);
sem_getvalue(sem,&val);
printf(“Now the value have %d\n”,val);
}

程序编译后运行会得到如下结果：

#./8_2 8_2.c

  1. I get it,my tid is 1082330304   
  2. Now the value have 1    
  3. I get it,my tid is 1090718784  
  4. Now the value have 0    
  5. I finished,my pid is 1082330304   
  6. I finished,my pid is 1090718784   
  7. I get it,my tid is 1099107264    
  8. Now the value have 1    
  9. I get it,my tid is 1116841120  
  10. Now the value have 0    
  11. I finished,my pid is 1099107264  
  12. I finished,my pid is 1116841120    
  13. I get it,my tid is 1125329600    
  14. Now the value have 1    
  15. I finished,my pid is 1125329600 

二、基于内存的信号灯

 前面已经介绍了Posix有名信号灯。这些信号灯由一个name参数标识，它通常指代文件系统中的某个文件。然而Posix也提供基于内存的信号灯，它们由应用程序分配信号灯的内存空间，然后由系统初始化它们的值。

7.

名称:：

sem_init/sem_destroy

功能：

初始化/关闭信号等

头文件：

#include <semaphore.h>

函数原形：

int sem_init(sem_t *sem,int shared,unsigned int value);

int sem_getvalue(sem_t *sem);

参数：

sem    指向信号灯的指针

shared  作用范围

value   信号灯初始值

返回值：

若成功则返回0，否则返回-1。

 基于内存的信号灯是由sem_init初始化的。sem参数指向必须由应用程序分配的sem_t变量。如果shared为0，那么待初始化的信号灯是在同一进程的各个线程共享的，否则该信号灯是在进程间共享的。当shared为零时，该信号灯必须存放在即将使用它的所有进程都能访问的某种类型的共享内存中。跟sem_open一样，value参数是该信号灯的初始值。

 使用完一个基于内存的信号灯后，我们调用sem_destroy关闭它。

除了sem_open和sem_close外，其它的poisx有名信号灯函数都可以用于基于内存的信号灯。

注意：posix基于内存的信号灯和posix有名信号灯有一些区别，我们必须注意到这些。

1.sem_open不需要类型与shared的参数，有名信号灯总是可以在不同进程间共享的。

2.sem_init不使用任何类似于O_CREAT标志的东西，也就是说，sem_init总是初始化信号灯的值。因此，对于一个给定的信号灯，我们必须小心保证只调用一次sem_init。

3.sem_open返回一个指向某个sem_t变量的指针，该变量由函数本身分配并初始化。但sem_init的第一个参数是一个指向某个sem_t变量的指针，该变量由调用者分配，然后由sem_init函数初始化。

4.posix有名信号灯是通过内核持续的，一个进程创建一个信号灯，另外的进程可以通过该信号灯的外部名（创建信号灯使用的文件名）来访问它。posix基于内存的信号灯的持续性却是不定的，如果基于内存的信号灯是由单个进程内的各个线程共享的，那么该信号灯就是随进程持续的，当该进程终止时它也会消失。如果某个基于内存的信号灯是在不同进程间同步的，该信号灯必须存放在共享内存区中，这要只要该共享内存区存在，该信号灯就存在。

5.基于内存的信号灯应用于线程很麻烦（待会你会知道为什么），而有名信号灯却很方便，基于内存的信号灯比较适合应用于一个进程的多个线程。

下面是posix基于内存的信号灯实现一个进程的各个线程间的互次。

#include 
#include 
#include 
#include 
#include 
#incude 
void *thread_function(void *arg); /*线程入口函数*/
void print(void); /*共享资源函数*/
sem_t bin_sem; /*定义信号灯*/
int value; /*定义信号量的灯*/
int main()
{
int n=0;
pthread_t a_thread; 

if((sem_init(&bin_sem,0,2))!=0) /*初始化信号灯，初始值为2*/
{
    perror(“sem_init”);
    exit(1);
}
while(n++<5) /*循环创建5个线程*/
{
    if((pthread_create(&a_thread,NULL,thread_function,NULL))!=0) 
{
    perror(“Thread creation failed”);
    exit(1);
}
}
pthread_join(a_thread,NULL);/*等待子线程返回*/
}
void *thread_function(void *arg)
{
sem_wait(&bin_sem); /*等待信号灯*/
print();
sleep(1);
sem_post(&bin_sem); /*挂出信号灯*/
printf(“I finished,my pid is %d\n”,pthread_self());
pthread_exit(arg);
}

void print()
{
printf(“I get it,my tid is %d\n”,pthread_self());
sem_getvalue(&bin_sem,&value); /*获取信号灯的值*/
printf(“Now the value have %d\n”,value);
}


posix基于内存的信号灯和有名信号灯基本是一样的，上面的几点区别就可以了。

下面是运行结果：

#gcc –lpthread –o seminitthread seminitthread.c

#./seminitthread 

I get it,my tid is 1082330304
Now the value have 1
I get it,my tid is 1090718784
Now the value have 0
I finished,my pid is 1082330304
I finished,my pid is 1090718784
I get it,my tid is 1099107264
Now the value have 1
I get it,my tid is 1116841120
Now the value have 0
I finished,my pid is 1099107264
I finished,my pid is 1116841120
I get it,my tid is 1125329600
Now the value have 1
I finished,my pid is 1125329600

下面是经典的生产者消费者问题： 

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define FIFO "myfifo"
#define N 5
int lock_var;
time_t end_time;
char buf_r[100];
sem_t mutex,full,avail;/*定义３个信号量，full标识缓冲区是否为满，avail标识缓冲区是否为空．*/

int fd;
void pthread1(void *arg);
void pthread2(void *arg);
void consumer(void *arg);
void productor(void *arg);

int main(int argc, char *argv[])
{
    pthread_t id1,id2;
    pthread_t mon_th_id;
    int ret;
    end_time = time(NULL)+30;
    if((mkfifo(FIFO,O_CREAT|O_EXCL)<0)&&(errno!=EEXIST))
        printf("cannot create fifoserver\n");
    printf("Preparing for reading bytes...\n");
    memset(buf_r,0,sizeof(buf_r));
    fd=open(FIFO,O_RDWR|O_NONBLOCK,0);
    if(fd==-1)
    {
        perror("open");
        exit(1);
    }

    ret=sem_init(&mutex,0,1);
    ret=sem_init(&avail,0,N);
    ret=sem_init(&full,0,0);
    if(ret!=0)
    {
        perror("sem_init");
    }
    ret=pthread_create(&id1,NULL,(void *)productor, NULL);
    if(ret!=0)
        perror("pthread cread1");
    ret=pthread_create(&id2,NULL,(void *)consumer, NULL);
    if(ret!=0)
        perror("pthread cread2");
    pthread_join(id1,NULL);
    pthread_join(id2,NULL);
    exit(0);
}

void productor(void *arg)
{
    int i,nwrite;
    while(time(NULL) < end_time){
        sem_wait(&avail);
        sem_wait(&mutex);
        if((nwrite=write(fd,"hello",5))==-1)
     {

            if(errno==EAGAIN)
                printf("The FIFO has not been read yet.Please try later\n");
     }
        else
            printf("write hello to the FIFO\n");
        sem_post(&full);
        sem_post(&mutex);
        sleep(1);
    }
}
void consumer(void *arg)
{
    int nolock=0;
    int ret,nread;
    while(time(NULL) < end_time){
        sem_wait(&full);
        sem_wait(&mutex);
        memset(buf_r,0,sizeof(buf_r));
        if((nread=read(fd,buf_r,100))==-1){
            if(errno==EAGAIN)
                printf("no data yet\n");
     }

        printf("read %s from FIFO\n",buf_r);
        sem_post(&avail);
        sem_post(&mutex);
        sleep(1);
    }
}

下面是posix基于内存的信号灯实现各进程间的互斥。但要注意它并不能得到我们想要的结果。 

#include 
#include 
#include 
#include 

void print(pid_t);
sem_t *sem; /*定义Posix有名信号灯*/
int val; /*定义信号灯当前值*/

int main(int argc,char *argv[])
{
	int n=0;
	sem=sem_open(argv[1],O_CREAT,0644,3); /*打开一个信号灯*/
	sem_getvalue(sem,&val); /*查看信号灯的值*/
	printf("The value have %d\n",val);
	while(n++<5) /*循环创建5个子进程，使它们同步运行*/
	{
		if(fork()==0) 
		{
			sem_wait(sem); /*申请信号灯*/
			print(getpid()); /*调用共享代码段*/
			sleep(1); 
			sem_post(sem); /*释放信号灯*/
			printf("I'm finished,my pid is %d\n",getpid());
			return 0; 
		}
	wait(); /*等待所有子进程结束*/
	return 0;
}

void print(pid_t pid)
{
	printf("I get it,my pid is %d\n",pid);
	sem_getvalue(sem,&val);
	printf("Now the value have %d\n",val);
}

下面是运行结果：

#cc –lpthread –o sem sem.c

#./sem 

[cpp]  view plain copy
  1. The value have 3    
  2. I get it,my pid is 2236    
  3. Now the value have 2    
  4. I get it,my pid is 2237    
  5. Now the value have 2    
  6. I get it,my pid is 2238    
  7. Now the value have 2    
  8. I get it,my pid is 2239    
  9. Now the value have 2    
  10. Iget it,my pid is 2240    
  11. Now the value have 2    
  12. I’m finished,my pid is 2236   
  13. I’m finished,my pid is 2237   
  14. I’m finished,my pid is 2238    
  15. I’m finished,my pid is 2239    
  16. I’m finished,my pid is 2240  

问题在于sem信号灯不在共享内存区中。fork出来的子进程通常不共享父进程的内存空间。子进程是在父进程内存空间的拷贝上启动的，它跟共享内存不是一回事。

④互斥锁

一、什么是互斥锁

       另一种在多线程程序中同步访问手段是使用互斥量。程序员给某个对象加上一把“锁”，每次只允许一个线程去访问它。如果想对代码关键部分的访问进行控制，你必须在进入这段代码之前锁定一把互斥量，在完成操作之后再打开它。 

       互斥量函数有

       pthread_mutex_init 初始化一个互斥量

       pthread_mutex_lock 给一个互斥量加锁

       pthread_mutex_trylock 加锁，如果失败不阻塞

       pthread_mutex_unlock 解锁

       可以通过使用pthread的互斥接口保护数据，确保同一时间只有一个线程访问数据。互斥量从本质上说是一把锁，在访问共享资源前对互斥量进行加锁，在访问完成后释放互斥量上的锁。对互斥量进行加锁以后，任何其他试图再次对互斥量加锁的线程将会被阻塞直到当前线程释放该互斥锁。如果释放互斥锁时有多个线程阻塞，所以在该互斥锁上的阻塞线程都会变成可进行状态，第一个变成运行状态的线程可以对互斥量加锁，其他线程在次被阻塞，等待下次运行状态。

       互斥量用pthread_mutex_t数据类型来表示，在使用互斥量以前，必须首先对它进行初始化，可以把它置为常量PTHREAD_MUTEX_INITIALIZER(只对静态分配的互斥量)，也可以通过调用pthread_mutex_init函数进行初始化，如果动态地分配互斥量，那么释放内存前需要调用pthread_mutex_destroy. 

二、初始化/回收互斥锁

名称:：

pthread_mutexattr_init

功能：

初始化互斥锁。

头文件：

#include

函数原形：

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

参数：

mutex  互斥量

attr     互斥锁属性

返回值：

若成功则返回0，否则返回错误编号。

 mutex是我们要锁住的互斥量，attr是互斥锁的属性，可用相应的函数修改，我们在下章介绍，要用默认的属性初始化互斥量，只需把attr设置为NULL。

名称:：

pthread_mutex_destroy

 

功能：

释放对互斥变量分配的资源

 

头文件：

#include

函数原形：

int  pthread_mutex_destroy(pthread_mutex_t *mutex);

参数：

  

返回值：

若成功则返回0，否则返回错误编号。

三、对互斥量加减锁 

名称:：

pthread_mutex_lock/ pthread_mutex_trylock/ pthread_mutex_unlock

 

功能：

对互斥量加/减锁

 

头文件：

#include

函数原形：

int pthread_mutex_lock(pthread_mutex_t *mutex);

int pthread_mutex_trylock(pthread_mutex_t *mutex);

int pthread_mutex_unlock(pthread_mutex_t *mutex);

参数：

  

返回值：

若成功则返回0，否则返回错误编号。

对互斥量进行加锁，需要调用pthread_mutex_lock,如果互斥量已经上锁，调用线程阻塞直至互斥量解锁。对互斥量解锁，需要调用pthread_mutex_unlock.

       如果线程不希望被阻塞，他可以使用pthread_mutex_trylock尝试对互斥量进行加锁。如果调用pthread_mutex_trylock时互斥量处于未锁住状态，那么pthread_mutex_trylock将锁住互斥量，否则就会失败，不能锁住互斥量，而返回EBUSY。 

下面试例子可以证明对互斥量加锁的必要性：

我们先来看不加锁的程序。

[cpp]  view plain copy
  1. #inlcude    
  2. #include     
  3. #inlcude     
  4. #include      
  5.   
  6. viid *thread_function(void *arg);   
  7. int run_now=1;   /*用run_now代表共享资源*/   
  8.   
  9. int main()    
  10. {    
  11. int print_count1=0; /*用于控制循环*/  
  12. prhread_t a_thread;   
  13.   
  14. if(pthread_create(&a_thread,NULL,thread_function,NULL)!=0)   /*创建一个进程*/   
  15. {  
  16.     perror(“Thread createion failed”);    
  17.     exit(1);   
  18. }    
  19.   
  20. while(print_count1++<5)   
  21. {    
  22.     if(run_now==1)  /主线程：如果run_now为1就把它修改为2*/   
  23.     {    
  24.         printf(“main thread is run\n”);    
  25.         run_now=2;    
  26.     }   
  27.     else   
  28.     {    
  29.         printf(“main thread is sleep\n”);    
  30.         sleep(1); 
  31.     }    
  32. }    
  33. pthread_join(a_thread,NULL); /*等待子线程结束*/   
  34. exit(0);    
  35. }    
  36. void *thread_function(void *arg)   
  37. {    
  38. int print_count2 = 0;   
  39. while(print_count2++ < 5)    
  40. {    
  41.     if(run_now==2)  /子线程：如果run_now为1就把它修改为1*/  
  42.     {    
  43.         printf(“function thread is run\n”);    
  44.         run_now=1;    
  45.     }    
  46.     else    
  47.     {    
  48.         printf(“function thread is sleep\n”);   
  49.         sleep(1);    
  50.     }    
  51. }    
  52. pthread_exit(NULL);    
  53. }  

运行上面程序的运行结果为:

[cpp]  view plain copy
  1. function thread is sleep    
  2. main thread is run    
  3. main thread is sleep    
  4. main thread is sleep    
  5. function thread is run   
  6. function thread is sleep    
  7. main thread is run    
  8. main thread is sleep    
  9. function thread is run  
  10. function thread is sleep  

我们可以看到main线程和function线程是交替运行的。它们都可以对run_now进行操作。

下面是加锁的程序。

[cpp]  view plain copy
  1. #inlcude    
  2. #include    
  3. #inlcude   
  4.   
  5. viid *thread_function(void *arg);   
  6.   
  7. int run_now=1;  /*用run_now代表共享资源*/  
  8. pthread_mutex_t work_mutex;  /*定义互斥量*/    
  9.   
  10. int main()    
  11. {    
  12. int res;    
  13. int print_count1=0;    
  14. prhread_t a_thread;     
  15.   
  16. if(pthread_mutex_init(&work_mutex,NULL)!=0)  /*初始化互斥量*/   
  17. {    
  18.     perror(“Mutex init faied”);   
  19.     exit(1);    
  20. }    
  21.   
  22. if(pthread_create(&a_thread,NULL,thread_function,NULL)!=0)  /*创建新线程*/    
  23. {    
  24.     perror(“Thread createion failed”);    
  25.     exit(1);    
  26. }     
  27.   
  28. if(pthread_mutex_lock(&work_mutex)!=0)  /*对互斥量加锁*/    
  29. {    
  30.     preeor(“Lock failed”);    
  31.     exit(1);    
  32. }    
  33. else    
  34.     printf(“main lock\n”);    
  35.   
  36. while(print_count1++<5)    
  37. {    
  38.     if(run_now==1)  /主线程：如果run_now为1就把它修改为2*/    
  39.     {    
  40.         printf(“main thread is run\n”);    
  41.         run_now=2;    
  42.     }    
  43.     else    
  44.     {    
  45.         printf(“main thread is sleep\n”);   
  46.         sleep(1);    
  47.     }    
  48. }     
  49.   
  50. if(pthread_mutex_unlock(&work_mutex)!=0) /*对互斥量解锁*/    
  51. {    
  52.     preeor(“unlock failed”);    
  53.     exit(1);    
  54. }    
  55. else  
  56.     printf(“main unlock\n”);     
  57.   
  58. pthread_mutex_destroy(&work_mutex); /*收回互斥量资源*/    
  59. pthread_join(a_thread,NULL); /*等待子线程结束*/    
  60. exit(0);    
  61. }    
  62.   
  63. void *thread_function(void *arg)    
  64. {    
  65. int print_count2=0;   
  66. sleep(1);    
  67. if(pthread_mutex_lock(&work_mutex)!=0)   
  68. {    
  69.     perror(“Lock failed”);    
  70.     exit(1);    
  71. }    
  72. else    
  73.     printf(“function lock\n”);    
  74. while(print_count2++<5)    
  75. {    
  76.     if(run_now==2)  /分进程：如果run_now为1就把它修改为1*/   
  77.     {    
  78.         printf(“function thread is run\n”);    
  79.         run_now=1;    
  80.     }    
  81.     else    
  82.     {    
  83.         printf(“function thread is sleep\n”);    
  84.         sleep(1);    
  85.     }    
  86. }    
  87. if(pthread_mutex_unlock(&work_mutex)!=0)  /*对互斥量解锁*/   
  88. {    
  89.     perror(“unlock failed”);    
  90.     exit(1);    
  91. }   
  92. else    
  93.     printf(“function unlock\n”);    
  94. pthread_exit(NULL);    
  95. }     

下面是运行结果：

[cpp]  view plain copy
  1. main lock    
  2. main thread is run    
  3. main thread is sleep   
  4. main thread is sleep    
  5. main thread is sleep    
  6. main thread is sleep    
  7. main unlock    
  8. function lock    
  9. function thread is run    
  10. function thread is sleep    
  11. function thread is sleep    
  12. function thread is sleep    
  13. function thread is sleep    
  14. function unlock  

我们从运行结果可以看到，当主进程把互斥量锁住后，子进程就不能对共享资源进行操作了。

四、互斥锁属性

       线程和线程的同步对象（互斥量，读写锁，条件变量）都具有属性。在修改属性前都需要对该结构进行初始化。使用后要把该结构回收。我们用pthread_ mutexattr_init函数对pthread_mutexattr结构进行初始化，用pthread_mutexattr_destroy函数对该结构进行回收。

名称:：

pthread_mutexattr_init/pthread_mutexattr_destroy

功能：

初始化/回收pthread_mutexattr_t结构

头文件：

#include

函数原形：

int pthread_mutexattrattr_init(pthread_mutexattr_t *attr);

int pthread_mutexattrattr_destroy( pthread_mutexattr_t *attr );

参数：

attr    pthread_mutexattr_t结构变量

参数：

若成功返回0，若失败返回错误编号。

      pthread_mutexattr_init将属性对象的值初始化为缺省值。并分配属性对象占用的内存空间。

attr中pshared属性表示用这个属性对象创建的互斥锁的作用域，它的取值可以是PTHREAD_PROCESS_PRIVATE(缺省值，表示由这个属性对象创建的互斥锁只能在进程内使用)或PTHREAD_PROCESS_SHARED。 

互斥量属性分为共享互斥量属性和类型互斥量属性。两种属性分别由不同的函数得到并由不同的函数进行修改。pthread_mutexattr_getpshared和pthread_mutexattr_setpshared函数可以获得和修改共享互斥量属性。pthread_mutexattr_gettype和pthread_mutexattr_settype函数可以获得和修改类型互斥量属性。下面我们分别介绍。

名称:：

pthread_mutexattr_getpshared/pthread_mutexattr_setpshared

功能：

获得/修改共享互斥量属性

头文件：

#include

函数原形：

int pthread_mutexattrattr_ getpshared ( const pthread_attr_t *restrict attr,int*restrict pshared);

int pthread_mutexattrattr_ setpshared (  const pthread_attr_t *restrict attr,int pshared);

参数：

  

参数：

若成功返回0，若失败返回错误编号。

共享互斥量属性用于规定互斥锁的作用域。互斥锁的域可以是进程内的也可以是进程间的。pthread_mutexattrattr_ getpshared可以返回属性对象的互斥锁作用域属性。可以是以下值：PTHREAD_PROCESS_SHARED，PTHREAD_PROCESS_PRIVATE。如果互斥锁属性对象的pshared属性被置PTHREAD_PROCESS_SHARED。那么由这个属性对象创建的互斥锁将被保存在共享内存中，可以被多个进程中的线程共享。如果pshared属性被置为PTHREAD_PROCESS_PRIVATE，那么只有和创建这个互斥锁的线程在同一个进程中的线程才能访问这个互斥锁。 

名称:：

pthread_mutexattr_gettype/pthread_mutexattr_settype

功能：

获得/修改类型互斥量属性

头文件：

#include

函数原形：

int pthread_mutexattrattr_ getpshared ( const pthread_attr_t *restrict attr,int*restrict pshared);

int pthread_mutexattrattr_ setpshared (  const pthread_attr_t *restrict attr,int pshared);

参数：

  

参数：

若成功返回0，若失败返回错误编号。

pthread_mutexattr_gettype函数可以获得互斥锁类型属性。缺省的互斥锁类型属性是PTHREAD_MUTEX_DEFAULT。

合法的类型属性值有：

PTHREAD_MUTEX_NORMAL；

PTHREAD_MUTEX_ERRORCHECK；

PTHREAD_MUTEX_RECURSIVE；

PTHREAD_MUTEX_DEFAULT。

类型说明：

PTHREAD_MUTEX_NORMAL

这种类型的互斥锁不会自动检测死锁。如果一个线程试图对一个互斥锁重复锁定，将会引起这个线程的死锁。如果试图解锁一个由别的线程锁定的互斥锁会引发不可预料的结果。如果一个线程试图解锁已经被解锁的互斥锁也会引发不可预料的结果。 

PTHREAD_MUTEX_ERRORCHECK

这种类型的互斥锁会自动检测死锁。如果一个线程试图对一个互斥锁重复锁定，将会返回一个错误代码。如果试图解锁一个由别的线程锁定的互斥锁将会返回一个错误代码。如果一个线程试图解锁已经被解锁的互斥锁也将会返回一个错误代码。 

PTHREAD_MUTEX_RECURSIVE

如果一个线程对这种类型的互斥锁重复上锁，不会引起死锁，一个线程对这类互斥锁的多次重复上锁必须由这个线程来重复相同数量的解锁，这样才能解开这个互斥锁，别的线程才能得到这个互斥锁。如果试图解锁一个由别的线程锁定的互斥锁将会返回一个错误代码。如果一个线程试图解锁已经被解锁的互斥锁也将会返回一个错误代码。这种类型的互斥锁只能是进程私有的（作用域属性为PTHREAD_PROCESS_PRIVATE）。 

PTHREAD_MUTEX_DEFAULT

这种类型的互斥锁不会自动检测死锁。如果一个线程试图对一个互斥锁重复锁定，将会引起不可预料的结果。如果试图解锁一个由别的线程锁定的互斥锁会引发不可预料的结果。如果一个线程试图解锁已经被解锁的互斥锁也会引发不可预料的结果。POSIX标准规定，对于某一具体的实现，可以把这种类型的互斥锁定义为其他类型的互斥锁。 

五、应用互斥量需要注意的几点

       1、互斥量需要时间来加锁和解锁。锁住较少互斥量的程序通常运行得更快。所以，互斥量应该尽量少，够用即可，每个互斥量保护的区域应则尽量大。

       2、互斥量的本质是串行执行。如果很多线程需要领繁地加锁同一个互斥量，

则线程的大部分时间就会在等待，这对性能是有害的。如果互斥量保护的数据(或代码)包含彼此无关的片段，则可以特大的互斥量分解为几个小的互斥量来提高性能。这样，任意时刻需要小互斥量的线程减少，线程等待时间就会减少。所以，互斥量应该足够多(到有意义的地步)，每个互斥量保护的区域则应尽量的少。

⑤条件变量

一、什么是条件变量

       与互斥锁不同，条件变量是用来等待而不是用来上锁的。条件变量用来自动阻塞一个线程，直到某特殊情况发生为止。通常条件变量和互斥锁同时使用。

       条件变量使我们可以睡眠等待某种条件出现。条件变量是利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作：一个线程等待"条件变量的条件成立"而挂起；另一个线程使"条件成立"（给出条件成立信号）。

条件的检测是在互斥锁的保护下进行的。如果一个条件为假，一个线程自动阻塞，并释放等待状态改变的互斥锁。如果另一个线程改变了条件，它发信号给关联的条件变量，唤醒一个或多个等待它的线程，重新获得互斥锁，重新评价条件。如果两进程共享可读写的内存，条件变量可以被用来实现这两进程间的线程同步。

       使用条件变量之前要先进行初始化。可以在单个语句中生成和初始化一个条件变量如：

pthread_cond_t my_condition=PTHREAD_COND_INITIALIZER;（用于进程间线程的通信）。

也可以利用函数pthread_cond_init动态初始化。 

二、条件变量函数

名称：

pthread_cond_init

目标：

条件变量初始化

头文件：

#include < pthread.h>

函数原形：

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

参数：

cptr  条件变量

attr  条件变量属性

返回值：

成功返回0，出错返回错误编号。

 pthread_cond_init函数可以用来初始化一个条件变量。他使用变量attr所指定的属性来初始化一个条件变量，如果参数attr为空，那么它将使用缺省的属性来设置所指定的条件变量。 

名称：

pthread_cond_destroy

目标：

条件变量摧毁

头文件：

#include < pthread.h>

函数原形：

 

int pthread_cond_destroy(pthread_cond_t *cond);

参数：

cptr  条件变量

返回值：

成功返回0，出错返回错误编号。

pthread_cond_destroy函数可以用来摧毁所指定的条件变量，同时将会释放所给它分配的资源。调用该函数的进程也并不要求等待在参数所指定的条件变量上。

名称：

pthread_cond_wait/pthread_cond_timedwait

目标：

条件变量等待

头文件：

#include < pthread.h>

函数原形：

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

int pthread_cond_timedwait(pthread_cond_t *cond,pthread_mutex_t mytex,

const struct timespec *abstime);

参数：

cond 条件变量

mutex 互斥锁

返回值：

成功返回0，出错返回错误编号。

第一个参数*cond是指向一个条件变量的指针。第二个参数*mutex则是对相关的互斥锁的指针。函数pthread_cond_timedwait函数类型与函数pthread_cond_wait,区别在于，如果达到或是超过所引用的参数*abstime,它将结束并返回错误ETIME.pthread_cond_timedwait函数的参数*abstime指向一个timespec结构。该结构如下：

[cpp]  view plain copy
  1. typedef struct timespec{    
  2.        time_t tv_sec;    
  3.        long tv_nsex;    
  4. }timespec_t;  

名称：

pthread_cond_signal/pthread_cond_broadcast

目标：

条件变量通知

头文件：

#include < pthread.h>

函数原形：

int pthread_cond_signal(pthread_cond_t *cond);

int pthread_cond_broadcast(pthread_cond_t *cond);

参数：

cond 条件变量

返回值：

成功返回0，出错返回错误编号。

 参数*cond是对类型为pthread_cond_t 的一个条件变量的指针。当调用pthread_cond_signal时一个在相同条件变量上阻塞的线程将被解锁。如果同时有多个线程阻塞，则由调度策略确定接收通知的线程。如果调用pthread_cond_broadcast,则将通知阻塞在这个条件变量上的所有线程。一旦被唤醒，线程仍然会要求互斥锁。如果当前没有线程等待通知，则上面两种调用实际上成为一个空操作。如果参数*cond指向非法地址，则返回值EINVAL。 

下面是一个简单的例子，我们可以从程序的运行来了解条件变量的作用。

[cpp]  view plain copy
  1. #include   
  2. #include   
  3. #include   
  4.   
  5. pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;/*初始化互斥锁*/  
  6. pthread_cond_t cond = PTHREAD_COND_INITIALIZER;/*初始化条件变量*/  
  7.   
  8. void *thread1(void *);  
  9. void *thread2(void *);  
  10.   
  11. int i=1;  
  12. int main(void)  
  13. {  
  14.     pthread_t t_a;  
  15.     pthread_t t_b;  
  16.   
  17.     pthread_create(&t_a,NULL,thread2,(void *)NULL);/*创建进程t_a*/  
  18.     pthread_create(&t_b,NULL,thread1,(void *)NULL); /*创建进程t_b*/  
  19.     pthread_join(t_b, NULL);/*等待进程t_b结束*/  
  20.     pthread_mutex_destroy(&mutex);  
  21.     pthread_cond_destroy(&cond);  
  22.     exit(0);  
  23. }  
  24.   
  25. void *thread1(void *junk)  
  26. {  
  27.     for(i=1;i<=9;i++)   
  28.     {  
  29.         pthread_mutex_lock(&mutex);/*锁住互斥量*/  
  30.         if(i%3==0)  
  31.              pthread_cond_signal(&cond);/*条件改变，发送信号，通知t_b进程*/  
  32.         else          
  33.              printf("thead1:%d\n",i);  
  34.         pthread_mutex_unlock(&mutex);/*解锁互斥量*/  
  35.   
  36.       sleep(1);  
  37.    }    
  38. }  
  39.   
  40. void *thread2(void *junk)  
  41. {  
  42.     while(i<9)  
  43.     {  
  44.         pthread_mutex_lock(&mutex);  
  45.   
  46. if(i%3!=0)  
  47.             pthread_cond_wait(&cond,&mutex);/*等待*/  
  48.         printf("thread2:%d\n",i);  
  49.         pthread_mutex_unlock(&mutex);  
  50.   

你可能感兴趣的:(Linux多线程编程)

  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • linux sdl windows.h,Windows下的SDL安装 奔跑吧linux内核 linuxsdlwindows.h
    首先你要下载并安装SDL开发包。如果装在C盘下，路径为C:\SDL1.2.5如果在WINDOWS下。你可以按以下步骤：1.打开VC++，点击"Tools",Options2,点击directories选项3.选择"Includefiles"增加一个新的路径。"C:\SDL1.2.5\include"4，现在选择"Libaryfiles“增加"C:\SDL1.2.5\lib"现在你可以开始编写你的第
  • linux中sdl的使用教程,sdl使用入门 Melissa Corvinus linux中sdl的使用教程
    本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一
  • PHP环境搭建详细教程 好看资源平台 前端php
    PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
  • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器） 编程经验分享 开发工具服务器sshlinux
    目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
  • libyuv之linux编译 jaronho Linuxlinux运维服务器
    文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
  • ARM驱动学习之5 LEDS驱动 JT灬新一 嵌入式C底层arm开发学习单片机
    ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
  • 【华为OD技术面试真题精选 - 非技术题】 -HR面，综合面_华为od hr面 一个射手座的程序媛 程序员华为od面试职场和发展
    最后的话最近很多小伙伴找我要Linux学习资料，于是我翻箱倒柜，整理了一些优质资源，涵盖视频、电子书、PPT等共享给大家！资料预览给大家整理的视频资料：给大家整理的电子书资料：如果本文对你有帮助，欢迎点赞、收藏、转发给朋友，让我有持续创作的动力！网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以点击这里获
  • 简介Shell、zsh、bash zhaosuningsn Shellzshbashshelllinuxbash
    Shell是Linux和Unix的外壳，类似衣服，负责外界与Linux和Unix内核的交互联系。例如接收终端用户及各种应用程序的命令，把接收的命令翻译成内核能理解的语言，传递给内核，并把内核处理接收的命令的结果返回给外界，即Shell是外界和内核沟通的桥梁或大门。Linux和Unix提供了多种Shell，其中有种bash，当然还有其他好多种。Mac电脑中不但有bash，还有一个zsh，预装的，据说
  • Linux MariaDB使用OpenSSL安装SSL证书 Meta39 MySQLOracleMariaDBLinuxWindowsssllinuxmariadb
    进入到证书存放目录，批量删除.pem证书警告：确保已经进入到证书存放目录find.-typef-iname\*.pem-delete查看是否安装OpenSSLopensslversion没有则安装yuminstallopensslopenssl-devel开启SSL编辑/etc/my.cnf文件（没有的话就创建，但是要注意，在/etc/my.cnf.d/server.cnf配置了datadir的，
  • 【从浅识到熟知Linux】Linux发展史 Jammingpro 从浅学到熟知Linuxlinux运维服务器
    归属专栏：从浅学到熟知Linux个人主页：Jammingpro每日努力一点点，技术变化看得见文章前言：本篇文章记录Linux发展的历史，因在介绍Linux过程中涉及的其他操作系统及人物，本文对相关内容也有所介绍。文章目录Unix发展史Linux发展史开源Linux官网企业应用情况发行版本在学习Linux前，我们可能都会问Linux从哪里来？它是如何发展的。但在介绍Linux之前，需要先介绍一下Un
  • linux 发展史 种树的猴子 内核java操作系统linux大数据
    linux发展史说明此前对linux认识模糊一知半解，近期通过学习将自己对于linux的发展总结一下方便大家日后的学习。那Linux是目前一款非常火热的开源操作系统，可是linux是什么时候出现的，又是因为什么样的原因被开发出来的呢。以下将对linux的发展历程进行详细的讲解。目录一、Linux发展背景二、UINIX的诞生三、UNIX的重要分支-BSD的诞生四、Minix的诞生五、GNU与Free
  • Linux sh命令 fengyehongWorld Linuxlinux
    目录一.基本语法二.选项2.1-c字符串中读取内容，并执行2.1.1基本用法2.1.2获取当前目录下失效的超链接2.2-x每个命令执行之前，将其打印出来2.3结合Here文档使用一.基本语法⏹Linux和Unix系统中用于执行shell脚本或运行命令的命令。sh[选项][脚本文件][参数...]⏹选项-c：从字符串中读取内容，并执行。-x：在每个命令执行之前，将其打印出来。-s：从标准流中读取内容
  • Linux vi常用命令 fengyehongWorld Linuxlinux
    参考资料viコマンド（vimコマンド）リファレンス目录一.保存系命令二.删除系命令三.移动系命令四.复制粘贴系命令一.保存系命令⏹保存并退出:wq⏹强制保存并退出:wq!⏹退出(文件未编辑):q⏹强制退出(忽略已编辑内容):q!⏹另存为:w新文件名二.删除系命令⏹删除当前行dd⏹清空整个文档gg：移动到文档顶部dG：删除到最后一行ggdG三.移动系命令⏹移动到文档顶部gg⏹移动到文档底部#方式1G
  • Linux查看服务器日志 TPBoreas 运维linux运维
    一、tail这个是我最常用的一种查看方式用法如下：tail-n10test.log查询日志尾部最后10行的日志;tail-n+10test.log查询10行之后的所有日志;tail-fn10test.log循环实时查看最后1000行记录(最常用的)一般还会配合着grep用，(实时抓包)例如:tail-fn1000test.log|grep'关键字'（动态抓包）tail-fn1000test.log
  • 笋丁网页自动回复机器人V3.0.0免授权版源码 希希分享 软希网58soho_cn源码资源笋丁网页自动回复机器人
    笋丁网页机器人一款可设置自动回复，默认消息，调用自定义api接口的网页机器人。此程序后端语言使用Golang，内存占用最高不超过30MB，1H1G服务器流畅运行。仅支持Linux服务器部署，不支持虚拟主机，请悉知！使用自定义api功能需要有一定的建站基础。源码下载：https://download.csdn.net/download/m0_66047725/89754250更多资源下载：关注我。安
  • Linux CTF逆向入门 蚁景网络安全 linux运维CTF
    1.ELF格式我们先来看看ELF文件头，如果想详细了解，可以查看ELF的manpage文档。关于ELF更详细的说明：e_shoff：节头表的文件偏移量（字节）。如果文件没有节头表，则此成员值为零。sh_offset：表示了该section（节）离开文件头部位置的距离+-------------------+|ELFheader|---++--------->+-------------------
  • NPM私库搭建-verdaccio（Linux） Beam007 npmlinux前端
    1、安装nodelinux服务器安装nodea)、官网下载所需的node版本https://nodejs.org/dist/v14.21.0/b)、解压安装包若下载的是xxx.tar.xz文件，解压命令为tar-xvfxxx.tar.xzc)、修改环境变量修改：/etc/profile文件#SETPATHFORNODEJSexportNODE_HOME=NODEJS解压安装的路径exportPAT
  • C++常见知识掌握 nfgo c++开发语言
    1.Linux软件开发、调试与维护内核与系统结构Linux内核是操作系统的核心，负责管理硬件资源，提供系统服务，它是系统软件与硬件之间的桥梁。主要组成部分包括：进程管理：内核通过调度器分配CPU时间给各个进程，实现进程的创建、调度、终止等操作。使用进程描述符（task_struct）来存储进程信息，包括状态（就绪、运行、阻塞等）、优先级、内存映射等。内存管理：包括物理内存和虚拟内存管理。通过页表映
  • linux脚本sed替换变量,sed 命令中替换值为shell变量 诺坎普之约 linux脚本sed替换变量
    文章目录sed命令中替换值为shell变量替换基本语法sed中替换使用shell变量总结参考文档sed命令中替换值为shell变量替换基本语法大家都是sed有很多用法，最多就应该是替换一些值了。让我们先回忆sed的替换语法。在sed进行替换的时候sed-i's/old/new/g'1.txtecho"hellooldfrank"|sed's/old/new/g'结果如下：hellonewfrank
  • RK3229_Android9.0_Box 4G模块EC200A调试 suifen_ 网络
    0、kernel修改这部分完全可以参考Linux的移植：RK3588EC200A-CN【4G模块】调试_rkec200a-cn-CSDN博客1、修改device/rockchip/rk322xdiff--gita/device.mkb/device.mkindexec6bfaa..e7c32d1100755---a/device.mk+++b/device.mk@@-105,6+105,8@@en
  • linux 安装Sublime Text 3 hhyiyuanyu Python学习linuxsublimetext
    方法/步骤打开官网http://www.sublimetext.com/3，选择64位进行下载执行命令wgethttps://download.sublimetext.com/sublime_text_3_build_3126_x64.tar.bz2进行下载3、下载完成进行解压,执行tar-xvvfsublime_text_3_build_3126_x64.tar.bz解压4、解压完成以后，移动到
  • KVM虚拟机源代码分析【转】 xidianjiapei001 #虚拟化技术
    1.KVM结构及工作原理1.1KVM结构KVM基本结构有两部分组成。一个是KVMDriver，已经成为Linux内核的一个模块。负责虚拟机的创建，虚拟内存的分配，虚拟CPU寄存器的读写以及虚拟CPU的运行等。另外一个是稍微修改过的Qemu，用于模拟PC硬件的用户空间组件，提供I/O设备模型以及访问外设的途径。KVM基本结构如图1所示。其中KVM加入到标准的Linux内核中，被组织成Linux中标准
  • 史上最全git命令,git回滚,git命令大全 騒周 其他git
    git命令大全一、Git整体理解二、由暂存区本地仓库三、由本地仓->远程仓库四、冲突处理五、Git分支操作六、bug的分支七、feature分支八、暂存的使用九、远程仓的操作十、标签的使用十一、Git配置全局信息十二、Linux的一些简单操作和一些符号的解释十三、符号解释十四、显示安装详细信息十五、gitconfig十六、Gitclone十七、Gitinit十八、gitstatus十九、gitre
  • 【显示 后台运行 & 的命令】 晨春计 debuglinux服务器运维
    目录背景步骤详解示例背景当你在Linuxshell中使用&符号将一个命令放到后台运行时，你可以使用jobs命令来查看这些后台进程的状态。但是，jobs命令并不会直接显示进程的PID（进程ID）。它会显示一个作业列表，其中包括每个作业的状态和一个作业标识符（通常是百分号%后面跟着一个数字），但不会直接显示PID。获取后台进程的PID步骤：1、使用jobs命令查看后台作业。2、使用ps命令配合grep
  • Android shell 常用 debug 命令 晨春计 Audiodebugandroidlinux
    目录1、查看版本2、am命令3、pm命令4、dumpsys命令5、sed命令6、log定位查看APK进程号7、log定位使用场景1、查看版本1.1、Android串口终端执行getpropro.build.version.release#获取Android版本uname-a#查看linux内核版本信息uname-r#单独查看内核版本1.2、linux服务器执行lsb_release-a#查看Lin
  • 【nginx】ngx_http_proxy_connect_module 正向代理 等风来不如迎风去 网络服务入门与实战nginxhttp运维
    50.65无法访问服务器，(403错误)50.196可以访问服务器。那么，配置65通过196访问。需要一个nginx作为代理【nginx】搭配okhttp配置反向代理发送原生的nginx是不支持okhttp的CONNECT请求的。大神竟然给出了一个java工程GINX编译ngx_http_proxy_connect_module及做正向代理是linux构建的。是windows构建的：编译Windo
  • linux下好用的任务管理器htop WittXie Linuxlinux服务器运维
    给大家推荐个好用的任务管理器htop，简直好用的不得了。完虐top。不解释了，看文章！！！在Linux系统中，top命令用来显示系统中正在运行的进程的实时状态，它显示了一些非常有用的信息，比如CPU利用情况、内存消耗情况，以及每个进程情况等。但是，你知道吗？还有另外一个命令行工具'htop'，它与传统的top命令功能一样，但它有更加强大的功能及能显示更多的信息。这篇文章，我们会用实例来讨论这个'h
  • Linux下使用U盘 WittXie Linuxlinux运维服务器
    第一步：插入U盘，如果能够识别出U盘，则会打印出一些信息；第二步：查看U盘系统分配给U盘的设备名；输入如下命令进行查看：fdisk-l/dev/sda如果打印出如下信息：Disk/dev/sda:4233MB,4233101312bytes165heads,34sectors/track,1473cylindersUnits=cylindersof5610*512=2872320bytesDevi
  • java线程的无限循环和退出 3213213333332132 java
    最近想写一个游戏，然后碰到有关线程的问题，网上查了好多资料都没满足。 突然想起了前段时间看的有关线程的视频，于是信手拈来写了一个线程的代码片段。 希望帮助刚学java线程的童鞋 package thread; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date
  • tomcat 容器 BlueSkator tomcatWebservlet
    Tomcat的组成部分 1、server A Server element represents the entire Catalina servlet container. (Singleton) 2、service service包括多个connector以及一个engine，其职责为处理由connector获得的客户请求。   3、connector 一个connector
  • php递归,静态变量,匿名函数使用 dcj3sjt126com PHP递归函数匿名函数静态变量引用传参
      <!doctype html> <html lang="en"> <head> <meta charset="utf-8"> <title>Current To-Do List</title> </head> <body>
  • 属性颜色字体变化 周华华 JavaScript
    function changSize(className){ var diva=byId("fot") diva.className=className; } </script> <style type="text/css"> .max{ background: #900; color:#039;
  • 将properties内容放置到map中 g21121 properties
    代码比较简单： private static Map<Object, Object> map; private static Properties p; static { //读取properties文件 InputStream is = XXX.class.getClassLoader().getResourceAsStream("xxx.properti
  • [简单]拼接字符串 53873039oycg 字符串
             工作中遇到需要从Map里面取值拼接字符串的情况，自己写了个，不是很好，欢迎提出更优雅的写法，代码如下：           import java.util.HashMap; import java.uti
  • Struts2学习 云端月影
    最近开始关注struts2的新特性，从这个版本开始，Struts开始使用convention-plugin代替codebehind-plugin来实现struts的零配置。 配置文件精简了，的确是简便了开发过程，但是，我们熟悉的配置突然disappear了，真是一下很不适应。跟着潮流走吧，看看该怎样来搞定convention-plugin。 使用Convention插件，你需要将其JAR文件放
  • Java新手入门的30个基本概念二 aijuans java新手java 入门
    基本概念:　　1.OOP中唯一关系的是对象的接口是什么,就像计算机的销售商她不管电源内部结构是怎样的,他只关系能否给你提供电就行了,也就是只要知道can or not而不是how and why.所有的程序是由一定的属性和行为对象组成的,不同的对象的访问通过函数调用来完成,对象间所有的交流都是通过方法调用,通过对封装对象数据,很大限度上提高复用率。　　2.OOP中最重要的思想是类,类是模板是蓝图,
  • jedis 简单使用 antlove javarediscachecommandjedis
    jedis.RedisOperationCollection.java package jedis; import org.apache.log4j.Logger; import redis.clients.jedis.Jedis; import java.util.List; import java.util.Map; import java.util.Set; pub
  • PL/SQL的函数和包体的基础 百合不是茶 PL/SQL编程函数包体显示包的具体数据包
    由于明天举要上课,所以刚刚将代码敲了一遍PL/SQL的函数和包体的实现(单例模式过几天好好的总结下再发出来);以便明天能更好的学习PL/SQL的循环,今天太累了,所以早点睡觉,明天继续PL/SQL总有一天我会将你永远的记载在心里,,,   函数; 函数:PL/SQL中的函数相当于java中的方法;函数有返回值 定义函数的 --输入姓名找到该姓名的年薪 create or re
  • Mockito(二)--实例篇 bijian1013 持续集成mockito单元测试
            学习了基本知识后，就可以实战了，Mockito的实际使用还是比较麻烦的。因为在实际使用中，最常遇到的就是需要模拟第三方类库的行为。         比如现在有一个类FTPFileTransfer，实现了向FTP传输文件的功能。这个类中使用了a
  • 精通Oracle10编程SQL(7)编写控制结构 bijian1013 oracle数据库plsql
    /* *编写控制结构 */ --条件分支语句 --简单条件判断 DECLARE v_sal NUMBER(6,2); BEGIN select sal into v_sal from emp where lower(ename)=lower('&name'); if v_sal<2000 then update emp set
  • 【Log4j二】Log4j属性文件配置详解 bit1129 log4j
    如下是一个log4j.properties的配置   log4j.rootCategory=INFO, stdout , R log4j.appender.stdout=org.apache.log4j.ConsoleAppender log4j.appender.stdout.layout=org.apache.log4j.PatternLayout log4j.appe
  • java集合排序笔记 白糖_ java
    public class CollectionDemo implements Serializable,Comparable<CollectionDemo>{ private static final long serialVersionUID = -2958090810811192128L; private int id; private String nam
  • java导致linux负载过高的定位方法 ronin47
    定位java进程ID 可以使用top或ps -ef |grep java ![图片描述][1] 根据进程ID找到最消耗资源的java pid 比如第一步找到的进程ID为5431 执行 top -p 5431 -H ![图片描述][2] 打印java栈信息 $ jstack -l 5431 > 5431.log 在栈信息中定位具体问题 将消耗资源的Java PID转
  • 给定能随机生成整数1到5的函数，写出能随机生成整数1到7的函数 bylijinnan 函数
    import java.util.ArrayList; import java.util.List; import java.util.Random; public class RandNFromRand5 { /** 题目：给定能随机生成整数1到5的函数，写出能随机生成整数1到7的函数。 解法1： f(k) = (x0-1)*5^0+(x1-
  • PL/SQL Developer保存布局 Kai_Ge
          近日由于项目需要，数据库从DB2迁移到ORCAL，因此数据库连接客户端选择了PL/SQL Developer。由于软件运用不熟悉，造成了很多麻烦，最主要的就是进入后，左边列表有很多选项，自己删除了一些选项卡，布局很满意了，下次进入后又恢复了以前的布局，很是苦恼。在众多PL/SQL Developer使用技巧中找到如下这段：   &n
  • [未来战士计划]超能查派[剧透,慎入] comsci 计划
           非常好看,超能查派,这部电影......为我们这些热爱人工智能的工程技术人员提供一些参考意见和思想........        虽然电影里面的人物形象不是非常的可爱....但是非常的贴近现实生活....    &nbs
  • Google Map API V2 dai_lm google map
    以后如果要开发包含google map的程序就更麻烦咯 http://www.cnblogs.com/mengdd/archive/2013/01/01/2841390.html 找到篇不错的文章，大家可以参考一下 http://blog.sina.com.cn/s/blog_c2839d410101jahv.html 1. 创建Android工程 由于v2的key需要G
  • java数据计算层的几种解决方法2 datamachine javasql集算器
    2、SQL     SQL/SP/JDBC在这里属于一类，这是老牌的数据计算层，性能和灵活性是它的优势。但随着新情况的不断出现，单纯用SQL已经难以满足需求，比如： JAVA开发规模的扩大，数据量的剧增，复杂计算问题的涌现。虽然SQL得高分的指标不多，但都是权重最高的。     成熟度：5星。最成熟的。   
  • Linux下Telnet的安装与运行 dcj3sjt126com linuxtelnet
    Linux下Telnet的安装与运行   linux默认是使用SSH服务的 而不安装telnet服务  如果要使用telnet 就必须先安装相应的软件包  即使安装了软件包 默认的设置telnet 服务也是不运行的 需要手工进行设置 如果是redhat9，则在第三张光盘中找到 telnet-server-0.17-25.i386.rpm
  • PHP中钩子函数的实现与认识 dcj3sjt126com PHP
    假如有这么一段程序： function fun(){ fun1(); fun2(); }   首先程序执行完fun1()之后执行fun2()然后fun()结束。   但是，假如我们想对函数做一些变化。比如说，fun是一个解析函数，我们希望后期可以提供丰富的解析函数，而究竟用哪个函数解析，我们希望在配置文件中配置。这个时候就可以发挥钩子的力量了。   我们可以在fu
  • EOS中的WorkSpace密码修改 蕃薯耀 修改WorkSpace密码
    EOS中BPS的WorkSpace密码修改 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 201
  • SpringMVC4零配置--SpringSecurity相关配置【SpringSecurityConfig】 hanqunfeng SpringSecurity
     SpringSecurity的配置相对来说有些复杂，如果是完整的bean配置，则需要配置大量的bean，所以xml配置时使用了命名空间来简化配置，同样，spring为我们提供了一个抽象类WebSecurityConfigurerAdapter和一个注解@EnableWebMvcSecurity，达到同样减少bean配置的目的，如下：   applicationContex
  • ie 9 kendo ui中ajax跨域的问题 jackyrong AJAX跨域
    这两天遇到个问题，kendo ui的datagrid，根据json去读取数据，然后前端通过kendo ui的datagrid去渲染，但很奇怪的是，在ie 10,ie 11,chrome,firefox等浏览器中，同样的程序， 浏览起来是没问题的，但把应用放到公网上的一台服务器， 却发现如下情况： 1） ie 9下，不能出现任何数据，但用IE 9浏览器浏览本机的应用，却没任何问题
  • 不要让别人笑你不能成为程序员 lampcy 编程程序员
    在经历六个月的编程集训之后，我刚刚完成了我的第一次一对一的编码评估。但是事情并没有如我所想的那般顺利。 说实话，我感觉我的脑细胞像被轰炸过一样。 手慢慢地离开键盘，心里很压抑。不禁默默祈祷：一切都会进展顺利的，对吧？至少有些地方我的回答应该是没有遗漏的，是不是？ 难道我选择编程真的是一个巨大的错误吗——我真的永远也成不了程序员吗？ 我需要一点点安慰。在自我怀疑，不安全感和脆弱等等像龙卷风一
  • 马皇后的贤德 nannan408
       马皇后不怕朱元璋的坏脾气，并敢理直气壮地吹耳边风。众所周知，朱元璋不喜欢女人干政，他认为“后妃虽母仪天下，然不可使干政事”，因为“宠之太过，则骄恣犯分，上下失序”，因此还特地命人纂述《女诫》，以示警诫。但马皇后是个例外。 　　有一次，马皇后问朱元璋道：“如今天下老百姓安居乐业了吗？”朱元璋不高兴地回答：“这不是你应该问的。”马皇后振振有词地回敬道：“陛下是天下之父，
  • 选择某个属性值最大的那条记录（不仅仅包含指定属性，而是想要什么属性都可以） Rainbow702 sqlgroup by最大值max最大的那条记录
    好久好久不写SQL了，技能退化严重啊！！！   直入主题： 比如我有一张表，file_info， 它有两个属性（但实际不只，我这里只是作说明用）： file_code, file_version 同一个code可能对应多个version 现在，我想针对每一个code，取得它相关的记录中，version 值 最大的那条记录， SQL如下： select *
  • VBScript脚本语言 tntxia VBScript
      VBScript 是基于VB的脚本语言。主要用于Asp和Excel的编程。   VB家族语言简介   Visual Basic 6.0           源于BASIC语言。           由微软公司开发的包含协助开发环境的事
  • java中枚举类型的使用 xiao1zhao2 javaenum枚举1.5新特性
    枚举类型是j2se在1.5引入的新的类型,通过关键字enum来定义,常用来存储一些常量.   1.定义一个简单的枚举类型 public enum Sex { MAN, WOMAN }   枚举类型本质是类,编译此段代码会生成.class文件.通过Sex.MAN来访问Sex中的成员,其返回值是Sex类型.   2.常用方法 静态的values()方
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他