pthread_mutex_initializer-100

Linux 线程同步有哪些方法？

有两种方法创建互斥锁，静态方式和动态方式。POSIX定义了一个宏PTHREAD_MUTEX_INITIALIZER来静态初始化互斥锁，方法如下： pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER; 在LinuxThreads实现中，pthread_mutex_t是一个结构，而PTHREAD_MUTEX_INITIALIZER则是一个结构常量。

怎样用C++实现生产者消费者的模拟

Linux系统中，实现线程同步的方式大致分为六种，其中包括：互斥锁、自旋锁、信号量、条件变量、读写锁、屏障。最常用的线程同步方式就是互斥锁、自旋锁、信号量：

1、互斥锁

互斥锁本质就是一个特殊的全局变量，拥有lock和unlock两种状态，unlock的互斥锁可以由某个线程获得，当互斥锁由某个线程持有后，这个互斥锁会锁上变成lock状态，此后只有该线程有权力打开该锁，其他想要获得该互斥锁的线程都会阻塞，直到互斥锁被解锁。

互斥锁的类型：

①普通锁：互斥锁默认类型。当一个线程对一个普通锁加锁以后，其余请求该锁的线程将形成一个等待队列，并在锁解锁后按照优先级获得它，这种锁类型保证了资源分配的公平性。一个线程如果对一个已经加锁的普通锁再次加锁，将引发死锁;对一个已经被其他线程加锁的普通锁解锁，或者对一个已经解锁的普通锁再次解锁，将导致不可预期的后果。

②检错锁：一个线程如果对一个已经加锁的检错锁再次加锁，则加锁操作返回EDEADLK;对一个已经被其他线程加锁的检错锁解锁或者对一个已经解锁的检错锁再次解锁，则解锁操作返回EPERM。

③嵌套锁：该锁允许一个线程在释放锁之前多次对它加锁而不发生死锁;其他线程要获得这个锁，则当前锁的拥有者必须执行多次解锁操作;对一个已经被其他线程加锁的嵌套锁解锁，或者对一个已经解锁的嵌套锁再次解锁，则解锁操作返回EPERM。

④默认锁：一个线程如果对一个已经解锁的默认锁再次加锁，或者对一个已经被其他线程加锁的默认锁解锁，或者对一个解锁的默认锁解锁，将导致不可预期的后果;这种锁实现的时候可能被映射成上述三种锁之一。

【老男孩教育】Linux运维云计算课程汇集了虚拟化、云计算、安全攻防、Python开发、SRE等技术，课堂效率高、内容丰富全面，由浅入深，循序渐进，帮助学员稳扎稳打，夯实基础，在有限的时间内帮助学员高效提升，成为符合企业需求的技术型人才。

2、自旋锁

自旋锁顾名思义就是一个死循环，不停的轮询，当一个线程未获得自旋锁时，不会像互斥锁一样进入阻塞休眠状态，而是不停的轮询获取锁，如果自旋锁能够很快被释放，那么性能就会很高，如果自旋锁长时间不能够被释放，甚至里面还有大量的IO阻塞，就会导致其他获取锁的线程一直空轮询，导致CPU使用率达到100%，特别CPU时间。

3、信号量

信号量是一个计数器，用于控制访问有限共享资源的线程数。

如何使用pthread

// producer_consumer.cpp。

//////////////////////////////////////////////////////////////////////。

// 有一个生产者在生产产品，这些产品将提供给若干个消费者去消费，为了使生产者和消费者能并发执行，

// 在两者之间设置一个有多个缓冲区的缓冲池，生产者将它生产的产品放入一个缓冲区中，消费者可以从缓。

// 冲区中取走产品进行消费，所有生产者和消费者都是异步方式运行的，但它们必须保持同步，即不允许消。

// 费者到一个空的缓冲区中取产品，也不允许生产者向一个已经装满产品且尚未被取走的缓冲区中投放产品。

//////////////////////////////////////////////////////////////////////。

#include <pthread.h>。

#include <stdio.h>。

#include <stdlib.h>。

#include <unistd.h>。

const int BUFFER_LENGTH = 100;。

int buffer[BUFFER_LENGTH];。

int front = 0, rear = -1; // 缓冲区的前端和尾端。

int size = 0;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;。

pthread_cond_t cond = PTHREAD_COND_INITIALIZER;。

void *producer(void *arg);。

void *consumer(void *arg);。

int main(int argc, char **argv)。

    pthread_t producer_id;。

    pthread_t consumer_id;。

    pthread_create(&producer_id, NULL, producer, NULL);。

    

    pthread_create(&consumer_id, NULL, consumer, NULL);。

    

//主线程运行结束，子线程也就运行结束了。

//http://bbs.chinaunix.net/thread-1286290-1-1.html。

    sleep(1);

    return 0;

void *producer(void *arg)。

{    

   //pthread_detach(threadid)函数的功能是使线程ID为threadid的线程处于分离状态，一旦线程处于分离状态，

  //该线程终止时底 层资源立即被回收；否则终止子线程的状态会一直保存（占用系统资源）直到主线程调用pthread_join(threadid,NULL)获取线程的退 出状态。

  //通常是主线程使用pthread_create()创建子线程以后，一般可以调用pthread_detach(threadid)分离刚刚创建的子线程，

 

  //这里的threadid是指子线程的threadid；如此以来，该子线程止时底层资源立即被回收；

  //被创建的子线程也可以自己分离自己，子线程调用pthread_detach(pthread_self())就是分离自己，

 //因为pthread_self()这个函数返回的就是自己本身的线程ID；

    pthread_detach(pthread_self());。

    

    while (true)。

    {

        pthread_mutex_lock(&mutex);。

        while (size == BUFFER_LENGTH) // 如果缓冲区已满，等待; 否则，添加新产品。

        {

            printf("buffer is full. producer is waiting...\n");。

            pthread_cond_wait(&cond, &mutex);。

        }

        // 往尾端添加一个产品。

        rear = (rear + 1) % BUFFER_LENGTH;。

        buffer[rear] = rand() % BUFFER_LENGTH;。

        printf("producer produces the item %d: %d\n", rear, buffer[rear]);。

        ++size;。

        if (size == 1) // 如果当前size=1, 说明以前size=0, 消费者在等待，则给消费者发信号。

        {

           pthread_cond_signal(&cond);。

        }

        pthread_mutex_unlock(&mutex);。

    }

void *consumer(void *arg)。

    pthread_detach(pthread_self());。

    

    while (true)。

    {

        pthread_mutex_lock(&mutex);。

        while(size == 0) // 如果缓冲区已空，等待; 否则，消费产品。

        {

            printf("buffer is empty. consumer is waiting...\n");。

            pthread_cond_wait(&cond, &mutex);。

        }

        // 从前端消费一个产品。

        printf("consumer consumes an item%d: %d\n", front, buffer[front]);。

        front = (front + 1) % BUFFER_LENGTH;。

        --size;。

        if (size == BUFFER_LENGTH-1) // 如果当前size=BUFFER_LENGTH-1，说明以前生产者在等待，则给生产者发信号。

        {

            pthread_cond_signal(&cond);。

        }

        pthread_mutex_unlock(&mutex);。

    }

linux下互斥锁mutex，貌似锁不上呢

一 概述

Pthread是一套通用的线程库, 它广泛的被各种Unix所支持, 是由POSIX提出的. 因此, 它具有很好的可移植性. 。

例1:

/* ------ test.c ------- */。

#include <pthread.h>。

void *pp(void *arg)。

printf("%s\n", (char *)arg);。

sleep(2);

return NULL;

main()

printf("I am main thread\n");。

sleep(1);

执行：

gcc test.c -lpthread。

./a.out

输出：

I am main thread。

hello world

I am main thread。

hello world

............

二 返回值

也应该看到了, 每一个线程的返回值是void *.。

有两种方法返回:

1 return pointer;。

2 pthread_exit(pointer);。

这两种方法是一样的.

那么, 其他的线程是如何得到这个返回值的呢?。

用这个函数:

int pthread_join(pthread_t TH, void **thread_RETURN);。

一个线程有两种状态, joinable 即系统保留线程的返回值, 直到有另外一个线程将它取走. detach系统不保留返回值.。

下面的函数用于detach:

int pthread_detach (pthread_t TH);。

pthread_t pthread_self(); 可以返回自己的id. 通常, 我们用下列的语句来detach自己:。

pthread_detach(pthread_self());。

三 Mutex

Mutex用于解决互斥问题. 一个Mutex是一个互斥装置, 用于保护临界区和共享内存. 它有两种状态locked, unlocked. 它不能同时被两个线程所拥有.。

下面的函数用于处理Mutex:。

初始化一个Mutex

int pthread_mutex_init (pthread_mutex_t *MUTEX, const pthread_mutexattr_t *MUTEXATTR);。

锁定一个Mutex

int pthread_mutex_lock (pthread_mutex_t *mutex));。

试图锁定一个Mutex

int pthread_mutex_trylock (pthread_mutex_t *MUTEX);。

结锁一个Mutex

int pthread_mutex_unlock (pthread_mutex_t *MUTEX);。

销毁一个Mutext

int pthread_mutex_destroy (pthread_mutex_t *MUTEX);。

它的锁一共有三种: "fast", "recursive", or "error checking"。

进行lock操作时:

如处于unlock状态, lock它, 即排斥占有。

在被其他线程lock的时候,

挂起当前线程, 直到被其他线程unlock。

在已经被自己lock的时候,

"fast" 挂起当前线程.

"resursive" 成功并立刻返回当前被锁定的次数。

"error checking" 立刻返回EDEADLK。

进行unlock操作时:

解锁.

"fast" 唤醒第一个被锁定的线程。

"recursive" 减少lock数(这个数仅仅是被自己lock的, 不关其它线程的) 当lock数等于零的。

时候, 才被unlock并唤醒第一个被锁定的线程.。

"error check" 会检查是不是自己lock的, 如果不是返回EPERM. 如果是唤 醒第一个被锁定的线程,。

通常, 我们用一些静态变量来初始化mutex.。

"fast" `PTHREAD_MUTEX_INITIALIZER'。

"recursive" `PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP'。

"error check" `PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP'。

注意: _NP 表示no portable不可移植。

例如:

// "fast" type mutex。

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;。

... ...

pthread_mutext_lock(&mutex);。

fwrite(buffer, 1, strlen(buffer), file);。

pthread_mutex_unlock(&mutex);。

... ...

四 Condition Variable (条件变量) 。

也是一种用于同步的device. 允许一个进程将自己挂起等待一个条件变量被改变状态.。

有下列几个函数:

int pthread_cond_init (pthread_cond_t *COND,pthread_condattr_t *cond_ATTR);。

int pthread_cond_signal (pthread_cond_t *COND);。

int pthread_cond_broadcast (pthread_cond_t *COND);。

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

int pthread_cond_destroy (pthread_cond_t *COND);。

我想看看名字就可以知道它们的用途了. 通常我们也使用静态变量来初始化一个条件变量.。

Example:

pthread_cond_t cond = PTHREAD_COND_INITIALIZER;。

pthread_cond_signal 用于唤醒一个被锁定的线程.。

pthread_cond_broadcast 用于唤醒所有被锁定的线程.。

pthread_cond_wait 用于等待.。

为了解决竞争问题(即一个线程刚要去wait而另一个线程已经signal了), 它要与一个mutex连用.。

看一看下面的例子:

int x,y;

pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;。

pthread_cond_t cond = PTHREAD_COND_INITIALIZER;。

//Waiting until X is greater than Y is performed as follows:。

pthread_mutex_lock(&mut);。

/**//* operate on x and y */。

pthread_mutex_unlock(&mut);。

pthread_cond_wait的执行过程如下:。

1. 首先, 它unlock the mutex, then 挂起当前的线程.。

2. 当被唤醒的时候, 它会lock the mutex.。

这样就保证了这是一个临界区.

五 Thread-Specific Data (TSD)。

说白了就是线程中使用的静态变量. 大家可以很容易的理解为什么使用静态变量函数不是线程安全的(也就是它们一定要很小心的在线程中使用).。

而使用静态变量又是很方便的, 这就产生了 thread-specific data. 可以把它理解为一个指针数组, 但对于每个线程来说是唯一的. 。

Example:

int func()

char *p;

p = strdup(thread-specific-data[1]);。

... ...

void *pthread-1(void *arg)。

... ...

func()

... ...

void *pthread-2(void *arg)。

... ...

func()

... ...

不同的线程调用func产生的结果是不同的. 这只是个例子.。

int pthread_key_create(pthread_key_t *KEY, void (*destr_function) (void *));。

int pthread_key_delete(pthread_key_t KEY);。

int pthread_setspecific(pthread_key_t KEY, const void *POINTER);。

void * pthread_getspecific(pthread_key_t KEY);。

TSD可以看成是一个void *的数组. 。

注意: pthread_key_delete只是释放key占用的空间, 你仍然需要释放那个void *.。

为了加深你的理解, 看一看下面的例子吧:。

/* Key for the thread-specific buffer */。

static pthread_key_t buffer_key;。

/* Once-only initialisation of the key */。

static pthread_once_t buffer_key_once = PTHREAD_ONCE_INIT;。

pthread_once(&buffer_key_once, buffer_key_alloc);。

pthread_setspecific(buffer_key, malloc(100));。

return (char *) pthread_getspecific(buffer_key);。

pthread_key_create(&buffer_key, buffer_destroy);。

free(buf);

C语言 struct timeval timeout = ..; 是什么意思啊？

多线程的效果就是同一时间各个线程都在执行。

加锁不是给线程上锁。

pthread_mutex_lock(&qlock);表示尝试去把qlock上锁，它会先判断qlock是否已经上锁，如果已经上锁这个线程就会停在这一步直到其他线程把锁解开。它才继续运行。

所以代码中要么是线程1先执行完后执行线程2，要么就是线程2先执行，再执行线程1.而线程3一开始就执行了。

互斥量mutex是用来给多线程之间的贡献资源上锁的。也就是同一个时间只允许一个线程去访问该资源（资源：比如对文件的写操作）。

现在来回答楼主的问题：

不是只要在pthread_mutex_lock(&qlock)与pthread_mutex_unlock(&qlock)之间的代码执行，其他的都不能介入吗？

其他的都不能介入，不是整个进程只运行这一个线程，其他线程都停住了。

“不能介入“这个动作需要程序员自己设计来保证：好比前面提到的文件读写操作。为了防止多个线程同时对文件进行写入操作，这就需要把资源上锁了。

如果只有线程1加锁，那是不是这个锁就没有意义了呢？

这个理解可以有

原文地址：http://www.qianchusai.com/pthread_mutex_initializer-100.html