四线程 概述

作者:电脑系统

  三、互斥锁

  互斥锁: 只要被锁住,其他任何线程都不可以访问被保护的资源

int pthread_mutex_unlock(pthread_mutex_t *mutex);

1.线程的创建和退出

  • 进程:资源分配最小单位
  • 线程:轻量级的进程 是系统调度的最小单位 由进程创建 多个线程共享进程的资源

互斥量

2.线程属性

pthread_create函数的第二个参数线程的属性。将该值设为NULL,也就是采用默认属性,线程的多项属性都是可以更改的。这些属性主要包括绑定属性、分离属性、堆栈地址、堆栈大小、优先级。其中系统默认的属性为非绑定、非分离、缺省1M 的堆栈、与父进程同样级别的优先级。下面首先对绑定属性和分离属性的基本概念进行讲解。

绑定属性:

  Linux中采用“一对一”的线程机制,也就是一个用户线程对应一个内核线程。绑定属性就是指一个用户线程固定地分配给一个内核线程,因为CPU时间片的调度是面向内核线程 (也就是轻量级进程)的,因此具有绑定属性的线程可以保证在需要的时候总有一个内核线程与之对应。而与之相对的非绑定属性就是指用户线程和内核线程的关系不是始终固定的,而是由系统来控制分配的。

分离属性:

  分离属性是用来决定一个线程以什么样的方式来终止自己。在非分离情况下,当一个线程结束时,它所占用的系统资源并没有被释放,也就是没有真正的终止。只有当pthread_join()函数返回时,创建的线程才能释放自己占用的系统资源。而在分离属性情况下,一个线程结束时立即释放它所占有的系统资源。这里要注意的一点是,如果设置一个线程的分离属性,而这个线程运行又非常快,那么它很可能在pthread_create 函数返回之前就终止了,它终止以后就可能将线程号和系统资源移交给其他的线程使用,这时调用pthread_create 的线程就得到了错误的线程号。

设置绑定属性:

int pthread_attr_init(pthread_attr_t *attr)
int pthread_attr_setscope(pthread_attr_t *attr, int scope)
int pthread_attr_getscope(pthread_attr_t *tattr, int *scope)
scope:PTHREAD_SCOPE_SYSTEM:绑定,此线程与系统中所有的线程竞争 PTHREAD_SCOPE_PROCESS:非绑定,此线程与进程中的其他线程竞争

设置分离属性:

int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate)
int pthread_attr_getdetachstate(const pthread_attr_t *tattr,int *detachstate)
detachstate PTHREAD_CREATE_DETACHED:分离 PTHREAD _CREATE_JOINABLE:非分离

设置调度策略:

int pthread_attr_setschedpolicy(pthread_attr_t * tattr, int policy)
int pthread_attr_getschedpolicy(pthread_attr_t * tattr, int *policy)
policy SCHED_FIFO:先入先出 SCHED_RR:循环 SCHED_OTHER:实现定义的方法

设置优先级:

int pthread_attr_setschedparam (pthread_attr_t *attr, struct sched_param *param)
int pthread_attr_getschedparam (pthread_attr_t *attr, struct sched_param *param)

3.线程访问控制

1)互斥锁(mutex)
通过锁机制实现线程间的同步。同一时刻只允许一个线程执行一个关键部分的代码。

1 int pthread_mutex_init(pthread_mutex_t *mutex,const pthread_mutex_attr_t *mutexattr);
2 int pthread_mutex_lock(pthread_mutex_t *mutex);
3 int pthread_mutex_unlock(pthread_mutex_t *mutex);
4 int pthread_mutex_destroy(pthread_mutex_t *mutex);

(1)先初始化锁init()或静态赋值pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIER
(2)加锁,lock,trylock,lock阻塞等待锁,trylock立即返回EBUSY
(3)解锁,unlock需满足是加锁状态,且由加锁线程解锁
(4)清除锁,destroy(此时锁必需unlock,否则返回EBUSY)

mutex 分为递归(recursive) 和非递归(non-recursive)两种,这是POSIX 的叫法,另外的名字是可重入(Reentrant) 与非可重入。这两种mutex 作为线程间(inter-thread) 的同步工具时没有区别,它们的惟一区别在于:同一个线程可以重复对recursive mutex 加锁,但是不能重复对non-recursive mutex 加锁。
首选非递归mutex,绝对不是为了性能,而是为了体现设计意图。non-recursive 和recursive 的性能差别其实不大,因为少用一个计数器,前者略快一点点而已。在同一个线程里多次对non-recursive mutex 加锁会立刻导致死锁,我认为这是它的优点,能帮助我们思考代码对锁的期求,并且及早(在编码阶段)发现问题。毫无疑问recursive mutex 使用起来要方便一些,因为不用考虑一个线程会自己把自己给锁死了,我猜这也是Java 和Windows 默认提供recursive mutex 的原因。(Java 语言自带的intrinsic lock 是可重入的,它的concurrent 库里提供ReentrantLock,Windows的CRITICAL_SECTION 也是可重入的。似乎它们都不提供轻量级的non-recursive mutex。)

2)条件变量(cond)
利用线程间共享的全局变量进行同步的一种机制。

1 int pthread_cond_init(pthread_cond_t *cond,pthread_condattr_t *cond_attr);
2 int pthread_cond_wait(pthread_cond_t *cond,pthread_mutex_t *mutex);
3 int pthread_cond_timedwait(pthread_cond_t *cond,pthread_mutex_t *mutex,const timespec *abstime);
4 int pthread_cond_destroy(pthread_cond_t *cond); 
5 int pthread_cond_signal(pthread_cond_t *cond);
6 int pthread_cond_broadcast(pthread_cond_t *cond);  //解除所有线程的阻塞

(1)初始化. init()或者pthread_cond_t cond=PTHREAD_COND_INITIALIER;属性置为NULL
(2)等待条件成立. pthread_cond_wait,pthread_cond_timedwait.
wait()释放锁,并阻塞等待条件变量为真
timedwait()设置等待时间,仍未signal,返回ETIMEOUT(加锁保证只有一个线程wait)
(3)激活条件变量:pthread_cond_signal,pthread_cond_broadcast(激活所有等待线程)
(4)清除条件变量:destroy; 无线程等待,否则返回EBUSY

 

复制代码 代码如下:

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);

 

这两个函数一定要在mutex的锁定区域内使用。

调用 pthread_cond_signal() 释放被条件阻塞的线程时,如果没有任何线程基于条件变量阻塞,则调用pthread_cond_signal()不起作用。而对于 Windows,当调用 SetEvent 触发 Auto-reset 的 Event 条件时,如果没有被条件阻塞的线程,那么此函数仍然起作用,条件变量会处在触发状态。

Linux下生产者消费者问题(使用互斥锁和条件变量):

 

复制代码 代码如下:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "pthread.h"

 

#define BUFFER_SIZE 16

struct prodcons 

int buffer[BUFFER_SIZE]; 
pthread_mutex_t lock;  //mutex ensuring exclusive access to buffer
int readpos,writepos;  //position for reading and writing
pthread_cond_t notempty;  //signal when buffer is not empty
pthread_cond_t notfull;  //signal when buffer is not full
}; 

//initialize a buffer
void init(struct prodcons* b) 

pthread_mutex_init(&b->lock,NULL); 
pthread_cond_init(&b->notempty,NULL); 
pthread_cond_init(&b->notfull,NULL); 
b->readpos = 0; 
b->writepos = 0; 

//store an integer in the buffer
void put(struct prodcons* b, int data) 

pthread_mutex_lock(&b->lock); 
//wait until buffer is not full
while((b->writepos 1)%BUFFER_SIZE == b->readpos) 

printf("wait for not fulln"); 
pthread_cond_wait(&b->notfull,&b->lock); 
}
b->buffer[b->writepos] = data; 
b->writepos ;
b->writepos %= BUFFER_SIZE;
pthread_cond_signal(&b->notempty); //signal buffer is not empty
pthread_mutex_unlock(&b->lock); 
}

//read and remove an integer from the buffer
int get(struct prodcons* b) 

int data; 
pthread_mutex_lock(&b->lock); 
//wait until buffer is not empty
while(b->writepos == b->readpos) 

printf("wait for not emptyn"); 
pthread_cond_wait(&b->notempty,&b->lock); 
}
data=b->buffer[b->readpos]; 
b->readpos ;
b->readpos %= BUFFER_SIZE;
pthread_cond_signal(&b->notfull);  //signal buffer is not full
pthread_mutex_unlock(&b->lock); 
return data;
}

#define OVER -1

struct prodcons buffer; 

void * producer(void * data) 

int n; 
for(n=0; n<50; n) 
{
printf("put-->%dn",n); 
put(&buffer,n); 

put(&buffer,OVER); 
printf("producer stoppedn"); 
return NULL; 

void * consumer(void * data) 

int n; 
while(1) 

int d = get(&buffer); 
if(d == OVER) break; 
printf("get-->%dn",d); 
}
printf("consumer stoppedn"); 
return NULL; 

int main() 

pthread_t tha,thb; 
void * retval; 

init(&buffer); 
pthread_creare(&tha,NULL,producer,0); 
pthread_creare(&thb,NULL,consumer,0); 

pthread_join(tha,&retval); 
pthread_join(thb,&retval); 

return 0; 
}

 

3)信号量
如同进程一样,线程也可以通过信号量来实现通信,虽然是轻量级的。

信号量函数的名字都以"sem_"打头。线程使用的基本信号量函数有四个。

复制代码 代码如下:

#include <semaphore.h>
int sem_init(sem_t *sem , int pshared, unsigned int value);

这是对由sem指定的信号量进行初始化,设置好它的共享选项(linux只支持为0,即表示它是当前进程的局部信号量),然后给它一个初始值VALUE。

 

两个原子操作函数:这两个函数都要用一个由sem_init调用初始化的信号量对象的指针做参数。

 

复制代码 代码如下:

int sem_wait(sem_t *sem); //给信号量减1,对一个值为0的信号量调用sem_wait,这个函数将会等待直到有其它线程使它不再是0为止。
int sem_post(sem_t *sem); //给信号量的值加1

 

int sem_destroy(sem_t *sem);

 

这个函数的作用是再我们用完信号量后都它进行清理。归还自己占有的一切资源。

用信号量实现生产者消费者:

这里使用4个信号量,其中两个信号量occupied和empty分别用于解决生产者和消费者线程之间的同步问题,pmut用于多个生产者之间互斥问题,cmut是用于多个消费者之间互斥问题。其中empty初始化为N(有界缓区的空间元数),occupied初始化为0,pmut和cmut初始化为1。

参考代码:

 

复制代码 代码如下:

#define BSIZE 64

 

typedef struct
{
char buf[BSIZE];
sem_t occupied;
sem_t empty;
int nextin;
int nextout;
sem_t pmut;
sem_t cmut;
}buffer_t;

buffer_t buffer;

void init(buffer_t * b)
{
sem_init(&b->occupied, 0, 0);
sem_init(&b->empty,0, BSIZE);
sem_init(&b->pmut, 0, 1);
sem_init(&b->cmut, 0, 1);
b->nextin = b->nextout = 0;
}

void producer(buffer_t *b, char item)
{
sem_wait(&b->empty);
sem_wait(&b->pmut);
b->buf[b->nextin] = item;
b->nextin ;
b->nextin %= BSIZE;
sem_post(&b->pmut);
sem_post(&b->occupied);
}

char consumer(buffer_t *b)
{
char item;
sem_wait(&b->occupied);
sem_wait(&b->cmut);
item = b->buf[b->nextout];
b->nextout ;
b->nextout %= BSIZE;
sem_post(&b->cmut);
sem_post(&b->empty);
return item;
}

  前言:有个问题感觉一直会被问道:进程和线程的区别?也许之前我会回答:

sem_t empty; //缓冲区空闲数据信号量

线程分类

  1、信号量相关函数

  • sem_init函数

sem_t s;

#include <semaphore.h>

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

格式:sem_init(&s,0,n)
功能:初始化一个信号量的值为value
参数2:是否在进程间使用 一般总是0 表示不在进程间使用
参数3:计数器的初始值

  • sem_wait函数

int sem_wait(sem_t *sem);
把计数器减一 它会等待 直到信号量有个非零值才会执行减法操作
如果对值为0的信号量用sem_wait 这个函数会等待 直到其他线程增加该信号量的值 使其不再是0为止
如果对值为2的信号量调用sem_wait 线程会继续执行 但信号量的值会减一。
如果两个线程同时在sem_wait调用上等待同一个信号量变为非0值 那么当信号量 被第三个线程 1 只有一个等待线程开始对信号量-1
然后继续执行 另一个线程还继续等待。

  • sem_post函数

#include <semaphore.h>

int sem_post(sem_t *sem);

功能:把 计数器 1

  程序2-1介绍信号量使用

#include"my.h"

sem_t s;

void *fun(void *p)
{
    int i;
    int *pa = (int *)p;
    for(i=0;i<4;i  )
    {
        sem_wait(&s);//将计数器的值-1 
        pa[i]  =i;
    }
    for(i=0;i<4;i  )
    {
        printf("%-02d",pa[i]);
    }
    printf("n");
    return  NULL;
}

void *fun1(void *p)
{
    sem_wait(&s);//将计数器的值-1 
    puts("fun1 run!");
    return NULL;
}

int main()
{
    int i=0,ret=0;
    int a[5]={0};
    sem_init(&s,0,0);//设置信号量的值为0
    pthread_t tid[2];
    ret = pthread_create(&tid[0],NULL,fun,a);
    if(ret<0)
    {
        perror("pthread_create");
        exit(-1);
    }
    ret = pthread_create(&tid[1],NULL,fun1,a);
    if(ret<0)
    {
        perror("pthread_create");
        exit(-1);
    }

    for(i=0;i<5;i  )
    {
        sem_post(&s);//将计数器的值 1  
    }

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

运行演示如下图:

图片 1

上锁:

1. 户级线程   

  用户级线程主要解决的是上下文切换的问题,它的调度算法和调度过程全部由用户自行选择决定,在运行时不需要特定的内核支持。在这里,操作系统往往会提供一个用户空间的线程库,该线程库提供了线程的创建、调度、撤销等功能,而内核仍然仅对进程进行管理。如果一个进程中的某一个线程调用了一个阻塞的系统调用,那么该进程包括该进程中的其他所有线程也同时被阻塞。这种用户级线程的主要缺点是在一个进程中的多个线程的调度中无法发挥多处理器的优势。

  1、互斥锁相关函数

pthread_mutex_t m;

pthread_mutex_init(&m,NULL) //初始化互斥量
pthread_mutex_lock(&m);//对一个互斥量加锁 如果互斥量已经加锁 函数会一直等待 等到有线程把这个互斥量解锁后 再去加锁
pthread_mutex_unlock(&m);//对一个互斥量解锁 哪个线程加锁只能由这个线程解锁 别的线程不能 解锁

  程序3-1演示互斥锁应用:

#include"my.h"

pthread_mutex_t m;

void* thread_fun(void  *p)
{
    int i;
    pthread_mutex_lock(&m);//加锁
    for(i=0;i<3;i  )
    {
        printf("PID:%d tid:%lun",getpid(),pthread_self());
        sleep(1);
    }
    pthread_mutex_unlock(&m);//解锁
    pthread_exit(NULL);
}

int main()
{
    pthread_mutex_init(&m,NULL);//初始化锁
    int i,ret;
    pthread_t tid[3];
    for(i=0;i<3;i  )
    {
        ret = pthread_create(&tid[i],NULL,thread_fun,NULL);
        if(ret<0)
        {
            printf("pthread_create  %d errorn",i);
            exit(-1);
        }
    }



    for(i=0;i<3;i  )
    {
        pthread_join(tid[i],NULL);
    }
    return 0;
}

  运行演示如下图:

图片 2

总结:主要介绍线程同步的信号量和互斥锁,以后有时间将更加详细介绍其中实现原理。

  

 

线程按照其调度者可以分为用户级线程和核心级线程两种。

  一、线程

  通常在一个进程中可以包含若干个线程,当然一个进程中至少有一个线程,不然没有存在的意义。线程可以利用进程所拥有的资源,在引入线程的操作系统中,通常都是把进程作为分配资源的基本单位,而把线程作为独立运行和独立调度的基本单位,由于线程比进程更小,基本上不拥有系统资源,故对它的调度所付出的开销就会小得多,能更高效的提高系统多个程序间并发执行的程度。

 

pthread_create 线程创建函数

int pthread_create (pthread_t * thread_id,__const pthread_attr_t * __attr,void *(*__start_routine) (void *),void *__restrict __arg);

线程创建函数:

  第一个参数为指向线程标识符的指针,

  第二个参数用来设置线程属性,

  第三个参数是线程运行函数的起始地址,

  最后一个参数是运行函数的参数。

  这里,我们的函数thread 不需要参数,所以最后一个参数设为空指针。第二个参数我们也设为空指针,这样将生成默认属性的线程。当创建线程成功时,函数返回0,若不为0 则说明创建线程失败,常见的错误返回代码为EAGAIN 和EINVAL。前者表示系统限制创建新的线程,例如线程数目过多了;后者表示第二个参数代表的线程属性值非法。创建线程成功后,新创建的线程则运行参数三和参数四确定的函数,原来的线程则继续运行下一行代码。

  1、线程相关函数 

  • pthread_create函数

#include <pthread.h>

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
void *(*start_routine) (void *), void *arg);

注:Compile and link with -pthread.//编译时 要加-lpthread
功能:创建线程
参数1:线程的ID
参数2:NULL
参数3:线程处理函数
参数4: 传递给线程处理函数的参数
成功放回0 失败返回-1

  • pthread_join函数

#include <pthread.h>

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

功能:以阻塞的方式等待指定线程 主线程如果执行到此函数 将阻塞等待子线程结束

  程序1-1演示两个函数用法:

#include"my.h"

void *func(void *p) 
{
    *(int*)p = 10; 
    printf("%dn",*(int *)p);
}

int main()
{
    int x=100;
    pthread_t id; 
    int ret = pthread_create(&id,NULL,func,&x);
    if(ret<0)
    {   
        perror("pthread_create");
        exit(-1);
    }   
    pthread_join(id,NULL);
    return 0;

}

注:头文件“my.h”为自定义文件,详情请参考这篇博客:  

运行演示如下图:

图片 3

sem_wait(&empty); //缓冲区若有空闲空间,放数据,否则阻塞

2. 核心级线程   

  这种线程允许不同进程中的线程按照同一相对优先调度方法进行调度,这样就可以发挥多处理器的并发优势。
  现在大多数系统都采用用户级线程与核心级线程并存的方法。一个用户级线程可以对应一个或几个核心级线程,也就是“一对一”或“多对一”模型。这样既可满足多处理机系统的需要,也可以最大限度地减少调度开销。

  Linux的线程实现是在核外进行的,核内提供的是创建进程的接口do_fork()。内核提供了两个系统调用clone()和fork(),最终都用不同的参数调用do_fork()核内API。当然,要想实现线程,没有核心对多进程(其实是轻量级进程)共享数据段的支持是不行的,因此,do_fork()提供了很多参数,包括CLONE_VM(共享内存空间)、CLONE_FS(共享文件系统信息)、 CLONE_FILES(共享文件描述符表)、CLONE_SIGHAND(共享信号句柄表)和CLONE_PID(共享进程ID,仅对核内进程,即0号进程有效)。当使用fork系统调用时,内核调用do_fork()不使用任何共享属性,进程拥有独立的运行环境,而使用 pthread_create()来创建线程时,则最终设置了所有这些属性来调用__clone(),而这些参数又全部传给核内的do_fork(),从而创建的“进程”拥有共享的运行环境,只有栈是独立的,由__clone()传入。

  Linux线程在核内是以轻量级进程的形式存在的,拥有独立的进程表项,而所有的创建、同步、删除等操作都在核外pthread库中进行。pthread 库使用一个管理线程(__pthread_manager(),每个进程独立且唯一)来管理线程的创建和终止,为线程分配线程ID,发送线程相关的信号(比如Cancel),而主线程(pthread_create())的调用者则通过管道将请求信息传给管理线程。

主要函数说明

  但是现在我觉得一个比喻回答的更好:程序就像静止的火车,进程是运行的火车,线程是运行火车的每节车厢。

 

pthread_join 函数,来等待一个线程的结束

函数原型为:int pthread_join (pthread_t __th, void **__thread_return)
第一个参数为被等待的线程标识符,第二个参数为一个用户定义的指针,它可以用来存储被等待线程的返回值。这个函数是一个线程阻塞的函数,调用它的函数将一直等待到被等待的线程结束为止,当函数返回时,被等待线程的资源被收回。线程只能被一个线程等待终止,并且应处于joinable状态(非detached)。

个人感觉理解远比背些概念性东西更好。

pthread_join(consumerTd,NULL);

pthread_exit 函数

一个线程的结束有两种途径,一种是线程运行的函数结束了,调用它的线程也就结束了;另一种方式是通过函数pthread_exit 来实现。

它的函数原型为:void pthread_exit (void *__retval)唯一的参数是函数的返回代码,只要pthread_join 中的第二个参数thread_return 不是NULL,这个值将被传递给thread_return。最后要说明的是,一个线程不能被多个线程等待,否则第一个接收到信号的线程成功返回,其余调用pthread_join 的线程则返回错误代码ESRCH。

  二、信号量

  信号量(Semaphore),有时被称为信号灯,是在多线程环境下使用的一种设施, 它负责协调各个线程, 以保证它们能够正确、合理的使用公共资源。

}

buffer.erase(iter);

#define MAX_SIZE 100

第三个参数是线程运行函数的起始地址 

sem_wait( sem_t *sem ),表示等待信号量,若该信号量不可获取,则阻塞,解除阻塞后将sem的值减一,表明公共资源经使用后减少。

信号量的数据类型为结构sem_t,它本质上是一个长整型的数。

 

{

这个函数是一个线程阻塞的函数,调用它的函数将一直等待到线程结束为止,当函数返回时,被等待线程的资源被收回。如果执行成功,将返回0,如果失败则返回一个错误号。

pthread_t consumerTd;

这是第一次在VI下写linux的程序,和VS2005 VISUAL ASSIST相比,没有高亮,没有智能提示,用VI好痛苦~

pshared参数控制着信号量的类型, pshared的值若为0,表示是进程内共享信号量;否则,进程间可共享该信号量。

                        sem_post(&empty);

 

 

linux下生产者消费者_多线程演示程序

sem_wait(&full); //缓冲区有数据,取数据,否则阻塞

 

基本API介绍 线程 线程创建: int pthread_create(pthread *thread, pthread_attr_t *attr, void* (*start_routine)(*void), void*...

sem_destroy(&empty);

该函数以动态方式创建互斥锁的,参数attr指定了新建互斥锁的属性。如果参数attr为空,则使用默认的互斥锁属性,默认属性为快速互斥锁 。互斥锁的属性在创建锁的时候指定,在LinuxThreads实现中仅有一个锁类型属性,不同的锁类型在试图对一个已经被锁定的互斥锁加锁时表现不同。成功完成之后会返回零,其他任何返回值都表示出现了错误。

}

sleep(0.02);

sem_init(&empty, 0, MAX_SIZE);

 

 

 

void* consumer(void*)    //消费者

 

基本API介绍

sleep(0.05);

while(nMsgCount < MAX_SIZE) 

sem_destroy(&full);

初始化:

#include <iostream> 

 

 

sem_post(&full);

第四个参数是运行函数的参数。 其中pthread_attr_t*和void* arg可设置为NULL;

对由sem指定的信号量进行初始化,设置好它的共享选项,并指定一个整数类型的初始值。

#include <pthread.h>

cout<<"consumer: "<<value<<endl;

        www.2cto.com  

pthread_mutex_init(&mutex,NULL);

 

 

释放互斥锁,与pthread_mutex_lock成对存在。

 

vector<int>::iterator iter = buffer.begin();

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

pthread_mutex_unlock(&mutex);

 

{

第一个参数为被等待的线程标识符,

int value = *iter;

vector<int> buffer; //共享数据缓冲区

        //互斥量、信号量初始化

上代码:

 

buffer.push_back(i);

 

return 0;

void* producer(void*)    //生产者

int nMsgCount = 0;

sleep(100);

};  www.2cto.com  

int nProducerId = pthread_create(&producerTd, NULL, producer, NULL);

  www.2cto.com  

第二个参数用来设置线程属性。 

int main()

sem_post( sem_t *sem )用来增加信号量的值。当有线程阻塞在这个信号量上时,调用这个函数可唤醒被阻塞的线程。

                {

                        pthread_mutex_lock(&mutex);

}

{

}

for (int i = 0; i < MAX_SIZE; i )

函数: int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr);

线程创建: 

结果演示

pthread_mutex_unlock(&mutex);

 

        //创建线程

 

图片 4

sem_init(&full, 0, 0);

 

 

sem_t full; //缓冲区有有数据信号量

#include <stdio.h>

 返回值:在成功完成之后会返回零。其他任何返回值表示出现错误。如果出现以下任一情况,该函数将失败并返回对应的值。

pthread_join(producerTd,NULL);

线程

cout<<"producer: "<<i<<endl;

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

int pthread_mutex_lock(pthread_mutex_t *mutex);

int nConusmerId = pthread_create(&consumerTd, NULL, consumer, NULL);

 解锁:

int pthread_create(pthread *thread, pthread_attr_t *attr, void* (*start_routine)(*void), void* arg);   

第一个参数为指向线程 

{

pthread_mutex_t mutex;        //缓冲区访问互斥量

sem_destroy(sem_t *sem)用来释放信号量sem。

作者 西昆仑

 

#include <vector>

pthread_mutex_lock(&mutex);

函数sem_init()用来初始化一个信号量。

 

信号量  www.2cto.com  

        //相关资源销毁

using namespace std;

#include <semaphore.h>

 

nMsgCount ;

第二个参数为一个用户自定义指针,用来存储被等待线程的返回值。

pthread_t producerTd;

 

本文由分分快三计划发布,转载请注明来源

关键词: linux 线程