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多线程编程)

  • 【Vim Masterclass 笔记22】S09L40 + L41：同步练习11：Vim 的配置与 vimrc 文件的相关操作（含点评课内容） 安冬的码畜日常 VimMasterclassvim笔记vim配置vim同步练习vimoptionsvimoption-list
    文章目录S09L40Exercise11-VimSettingsandtheVimrcFile1训练目标2操作指令2.1.打开vimrc-sample文件2.2.尝试各种选项与设置2.3.将更改内容保存到vimrc-sample文件2.4.将文件vimrc-sample的内容复制到寄存器2.5.创建专属vimrc文件2.6.对于Mac、Linux或Unix用户2.7.对于Windows用户2.8.
  • Linux环境下删除Golang HoUnix golang
    在Linux操作系统中，如果你决定删除Golang编程语言及其相关组件，需要执行一系列步骤。本文将为你提供详细的指导，并附上相应的源代码。卸载Golang首先，需要卸载已安装的Golang。在终端中执行以下命令：sudorm-rf/usr/local/go这将删除Golang的安装目录。移除环境变量下一步是从系统环境变量中移除与Golang相关的路径。打开终端，编辑~/.profile文件（或者是
  • ubuntu安装、升级、卸载go语言 aspirinnil linuxgolanglinuxubuntugolang
    ubuntu安装、升级、卸载golang一、安装go二、升级go1.卸载go2.重新安装新版本的golangubuntu安装、升级、卸载golang一、安装go下载go方法一：官网下载：https://golang.org/dl/方法二：打开ubuntu输入：wgethttps://dl.google.com/go/go1.15.3.linux-amd64.tar.gz
  • Centos常用命令，按功能分类，用户和权限管理等 ZHOUPUYU 资料分享centoslinux运维
    CentOS是一个基于RedHatEnterpriseLinux(RHEL)的免费开源操作系统，稳定可靠，广泛应用于服务器环境。以下是一份CentOS使用教程及常用命令的总结，帮助你快速上手。由于篇幅限制，这里只涵盖常用命令和基本操作，更深入的学习需要参考CentOS官方文档和相关书籍。一、安装CentOSCentOS的安装过程与其他Linux发行版类似，通常包含以下步骤：下载镜像:从CentOS
  • Linux(Centos 7.6)命令详解：dos2unix 豆是浪个 linux运维服务器
    1.命令作用将Windows格式文件件转换为Unix、Linux格式的文件(也可以转换成其他格式的)2.命令语法Usage:dos2unix[options][file...][-ninfileoutfile...]3.参数详解options:-c,--convmode，转换方式，支持ascii,7bit,iso,mac,默认为ascii-f,--force，强制转换二进制文件-k,--keepd
  • deepin-grep详解：文本搜索的强大工具 deepin
    在Linux系统中，grep命令是一个极其强大的文本搜索工具，广泛应用于文本处理、日志分析和数据筛选等场景。它的全称是“GlobalsearchREgularexpressionandPrintouttheline”，即全局搜索正则表达式并打印匹配的行。本文将详细介绍grep命令的基本用法、常用选项以及正则表达式的使用技巧。1.grep命令的基本功能grep命令的主要作用是从文本文件或管道数据流中
  • Debian常用命令详解 -龙川- 介绍学习笔记debian
    Debian是一个广泛使用的Linux发行版，以其稳定性和包管理系统的丰富性著称。对于新手和经验丰富的系统管理员来说，掌握常用的Debian命令至关重要。这篇文章将详细介绍Debian系统中常用的命令，包括文件和目录操作、软件包管理、用户和权限管理、系统监控和网络管理等多个方面。一、文件和目录操作1.ls-列出目录内容ls命令用于列出目录中的文件和子目录。ls常用选项：-l：以长格式显示详细信息。
  • deepin分享-Linux 磁盘分区和挂载指南 deepin
    在Linux系统中(如deepin等)，磁盘分区和挂载是系统管理的重要组成部分。了解如何进行分区、格式化和挂载操作，可以帮助你更好地管理磁盘空间，优化系统性能，并确保数据的安全存储。本文将详细介绍Linux磁盘分区和挂载的基本概念、操作步骤以及一些实用的命令。1.基本概念Linux系统采用了一种独特的文件系统结构，无论系统中有多少个分区，它们最终都归属于一个根目录（/），形成一个统一的文件系统。每
  • MySQL--mysqld、mysql_safe、mysql.server、mysqladmin几种启动和停止服务使用说明 m0_74823683 面试学习路线阿里巴巴mysqladbandroid
    您好，我是贾斯汀，欢迎进来学习的小伙伴~【学习背景】本文对Linux下启动和停止mysql服务最常用的几种方式进行讲解：（1）mysqld（2）mysqld_safe（3）mysql.server（4）mysqladmin关于这几种文件和命令对mysql服务的启动和停止的使用，本文会分别进行介绍，还有一些关键的事项，比如生产环境对于MySQL服务的启动和停止是非常谨慎的一件事，不是每一种方式都适合
  • Linux操作系统配置Mysql环境变量 MySQL冲冲冲 linuxmysql运维
    安装好了mysql之后，在linux服务器上使用mysql-uroot-p命令登录mysql数据库，出现：-bash:mysqlcommandnotfound；再使用mysql--V报同样的问题。需要配置mysql环境变量，过程如下：1.找到mysql安装路径：先执行：find/|grepbin/mysql出现一些安装路径后，用安装路径-V，如果能输出mysql版本，那么该路径就是mysql的安装
  • python中graphviz 参数_python graphviz的使用(画图工具) weixin_39900608 python中graphviz参数
    一、graphviz安装及配置graphviz实际上是一个绘图工具，可以根据dot脚本画出树形图等。1、windows安装配置环境变量：把bin文件夹的路径加入到环境变量path里安装python的graphviz模块：pipinstallgraphviz2、linuxcentos7安装yum下载graphviz软件：yum-yinstallgraphviz安装python的graphviz模块：
  • C++ 线程安全之互斥锁 __雨夜星辰__ c++开发语言学习笔记visualstudio多线程
    目录线程安全1.原子性2.可见性3.顺序性互斥锁1.mutex类2.timed_mutex类3.recursive_mutex类4.lock_guard类线程安全线程安全是多线程编程是的计算机程序代码中的一个概念。在拥有共享数据的多条线程并行执行的程序中，线程安全的代码会通过同步机制保证各个线程都可以正常且准确的执行，不会出现数据污染等意外情况。上述是百度百科给出的一个概念解释。换言之，线程安全就
  • 关于Linux（Centos7）的静态IP地址配置操作 为已己任 Linux配置篇linuxcentos网络
    Centos7-静态IP地址设置1、内容概述2、环境介绍3、操作步骤3.1、编辑网口配置文件3.2、进入网口配置文件3.3、修改网口配置文件内容3.3.1、静态IP设置3.3.2、自动激活网络3.4、添加配置内容3.4.1、添加IP信息3.4.2、添加网关信息3.4.3、添加掩码信息3.4.4、添加DNS地址3.5、操作结果内容4、重启网络5、检查修改情况6、检查网络情况7、总结1、内容概述关于在
  • Linux基础3 2301_78560796 linux运维服务器
    VIM编辑器1.命令模式gg：移动光标到第一行G：移动光标到最后一行$：移动光标到当前行的行尾（最后一行），一般可以使用shift+$o：移动光标到当前行的行首（第一列）x：删除当前光标所在处的一个字符nx：删除当前光标所在处以及后面共n个字符X：删除当前光标的左边一个字符D：删除当前光标至行尾：dd：删除当前光标所在行ndd：删除当前光标所在后面共n行，注意n是数字键dG：删除当前光标所在行至文
  • xargs命令工具 难以触及的高度 linux服务器前端
    `xargs`是一个强大的Unix/Linux命令行工具，用于构建和执行命令行。它可以从标准输入读取数据，并将其作为参数传递给其他命令。`xargs`提供了多个选项来控制其行为，以下是对你提到的几个选项的详细解释：1.`-nmax-args`含义：指定每次调用命令时传递的最大参数数量（即每个命令行中包含的参数个数）。示例：假设你有一个文件列表，并希望每次只处理一个文件，可以使用`-n1`。find
  • C语言实现静态IP地址，子网掩码，网关的设置 zhengyuquan android网络静态IP地址子网掩码网关的设置
    以下内容均搜集于网络。一、linux下C语言实现静态IP地址，子网掩码，网关的设置#include#include#include#include#include#include#include#includeintset_ifaddr(char*ifname,char*Ipaddr,char*mask,char*gateway){intfd;intrc;structifreqifr;struct
  • 5分钟搞懂 Golang 堆内存 程序员
    本文主要解释了堆内存的概念，介绍了Linux堆内存的工作原理，以及Golang如何管理堆内存。原文:UnderstandingHeapMemoryinLinuxwithGo你想过为什么堆内存被称为"堆"吗？想象一下杂乱堆放的对象，与此类似，在计算机中，堆内存是动态分配和释放内存的空间，通常会导致内存块的无序排列。我们可以利用这种相似性和无序排列来理解堆内存，并探讨堆内存的概念及其在计算中的意义。什
  • 搭建个人AI知识库：RAG与本地模型实践指南 ai开发知识库
    引言你是否想过拥有一个私人订制的AI助手，能够随时为你提供最个性化的信息？本文将带你一步步搭建一个基于本地模型和RAG技术的个人知识库。搭建本地模型环境os:archlinux内存:32gcpu:6核12线程python:3.12.7docker27.3.1+docker-compose向量库:milvus2.4.13+attu2.4(客户端)ollamapacman-Sollamasystemc
  • python中系统找不到指定文件怎么办,Python“系统找不到指定的文件” 许早早
    我正在尝试编写一个OpenDyslexic字体的安装程序。我已经在https://github.com/kirbyfan64/OpenDyslexic-Installer上有一个Linux版本，但是Windows版本(显然)目前还不太好用。这是UAC问题吗？我想不出别的办法了。有两个奇怪的部分：程序正在通过else子句和filecmp找到了第一个文件。我有一种感觉，执行else是因为与filecm
  • linux安装mysql5.7 万猿丛中最秃的帅哥 linuxmysqllinuxmysql数据库
    1、安装boost库boost_1_59_0连接：链接：https://pan.baidu.com/s/1sNY1niWTFjrLccPbMmcp5w提取码：pdj9在根目录的opt目录创建临时文件储存目录mkdir-p/opt/package进入临时目录cd/opt/package上传压缩包到服务器解压tar–xvzfboost_1_59_0.tar.gz进入boost目录cdboost_1_5
  • docker离线安装及部署各类中间件（x86系统架构） m0_67403143 面试学习路线阿里巴巴docker中间件系统架构
    前言：此文主要针对需要在x86内网服务器搭建系统的情况一、docker离线安装1、下载docker镜像https://download.docker.com/linux/static/stable/x86_64/版本：docker-23.0.6.tgz2、将docker-23.0.6.tgz文件上传到服务器上面，这里放在了/home下3、创建docker.service文件#进入/etc/syst
  • linux下jax-GPU安装 liu_zhaoda 深度学习-jaxlinuxpythonpytorch
    安装命令详细内容可查看jax官方文档在已有cuda的情况下，先使用命令1，再使用命令2，即可完成安装命令1：linux下jax安装命令pipinstalljax[cpu]==0.3.25-fhttps://storage.googleapis.com/jax-releases/jax_releases.html将黑体部分，替换成想要的版本即可命令2：linux下jaxlibcuda安装命令pipi
  • Windows和Linux两个操作系统的优势 服务器
    Windows和Linux是两种主流的操作系统，它们各自具有显著的优势，适用于不同的场景和用户群体。Windows系统的优势广泛的应用兼容性：Windows系统几乎可以运行所有的软件和游戏，满足用户的各种需求。无论是办公软件、设计软件还是游戏软件，Windows平台都有丰富的选择。直观的用户界面：Windows系统的用户界面设计直观，易于上手。它提供了丰富的图形界面和多媒体功能，使得用户可以通过点
  • VSCODE SSH远程连接报错或无法联网安装.vscode-server w_melody IDE篇vscodesshide
    问题问题1:"无法与SSH建立连接：XHRFailed"解决篇在有网得情况下ssh连接总是提示如下：问题2：远程linux环境无法联网，不能在线下载解决办法分析：根据报错显示，正在下载“VSCodeserverlocally”时出错，有可能是网络的原因导致服务器端下载出错，解决思路就是手动下载.vscode-server需要得包到服务器执行步骤：1）打开宿主机vscode->帮助->关于选中复制（
  • opencv相机特性 记录 faris_5bing 默认opencv音视频人工智能
    参考文档VideoCaptureAPIscv2.VideoCapture(0,cv2.VideoCaptureProperties)常见VideoCaptureProperties名称备注（含义）cv2.CAP_ANYautodetectcv2.CAP_VFWvideoforwindowscv2.CAP_V4L(cv2.CAP_V4L2)videoforlinuxcv2.CAP_DSHOWdire
  • linux中and运算符文件重定向,linux 重定向问题详解 上世是朵花
    Linux重定向是指修改原来默认的一些东西，对原来系统命令的默认执行方式进行改变，比如说简单的我不想看到在显示器的输出而是希望输出到某一文件中就可以通过Linux重定向来进行这项工作。Linux默认输入是键盘，输出是显示器。你可以用重定向来改变这些设置。比如用wc命令的时候本来是要手动输入一篇文字来计算字符数的，用了重定向后可以直接把一个已经写好的文件用‘STDIN0键盘输入STDOUT1输出信息
  • linux标准输出重定向到文件夹,linux输入输出重定向使用详解 佘炤灼
    1.输出重定向：默认条件下，标准输出和错误输出都是终端，可以把标准输出和错误内容进行重定向：[~]#echo"hello\!"hello\![~]#echo"hello!"-bash:!":eventnotfound"把标准输出重定向到文件[~]#echo"hello">test.sh[~]#cattest.shhello'>'输出方式默认等价'1>'[~]#echo"hello"1>test.s
  • K8S中Pod控制器之CronJob(CJ)控制器 元气满满的热码式 kubernetes容器云原生
    CronJob控制器是Kubernetes中用于周期性执行任务的一种控制器，它基于Job控制器来创建和管理作业。以下是CronJob的一些关键特点：周期性调度：CronJob允许您定义一个基于时间的调度，类似于Linux的cron工具，来周期性地执行任务。时间点触发：CronJob根据指定的时间表（cron表达式）触发，可以精确到分钟。一次性或重复执行：尽管CronJob主要用于重复性任务，但它也
  • stop调度类 liqb365 Linuxlinux
    摘自笔者原创的《Linux原理》草稿相关段落。本文基于5.15.133版本讨论。2.4.1stop2.4.1.1stop简介众所周知，Linux内核包含五个调度类。它们分别是stop,deadline,RT,CFS和Idle。每次调度，其调度的顺序按照排序先后进行。所以，stop调度类拥有每次调度的最高优先权。在stop机制中，可以借用经济学中消费者和生产者的概念来比喻该机制运行中非常重要的两部分
  • Kali Linux最新版本下无法直接pip安装？教你四招完美解决‘externally-managed-environment’报错！ vortex5 教程Kali笔记pipKali渗透经验分享
    内容预览≧∀≦ゞKaliLinux中解决externally-managed-environment错误的四种方法引言解决方案1：从系统存储库安装Python包解决方案2：使用虚拟环境解决方案3：使用pipx安装（推荐）解决方案4：强制安装（不推荐）总结KaliLinux中解决externally-managed-environment错误的四种方法引言在KaliLinux的最新版本中，很多用户尝
  • 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其他