2014-07-28 16:42:23 sam1437 阅读数 307
  • linux线程全解-linux应用编程和网络编程第7部分

    本课程讲解linux中线程,首先使用多进程解决上个课程中提出的并发式读取按键和鼠标的任务,然后引出多线程并讲解多线程的优势,后详细讲了多线程的同步技术。学习本课程的目的是学会在linux应用编程中使用多线程技术。

    5133 人正在学习 去看看 朱有鹏
一、互斥锁

尽管在Posix Thread中同样可以使用IPC的信号量机制来实现互斥锁mutex功能,但显然semphore的功能过于强大了,在Posix Thread中定义了另外一套专门用于线程同步的mutex函数。

1. 创建和销毁

   有两种方法创建互斥锁,静态方式和动态方式。

   POSIX定义了一个宏PTHREAD_MUTEX_INITIALIZER来静态初始化互斥锁,方法如下: pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER; 在LinuxThreads实现中,pthread_mutex_t是一个结构,而PTHREAD_MUTEX_INITIALIZER则是一个结构常量。

   动态方式是采用pthread_mutex_init()函数来初始化互斥锁,API定义如下: int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr) 其中mutexattr用于指定互斥锁属性(见下),如果为NULL则使用缺省属性。

   pthread_mutex_destroy()用于注销一个互斥锁,API定义如下: int pthread_mutex_destroy(pthread_mutex_t *mutex) 销毁一个互斥锁即意味着释放它所占用的资源,且要求锁当前处于开放状态。由于在Linux中,互斥锁并不占用任何资源,因此LinuxThreads中的pthread_mutex_destroy()除了检查锁状态以外(锁定状态则返回EBUSY)没有其他动作。

2. 互斥锁属性

   互斥锁的属性在创建锁的时候指定,在LinuxThreads实现中仅有一个锁类型属性,不同的锁类型在试图对一个已经被锁定的互斥锁加锁时表现不同。当前(glibc2.2.3,linuxthreads0.9)有四个值可供选择:

   PTHREAD_MUTEX_TIMED_NP,这是缺省值,也就是普通锁。当一个线程加锁以后,其余请求锁的线程将形成一个等待队列,并在解锁后按优先级获得锁。这种锁策略保证了资源分配的公平性。
PTHREAD_MUTEX_RECURSIVE_NP,嵌套锁,允许同一个线程对同一个锁成功获得多次,并通过多次unlock解锁。如果是不同线程请求,则在加锁线程解锁时重新竞争。
   PTHREAD_MUTEX_ERRORCHECK_NP,检错锁,如果同一个线程请求同一个锁,则返回EDEADLK,否则与PTHREAD_MUTEX_TIMED_NP类型动作相同。这样就保证当不允许多次加锁时不会出现最简单情况下的死锁。
PTHREAD_MUTEX_ADAPTIVE_NP,适应锁,动作最简单的锁类型,仅等待解锁后重新竞争。


3. 锁操作

   锁操作主要包括加锁pthread_mutex_lock()、解锁pthread_mutex_unlock()和测试加锁pthread_mutex_trylock()三个,不论哪种类型的锁,都不可能被两个不同的线程同时得到,而必须等待解锁。对于普通锁和适应锁类型,解锁者可以是同进程内任何线程;而检错锁则必须由加锁者解锁才有效,否则返回EPERM;对于嵌套锁,文档和实现要求必须由加锁者解锁,但实验结果表明并没有这种限制,这个不同目前还没有得到解释。在同一进程中的线程,如果加锁后没有解锁,则任何其他线程都无法再获得锁。

int pthread_mutex_lock(pthread_mutex_t *mutex)
int pthread_mutex_unlock(pthread_mutex_t *mutex)
int pthread_mutex_trylock(pthread_mutex_t *mutex)

pthread_mutex_trylock()语义与pthread_mutex_lock()类似,不同的是在锁已经被占据时返回EBUSY而不是挂起等待。

4. 其他

   POSIX线程锁机制的Linux实现都不是取消点,因此,延迟取消类型的线程不会因收到取消信号而离开加锁等待。值得注意的是,如果线程在加锁后解锁前被取消,锁将永远保持锁定状态,因此如果在关键区段内有取消点存在,或者设置了异步取消类型,则必须在退出回调函数中解锁。

   这个锁机制同时也不是异步信号安全的,也就是说,不应该在信号处理过程中使用互斥锁,否则容易造成死锁。


 

二、条件变量

   条件变量是利用线程间共享的全局变量进行同步的一种机制,主要包括两个动作:一个线程等待"条件变量的条件成立"而挂起;另一个线程使"条件成立"(给出条件成立信号)。为了防止竞争,条件变量的使用总是和一个互斥锁结合在一起。

1. 创建和注销

条件变量和互斥锁一样,都有静态动态两种创建方式,静态方式使用PTHREAD_COND_INITIALIZER常量,如下:
pthread_cond_t cond=PTHREAD_COND_INITIALIZER

动态方式调用pthread_cond_init()函数,API定义如下:
int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr)

尽管POSIX标准中为条件变量定义了属性,但在LinuxThreads中没有实现,因此cond_attr值通常为NULL,且被忽略。

   注销一个条件变量需要调用pthread_cond_destroy(),只有在没有线程在该条件变量上等待的时候才能注销这个条件变量,否则返回EBUSY。因为Linux实现的条件变量没有分配什么资源,所以注销动作只包括检查是否有等待线程。API定义如下:
int pthread_cond_destroy(pthread_cond_t *cond)

2. 等待和激发

int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime)

 

   等待条件有两种方式:无条件等待pthread_cond_wait()和计时等待pthread_cond_timedwait(),其中计时等待方式如果在给定时刻前条件没有满足,则返回ETIMEOUT,结束等待,其中abstime以与time()系统调用相同意义的绝对时间形式出现,0表示格林尼治时间1970年1月1日0时0分0秒。

   无论哪种等待方式,都必须和一个互斥锁配合,以防止多个线程同时请求pthread_cond_wait()(或pthread_cond_timedwait(),下同)的竞争条件(Race Condition)。mutex互斥锁必须是普通锁(PTHREAD_MUTEX_TIMED_NP)或者适应锁(PTHREAD_MUTEX_ADAPTIVE_NP),且在调用pthread_cond_wait()前必须由本线程加锁(pthread_mutex_lock()),而在更新条件等待队列以前,mutex保持锁定状态,并在线程挂起进入等待前解锁。在条件满足从而离开pthread_cond_wait()之前,mutex将被重新加锁,以与进入pthread_cond_wait()前的加锁动作对应。

   激发条件有两种形式,pthread_cond_signal()激活一个等待该条件的线程,存在多个等待线程时按入队顺序激活其中一个;而pthread_cond_broadcast()则激活所有等待线程。

3. 其他

pthread_cond_wait()和pthread_cond_timedwait()都被实现为取消点,因此,在该处等待的线程将立即重新运行,在重新锁定mutex后离开pthread_cond_wait(),然后执行取消动作。也就是说如果pthread_cond_wait()被取消,mutex是保持锁定状态的,因而需要定义退出回调函数来为其解锁。

以下示例集中演示了互斥锁和条件变量的结合使用,以及取消对于条件等待动作的影响。在例子中,有两个线程被启动,并等待同一个条件变量,如果不使用退出回调函数(见范例中的注释部分),则tid2将在pthread_mutex_lock()处永久等待。如果使用回调函数,则tid2的条件等待及主线程的条件激发都能正常工作。

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
pthread_mutex_t mutex;
pthread_cond_t  cond;
void * child1(void *arg)
{
        pthread_cleanup_push(pthread_mutex_unlock,&mutex);  /* comment 1 */
        while(1){
                printf("thread 1 get running \n");
        printf("thread 1 pthread_mutex_lock returns %d\n",
pthread_mutex_lock(&mutex));
        pthread_cond_wait(&cond,&mutex);
                    printf("thread 1 condition applied\n");
        pthread_mutex_unlock(&mutex);
                    sleep(5);
    }
        pthread_cleanup_pop(0);     /* comment 2 */
}
void *child2(void *arg)
{
        while(1){
                sleep(3);               /* comment 3 */
                printf("thread 2 get running.\n");
        printf("thread 2 pthread_mutex_lock returns %d\n",
pthread_mutex_lock(&mutex));
        pthread_cond_wait(&cond,&mutex);
        printf("thread 2 condition applied\n");
        pthread_mutex_unlock(&mutex);
        sleep(1);
        }
}
int main(void)
{
        int tid1,tid2;
        printf("hello, condition variable test\n");
        pthread_mutex_init(&mutex,NULL);
        pthread_cond_init(&cond,NULL);
        pthread_create(&tid1,NULL,child1,NULL);
        pthread_create(&tid2,NULL,child2,NULL);
        do{
        sleep(2);                   /* comment 4 */
                pthread_cancel(tid1);       /* comment 5 */
                sleep(2);                   /* comment 6 */
        pthread_cond_signal(&cond);
    }while(1);  
        sleep(100);
        pthread_exit(0);
}

 

   如果不做注释5的pthread_cancel()动作,即使没有那些sleep()延时操作,child1和child2都能正常工作。注释3和注释4的延迟使得child1有时间完成取消动作,从而使child2能在child1退出之后进入请求锁操作。如果没有注释1和注释2的回调函数定义,系统将挂起在child2请求锁的地方;而如果同时也不做注释3和注释4的延时,child2能在child1完成取消动作以前得到控制,从而顺利执行申请锁的操作,但却可能挂起在pthread_cond_wait()中,因为其中也有申请mutex的操作。child1函数给出的是标准的条件变量的使用方式:回调函数保护,等待条件前锁定,pthread_cond_wait()返回后解锁。

条件变量机制不是异步信号安全的,也就是说,在信号处理函数中调用pthread_cond_signal()或者pthread_cond_broadcast()很可能引起死锁。


 

三、信号灯

   信号灯与互斥锁和条件变量的主要不同在于"灯"的概念,灯亮则意味着资源可用,灯灭则意味着不可用。如果说后两中同步方式侧重于"等待"操作,即资源不可用的话,信号灯机制则侧重于点灯,即告知资源可用;没有等待线程的解锁或激发条件都是没有意义的,而没有等待灯亮的线程的点灯操作则有效,且能保持灯亮状态。当然,这样的操作原语也意味着更多的开销。

   信号灯的应用除了灯亮/灯灭这种二元灯以外,也可以采用大于1的灯数,以表示资源数大于1,这时可以称之为多元灯。

1. 创建和注销

   POSIX信号灯标准定义了有名信号灯和无名信号灯两种,但LinuxThreads的实现仅有无名灯,同时有名灯除了总是可用于多进程之间以外,在使用上与无名灯并没有很大的区别,因此下面仅就无名灯进行讨论。

int sem_init(sem_t *sem, int pshared, unsigned int value)
这是创建信号灯的API,其中value为信号灯的初值,pshared表示是否为多进程共享而不仅仅是用于一个进程。LinuxThreads没有实现多进程共享信号灯,因此所有非0值的pshared输入都将使sem_init()返回-1,且置errno为ENOSYS。初始化好的信号灯由sem变量表征,用于以下点灯、灭灯操作。

int sem_destroy(sem_t * sem) 
被注销的信号灯sem要求已没有线程在等待该信号灯,否则返回-1,且置errno为EBUSY。除此之外,LinuxThreads的信号灯注销函数不做其他动作。

2. 点灯和灭灯

int sem_post(sem_t * sem)

点灯操作将信号灯值原子地加1,表示增加一个可访问的资源。

int sem_wait(sem_t * sem)
int sem_trywait(sem_t * sem)
 

sem_wait()为等待灯亮操作,等待灯亮(信号灯值大于0),然后将信号灯原子地减1,并返回。sem_trywait()为sem_wait()的非阻塞版,如果信号灯计数大于0,则原子地减1并返回0,否则立即返回-1,errno置为EAGAIN。

3. 获取灯值

int sem_getvalue(sem_t * sem, int * sval)

读取sem中的灯计数,存于*sval中,并返回0。

4. 其他

sem_wait()被实现为取消点,而且在支持原子"比较且交换"指令的体系结构上,sem_post()是唯一能用于异步信号处理函数的POSIX异步信号安全的API。


 

四、异步信号

   由于LinuxThreads是在核外使用核内轻量级进程实现的线程,所以基于内核的异步信号操作对于线程也是有效的。但同时,由于异步信号总是实际发往某个进程,所以无法实现POSIX标准所要求的"信号到达某个进程,然后再由该进程将信号分发到所有没有阻塞该信号的线程中"原语,而是只能影响到其中一个线程。

   POSIX异步信号同时也是一个标准C库提供的功能,主要包括信号集管理(sigemptyset()、sigfillset()、sigaddset()、sigdelset()、sigismember()等)、信号处理函数安装(sigaction())、信号阻塞控制(sigprocmask())、被阻塞信号查询(sigpending())、信号等待(sigsuspend())等,它们与发送信号的kill()等函数配合就能实现进程间异步信号功能。LinuxThreads围绕线程封装了sigaction()何raise(),本节集中讨论LinuxThreads中扩展的异步信号函数,包括pthread_sigmask()、pthread_kill()和sigwait()三个函数。毫无疑问,所有POSIX异步信号函数对于线程都是可用的。

int pthread_sigmask(int how, const sigset_t *newmask, sigset_t *oldmask)
设置线程的信号屏蔽码,语义与sigprocmask()相同,但对不允许屏蔽的Cancel信号和不允许响应的Restart信号进行了保护。被屏蔽的信号保存在信号队列中,可由sigpending()函数取出。

int pthread_kill(pthread_t thread, int signo)
向thread号线程发送signo信号。实现中在通过thread线程号定位到对应进程号以后使用kill()系统调用完成发送。

int sigwait(const sigset_t *set, int *sig)
挂起线程,等待set中指定的信号之一到达,并将到达的信号存入*sig中。POSIX标准建议在调用sigwait()等待信号以前,进程中所有线程都应屏蔽该信号,以保证仅有sigwait()的调用者获得该信号,因此,对于需要等待同步的异步信号,总是应该在创建任何线程以前调用pthread_sigmask()屏蔽该信号的处理。而且,调用sigwait()期间,原来附接在该信号上的信号处理函数不会被调用。

如果在等待期间接收到Cancel信号,则立即退出等待,也就是说sigwait()被实现为取消点。


 

五、其他同步方式

   除了上述讨论的同步方式以外,其他很多进程间通信手段对于LinuxThreads也是可用的,比如基于文件系统的IPC(管道、Unix域Socket等)、消息队列(Sys.V或者Posix的)、System V的信号灯等。只有一点需要注意,LinuxThreads在核内是作为共享存储区、共享文件系统属性、共享信号处理、共享文件描述符的独立进程看待的。

 

条件变量与互斥锁、信号量的区别

1).互斥锁必须总是由给它上锁的线程解锁,信号量的挂出即不必由执行过它的等待操作的同一进程执行。一个线程可以等待某个给定信号灯,而另一个线程可以挂出该信号灯。

2).互斥锁要么锁住,要么被解开(二值状态,类型二值信号量)

3).由于信号量有一个与之关联的状态(它的计数值),信号量挂出操作总是被记住。然而当向一个条件变量发送信号时,如果没有线程等待在该条件变量上,那么该信号将丢失。

4).互斥锁是为了上锁而设计的,条件变量是为了等待而设计的,信号灯即可用于上锁,也可用于等待,因而可能导致更多的开销和更高的复杂性。

博文原址:http://blog.csdn.net/h_armony/article/details/6766505

2017-08-03 09:33:04 zhaoxd200808501 阅读数 609
  • linux线程全解-linux应用编程和网络编程第7部分

    本课程讲解linux中线程,首先使用多进程解决上个课程中提出的并发式读取按键和鼠标的任务,然后引出多线程并讲解多线程的优势,后详细讲了多线程的同步技术。学习本课程的目的是学会在linux应用编程中使用多线程技术。

    5133 人正在学习 去看看 朱有鹏

一、互斥锁基本原理

  互斥锁以排他方式防止共享数据被并发访问。互斥锁为一个二元变量,其状态分为开锁上锁,将某个共享资源与某个特定互斥锁在逻辑上绑定(即要申请该资源必须先获取锁),对该共享资源的访问操作如下:
  1.在访问该资源前,首先申请该互斥锁,如果该互斥锁处于开锁状态,则申请到该锁对象,并占有该锁(使该锁处于锁定状态),以防止其他线程访问该资源;如果该锁处于锁定状态,默认阻塞当前线程。
  2.只有锁定改互斥锁的进程才能释放该互斥锁,其他线程释放操作无效。
  3.互斥锁的主要作用是保证线程执行完整性

二、互斥锁操作流程

  1.定义一个全局的锁;
  2.初始化锁;
  3.创建线程;
  4.上锁、操作公共资源、解锁;
  5.线程退出,释放资源(销毁锁)。

三、互斥锁基本操作函数

  互斥锁基本操作函数如下表所示:
 这里写图片描述

1.初始化互斥锁

  在使用互斥锁前,需要定义互斥锁(全局变量),定义互斥锁的代码入下:

phtread_mutex_t lock;

  初始化互斥锁的函数为pthread_mutex_init,互斥锁函数声明如下:

/*Initialize a mutex*/
int pthread_mutex_init(pthread_mutex_t* mutex, pthread_mutexattr_t* mutexattr);

  第1个参数mutex是指向要初始化的互斥锁的指针。
  第2个参数mutexattr是指向属性对象的指针,该属性对象定义要初始化的互斥锁的属性。若该指针为NULL时,使用默认属性

  使用默认属性初始化互斥锁代码如下:

phtread_mutex_t mp;
int ret = pthread_mutex_init(&mp, NULL);

  使用自定义属性初始化互斥锁代码如下:

pthread_mutexattr_t mattr;
phtread_mutex_t mp;
int ret = pthread_mutex_init(&mp, &mattr);

  pthread_mutex_init()函数返回值为0表示函数执行成功。否则,将返回错误编号以指明错误

  此外,还可以使用宏PTHREAD_MUTEX_INITIALIZER初始化今天分配的互斥锁。此宏定义如下:

/*come from /usr/include/pthread.h*/
#define PTHREAD_MUTEX_INITIALIZER { { 0, } }

  使用宏PTHREAD_MUTEX_INITIALIZER初始化互斥锁代码如下:

phtread_mutex_t mp = PTHREAD_MUTEX_INITIALIZER;

2.申请互斥锁
  如果一线程要占用一共享资源,必须先申请对应的互斥锁。pthread_mutex_lock()函数以阻塞的方式申请互斥锁,其函数申明如下:

int pthread_mutex_lock(pthread_mutex_t* mutex);

  pthread_mutex_trylock()函数以非阻塞方式申请互斥锁,函数申明如下:

int pthread_mutex_trylock(pthread_mutex_t* mutex);

  pthread_mutex_lock()pthread_mutex_trylock()执行成功时返回0。否则,返回一个错误编号,以指明错误。

3.释放互斥锁
  pthread_mutex_unlock()函数用来释放互斥锁,其函数申明如下:

/*Unlock a mutex*/
int pthread_mutex_unlock(pthread_mutex_t* mutex);

  参数mutex为执行要解锁的互斥锁的指针。释放操作只能由占有该互斥锁的线程完成。该函数执行成功时返回0。否则,返回指明错误的错误编号(未设置errno变量)。

4.销毁互斥锁
  pthread_mutex_destroy()函数用来释放互斥锁,其函数申明如下:

/*Destroy a mutex*/
int pthread_mutex_destroy(pthread_mutex_t* mutex);

  参数mutex为执行要解锁的互斥锁的指针。该函数执行成功时返回0。否则,返回指明错误的错误编号。

四、示例

  下面通过3个线程来计算1+2+3+…+100的值,代码如下:

#include <stdio.h>  
#include <pthread.h>

int sum = 0;

void* pth_add1(void* arg)
{
    int i;

    for (i=1; i<20; i++) {
        sum += i;
        usleep(10000);
    }

    pthread_exit(0);
}

void* pth_add2(void* arg)
{
    int i;

    for (i=20; i<60; i++) {
        usleep(10000);
        sum += i;
    }

    pthread_exit(0);
}

void* pth_add3(void* arg)
{
    int i;

    for (i=60; i<=100; i++) {
        sum += i;
        usleep(10000);
    }

    pthread_exit(0);
}


int main()  
{  
    pthread_t tid1, tid2, tid3;
    int ret;

    ret = pthread_create(&tid1, NULL, pth_add1, NULL);
    if (0 != ret) {
        perror("create pthead error");
        return -1;
    }

    ret = pthread_create(&tid2, NULL, pth_add2, NULL);
    if (0 != ret) {
        perror("create pthead error");
        return -1;
    }

    ret = pthread_create(&tid3, NULL, pth_add3, NULL);
    if (0 != ret) {
        perror("create pthead error");
        return -1;
    }

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    pthread_join(tid3, NULL);

    printf("sum = %d\n", sum);

    return 0;
}

运行结果如下所示:
这里写图片描述

  由上图可知,四次运行结果中只有一次结果是对的,为什么会出现这样的情况呢?由于3个线程访问共享资源sum,而没有使用互斥锁导致,下面给每个线程加互斥锁:

#include <stdio.h>  
#include <pthread.h>

pthread_mutex_t lock;
int sum = 0;

void* pth_add1(void* arg)
{
    int i;

    // 申请互斥锁
    pthread_mutex_lock(&lock);

    for (i=1; i<20; i++) {
        sum += i;
        usleep(10000);
    }
    // 释放互斥锁
    pthread_mutex_unlock(&lock);

    pthread_exit(0);
}

void* pth_add2(void* arg)
{
    int i;
    // 申请互斥锁
    pthread_mutex_lock(&lock);

    for (i=20; i<60; i++) {
        usleep(10000);
        sum += i;
    }
    // 释放互斥锁
    pthread_mutex_unlock(&lock);

    pthread_exit(0);
}

void* pth_add3(void* arg)
{
    int i;
    // 申请互斥锁
    pthread_mutex_lock(&lock);

    for (i=60; i<=100; i++) {
        sum += i;
        usleep(10000);
    }
    // 释放互斥锁
    pthread_mutex_unlock(&lock);

    pthread_exit(0);
}


int main()  
{  
    pthread_t tid1, tid2, tid3;
    int ret;

    // 初始化锁
    pthread_mutex_init(&lock, NULL);

    ret = pthread_create(&tid1, NULL, pth_add1, NULL);
    if (0 != ret) {
        perror("create pthead error");
        return -1;
    }

    ret = pthread_create(&tid2, NULL, pth_add2, NULL);
    if (0 != ret) {
        perror("create pthead error");
        return -1;
    }

    ret = pthread_create(&tid3, NULL, pth_add3, NULL);
    if (0 != ret) {
        perror("create pthead error");
        return -1;
    }

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    pthread_join(tid3, NULL);

    // 销毁锁
    pthread_mutex_destroy(&lock);

    printf("sum = %d\n", sum);

    return 0;
}

运行结果如下:
这里写图片描述
  由上图可知,4次运行结果均正确,这便证明互斥锁可以确保线程执行的完整性,故对共享资源的访问一定要用互斥锁保护起来

2020-01-22 02:35:10 weixin_38054045 阅读数 10
  • linux线程全解-linux应用编程和网络编程第7部分

    本课程讲解linux中线程,首先使用多进程解决上个课程中提出的并发式读取按键和鼠标的任务,然后引出多线程并讲解多线程的优势,后详细讲了多线程的同步技术。学习本课程的目的是学会在linux应用编程中使用多线程技术。

    5133 人正在学习 去看看 朱有鹏

linux多线程的同步机制有几种方式,我们分别来讲
1、互斥量
保证临界区同时有且仅有一个线程在访问
互斥量函数 :
初始化信互斥量pthread_mutex_init
加锁 pthread_mutex_lock()
解锁 pthread_mutex_unlock
在加锁和解锁之间执行的代码为临界区资源,加锁和解锁必须成对出现。使用互斥量来同步进程,往往会造成cpu的浪费,比如考虑如下代码,当临街资源sum 》100时我们将其赋值为0
开启三个线程,thread1(加操作),thread2(减操作),thread3(赋值为0)

thread1
void func1()
{
 pthread_mutex_lock()
 sum++
pthread_mutex_unlock()
}
thread2
void func2()
{
 pthread_mutex_lock()
 --sum
pthread_mutex_unlock()
}
thread3
void func3()
{
 pthread_mutex_lock()
 if(sum>100)
{
 sum=0
pthread_mutex_unlock()
}
else
{
pthread_mutex_unlock()
}
}

从代码中我们可以看出,当sum不满100的时候,我们要去查询,并且sleep,如果当且仅当刚查询完sum不满100,然后立即sum满100,此时我们的线程仍然不得不睡眠100s这就浪费了cpu,所以为了充分利用cpu接下来引入了条件变量

2、条件变量
条件变量和互斥锁要同时使用,因为条件变量也要被保护,条件变量不同于互斥量需要不断的去轮询,=或者浪费cpu资源,条件变量会在条件不满足时阻塞,条件满足时释放变量,通知被阻塞的线程,而不许要不断的去轮询条件,
条件变量函数:

初始化条件变量:pthread_cond_init
等待条件变量 pthread_cond_wait()/pthread_cond_timewait()
通知条件变量满足条件:pthread_cond_signal()/pthread_cond_broadcast()

假设同样上述问题:

thread1
void func1()
{
pthread_mutex_lock()
sum++
pthread_mutex_unlock()
if (sum>100)
    pthread_cond_broadcast()
}
thread2
void func2()
{
pthread_mutex_lock()
--sum
pthread_mutex_unlock()
}
thread3
void func3()
{
pthread_mutex_lock()
while(sum<100)
    {
      pthread_cond_wait()
   }
sum=0
pthread_mutex_unlock()
}

这段代码的cpu利用效率旧远比上述直接使用互斥量来的高,我们使用互斥量访问临街区实现sum++,如果sum不大于100. pthread_cond_wait()就会一直阻塞,并且释放锁,当条件满足时pthread_cond_broadcast()会使pthread_cond_wait()函数成功返回,返回的同时将互斥量加锁,然后访问临界资源sum使其为0.然后释放锁。为什么我们会使用一个while拍判断sum<100而不是一个if语句,因为函数pthread_cond_broadcast()通知函数pthread_cond_wait()满足条件这期间有时间差,如果在通知的后,但pthread_cond_wait()还没来得及返回时,sum执行了减操作(因为pthread_cond_wait()函数没返回之前,是释放了锁的,所以此时可能会被线程二申请到锁,执行了减操作)此时sum就不满足条件了,所以我们要在一个while中判断,而不是,一个if,一个if没办法,保证sum的值在此期间满足条件。

3、信号量
信号量和互斥量最大的不同就是同时可以允许临界资源被多少线程访问,二进制信号量就和互斥量一样,pv操作承兑出现,且操作的值初始化为1,p操作,执行减1操作,相当于,一个线程申请了锁,v操作执行了加1操作,标明此时资源可以被访问,如果值为负数,则标明当前有多个线程在等待,这些线程会被防止等待队列中,等待由资源时被唤醒

thread1
void func1()
{
 sem_wait(s)
 sum++
sem_post(s)
}
thread2
void func2()
{
 sem_wait(s)
 --sum
sem_post(s)
}

通过加减s的值来控制临界资源的访问,如果s值初始化为1则为二进制信号量,非1,则同时允许多个线程同时访问临界资源

2017-08-10 17:37:37 zhaoxd200808501 阅读数 873
  • linux线程全解-linux应用编程和网络编程第7部分

    本课程讲解linux中线程,首先使用多进程解决上个课程中提出的并发式读取按键和鼠标的任务,然后引出多线程并讲解多线程的优势,后详细讲了多线程的同步技术。学习本课程的目的是学会在linux应用编程中使用多线程技术。

    5133 人正在学习 去看看 朱有鹏

一、信号量基本原理

信号量概念由荷兰科学家Dijkstra首先提出。信号量是一个特殊类型的变量,它可以被增加或者减少。但对其的关键访问被保证是原子操作,即使在一个多线程程序中也是如此。

信号量有两种类型:
  1.二进制信号量。它只有0和1两种取值。
  2.计数信号量。它可以有更大的取值范围。
  
  如果要用信号量来保护一段代码,使其每次只能被一个执行线程运行,就要用到二进制信号量。
  如果要允许有限数目的线程执行一段指定的代码,就需要用到计数信号量。

二、信号量基本操作

信号量基本操作如下表所示:
这里写图片描述

在使用信号量时需要包含头文件,如下所示:

#include<semaphore.h>

1.初始化信号量
  在使用信号量之前,需要定义信号量,定义信号量的代码如下:

sem_t sem;

sem_init()函数用于初始化信号量,其函数声明如下:

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

第1个参数sem为指向信号量结构的一个指针;
  第2个参数pshared表示是否为多进程共享当前信号量。Linux Threads没有实现多进程共享信号量,因此pshared必须为0,所有非0值的pshared输入都将使sem_init()返回-1,且置errno为ENOSYS;
  第3个参数value给出了信号量的初始值。

2.等待信号量
  sem_wait()函数以阻塞的方式等待信号量,若value的值大于0会将value的值减1,然后继续向下执行。若value的值为0会一直等待,直到value的值大于0。其函数声明如下所示:

int sem_wait(sem_t *sem);

sem_trywait()函数以非阻塞方式等待信号量。若value的值大于0,会将value的值减1,然后返回0。若value的为0,则返回-1。其函数声明如下所示:

int sem_trywait(sem_t *sem);

3.释放信号量
  sem_post()函数用于释放信号量。此函数会将value的值加1,然后通知其他等待该信号量的线程。当有线程阻塞在这个信号量上时,调用这个函数会使其中的一个线程不再阻塞,选择机制同样是由线程的调度策略决定的。函数声明如下所示:

int sem_post(sem_t *sem);

该函数成功时返回 0;错误时,信号量的值没有更改,返回-1 ,并设置errno 来指明错误。

4.获取信号量的值
  sem_getvalue()函数用于获取信号量的值。函数声明如下所示:

int sem_getvalue(sem_t* sem, int* sval)

第1个参数sem为指向信号量结构的一个指针;
  第2个参数用于返回信号量的值。

该函数执行成功返回0,错误时,返回-1 ,并设置errno 来指明错误。
  
5.销毁信号量
  sem_destroy()函数用来销毁信号量,其函数声明如下:

int sem_destroy(sem_t *sem);

参数sem为指向信号量结构的一个指针。

三、示例

下面通过信号量来实现生产者,消费者模问题。生产者消费者问题是一个经典的数学问题,要求生产者-消费者在固定仓库空间条件下,生产者每生产一个产品将占用一个仓库空间,生产者生产的产品库存不能越过仓库的存储量,消费者每消费一个产品将增加一个仓库空间,消费者在仓库产品为0时不能再消费。
  
下面为示例代码:

#include <stdio.h>  
#include <pthread.h>
#include <semaphore.h>

sem_t sem_product;		// 产品信号量
sem_t sem_space;		// 仓库容量信号量

void* pth_consume(void* arg)
{
	char* name = (char*)arg;
	int cnt;

	while (1) {
		sem_wait(&sem_product);

		sem_post(&sem_space);

		sem_getvalue(&sem_product, &cnt);
		printf("consume thread %s consumption a product, production count:%d\n", name, cnt);		

		sleep(2);	// 每隔2S消费一个产品
	}
	
	pthread_exit(0);
}

void* pth_product(void* arg)
{
	char* name = (char*)arg;
	int cnt;

	while (1) {
		sem_wait(&sem_space);

		sem_post(&sem_product);

		sem_getvalue(&sem_product, &cnt);
		printf("product thread %s produce a product, production count:%d\n", name, cnt);			

		sleep(1);	// 每隔1S生产一个产品
	}
	
	pthread_exit(0);
}

int main()  
{  
	pthread_t tid1, tid2, tid3, tid4;
	int ret;

	// 初始化信号量
	sem_init(&sem_product, 0, 0);	// 初始状态产品个数为0
	sem_init(&sem_space, 0, 5);		// 初始状态仓库空间为5

	ret = pthread_create(&tid1, NULL, pth_product, "A");
	if (0 != ret) {
		perror("create pthead error");
		return -1;
	}

	ret = pthread_create(&tid2, NULL, pth_product, "B");
	if (0 != ret) {
		perror("create pthead error");
		return -1;
	}

	ret = pthread_create(&tid3, NULL, pth_consume, "C");
	if (0 != ret) {
		perror("create pthead error");
		return -1;
	}

	ret = pthread_create(&tid4, NULL, pth_consume, "D");
	if (0 != ret) {
		perror("create pthead error");
		return -1;
	}

	pthread_join(tid1, NULL);
	pthread_join(tid2, NULL);
	pthread_join(tid3, NULL);
	pthread_join(tid4, NULL);

	// 销毁信号量
	sem_destroy(&sem_product);
	sem_destroy(&sem_space);

	return 0;
}

运行结果如下图所示:
这里写图片描述

没有更多推荐了,返回首页