线程的互斥锁

一、竞争与同步
当多个线程同时访问其所共享的进程资源时，需要相互协调，以防止出现数据不一致、不完整的问题。这就叫线程同步。

二、互斥量

int pthread_mutex_init (pthread_mutex_t* mutex,const pthread_mutexattr_t* mutexattr);
功能：初始化互斥量
//亦可 pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
?
int pthread_mutex_lock (pthread_mutex_t* mutex);
功能：加锁
?
int pthread_mutex_unlock (pthread_mutex_t* mutex);
功能：解锁
?
int pthread_mutex_destroy (pthread_mutex_t* mutex);
功能：销毁互斥量

1) 互斥量被初始化为非锁定状态；
2) 线程1调用pthread_mutex_lock函数，立即返回，互斥量呈锁定状态；
3) 线程2调用pthread_mutex_lock函数，阻塞等待；
4) 线程1调用pthread_mutex_unlock函数，互斥量呈非锁定状态；
5) 线程2被唤醒，从pthread_mutex_lock函数中返回，互斥量呈锁定状态；

三、信号量
信号量是一个计数器，用于控制访问有限共享资源的线程数。
注意：线程使用的信号量不在pthread.h中，而是semaphore.h

// 创建信号量
int sem_init (sem_t* sem, int pshared,unsigned int value);

　sem           信号量ID，输出。
?pshared 　　一般取0，表示调用进程的信号量。非0表示该信号量可以共享内存的方式，为多个进程所共享(Linux暂不支持)。
　value 　　 信号量初值。
?
// 信号量减1，不够减即阻塞
int sem_wait (sem_t* sem);
?
// 信号量减1，不够减即返回-1，errno为EAGAIN
int sem_trywait (sem_t* sem);
?
// 信号量减1，不够减即阻塞，直到abs_timeout超时返回-1，errno为ETIMEDOUT

int sem_timedwait (sem_t* sem,const struct timespec* abs_timeout);
struct timespec {
    time_t tv_sec;  // Seconds
    long   tv_nsec; // Nanoseconds [0 - 999999999]
};
?
// 信号量加1
int sem_post (sem_t* sem);
?
// 销毁信号量
int sem_destroy (sem_t* sem);

//简单的图书借阅小程序
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <semaphore.h>
#include <stdlib.h>
#include <time.h>

sem_t sem;
void* fun(void* arg)
{
    pthread_t tid = pthread_self();
    int* sec = arg;
    printf("请等待(%lu)...\n",tid);
    sem_wait(&sem);
    printf("借阅成功(%lu),正在读书,读书时间为:%d秒\n",tid,*sec);
    sleep(*sec);
    sem_post(&sem);
    printf("还书成功(%lu)!\n",tid);

}

int main()
{
    srand((int)time(NULL));
    pthread_t thread;
    sem_init(&sem,0,5);

    for(int i=0; i<20; i++)
    {
        int time = rand()%10;
        int ret = pthread_create(&thread,NULL,fun,&time);
        if(ret < 0)
        {
            perror("pthread_create");
            return -1;
        }
        sleep(1);
    }

    sem_destroy(&sem);
    while(1);        //主线程不结束

}

四、生产者与消费者模型
一线程负责生产数据，另一部分线程负责消费数据。
问题1：如何生产的快、消费的慢，生产者容易撑死
问题2：如果生产的慢、消费的快，消费者容易饿死
只有把问题1、和问题2协调好，才能最大限度的提高效率。

生产者快－>数据池满－>生产者暂停－>消费者全部开始消费－>数据池空－>消费者暂停－>生产者全部开始生产

五、条件变量
条件变量可以让调用线程在满足特定条件的情况下暂停。

//初始化条件变量
int pthread_cond_init (pthread_cond_t* cond,const pthread_condattr_t* attr);
//亦可pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
?
// 使调用线程睡入条件变量cond，同时释放互斥锁mutex
int pthread_cond_wait (pthread_cond_t* cond,pthread_mutex_t* mutex);
?
// 使调用线程睡入条件变量cond,同时释放互斥锁mutex，并在时间到了之后即使没有被唤醒，也醒过来
int pthread_cond_timedwait (pthread_cond_t* cond,
    pthread_mutex_t* mutex,
    const struct timespec* abstime);
?
struct timespec {
    time_t tv_sec;  // Seconds
    long   tv_nsec; // Nanoseconds [0 - 999999999]
};
?
// 从条件变量cond中唤出一个线程，令其重新获得原先的互斥锁
int pthread_cond_signal (pthread_cond_t* cond);
注意：被唤出的线程此刻将从pthread_cond_wait函数中返回，
但如果该线程无法获得原先的锁，则会继续阻塞在加锁上。
?
// 从条件变量cond中唤出所有线程
int pthread_cond_broadcast (pthread_cond_t* cond);
?
// 销毁条件变量
int pthread_cond_destroy (pthread_cond_t* cond);

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

#define MAX 20

char storage[MAX] = {};
int count = 0;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t full = PTHREAD_COND_INITIALIZER;
pthread_cond_t empty = PTHREAD_COND_INITIALIZER;

void show_storage(char* role,char* op,char prod)
{
    printf("%s:",role);
    for(int i=0; i<count; i++)
    {
        printf("%c",storage[i]);
    }
    printf("%s%c\n",op,prod);
}

void* pro_run(void* arg)
{
    char* who = "生产者";
    while(1)
    {
        pthread_mutex_lock(&mutex);
        while(count >= MAX)
        {
            printf("%s:满仓\n",who);
            pthread_cond_wait(&full,&mutex);
        }

        char prod = ‘A‘+rand()%26;
        storage[count++] = prod;

        show_storage(who,"->",prod);

        pthread_cond_signal(&empty);
        pthread_mutex_unlock(&mutex);

        usleep(rand()%100*1000);
    }
}

void* con_run(void* arg)
{
    char* who = "消费者";
    while(1)
    {
        pthread_mutex_lock(&mutex);
        while(count <= 0)
        {
            printf("%s:空仓\n",who);
            pthread_cond_wait(&empty,&mutex);
        }

        char prod = storage[count--];

        show_storage(who,"<-",prod);

        pthread_cond_signal(&full);
        pthread_mutex_unlock(&mutex);

        usleep(rand()%100*1000);
    }
}

int main()
{
    pthread_t tid1,tid2;
    pthread_create(&tid1,NULL,pro_run,NULL);
    pthread_create(&tid2,NULL,con_run,NULL);
    getchar();
}

原文地址：https://www.cnblogs.com/xiehuan-blog/p/9687984.html

时间： 2024-07-31 07:10:43

线程的互斥锁的相关文章

线程的互斥锁和条件变量通信机制

1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <time.h> 4 #include <pthread.h> 5 6 #define BUFFER_SIZE 2 7 struct prodcons 8 { 9 int buffer[BUFFER_SIZE]; 10 pthread_mutex_t lock; 11 int readpos,writepos; 12 pthread_cond_t no

Linux线程同步---互斥锁

线程中互斥锁使用的步骤与信号量相似! 1.首先定义互斥锁变量,并初始化 pthread_mutex_t mutex_lock;pthread_mutex_init(&mutex_lock,NULL);2.在操作前对互斥量进行加锁操作 pthread_mutex_lock(&mutex_lock);3.操作完毕后进行解锁操作 pthread_mutex_unlock(&mutex_lock); 所有操作均在加锁和解锁操作之间进行,保证同时仅仅对有一个操作对关键变量或是区域进行操作.

喜羊羊系列之【 线程 】互斥锁+信号量

1. 编写一个基本的多线程程序(主线程里面创建一个子线程) /************************************************************************* > File Name: 1_homework.c > Author: 梁惠涌 > Addr: > Created Time: 2015年04月22日 星期三 15时22分34秒 ************************************************

转发 ：java线程：互斥锁与读写锁

原文链接:http://coolxing.iteye.com/blog/1236909 两种互斥锁机制: 1.synchronized 2.ReentrantLock ReentrantLock是jdk5的新特性,采用ReentrantLock可以完全替代替换synchronized传统的锁机制,而且采用ReentrantLock的方式更加面向对象,也更加灵活,网上有很多关于对比两者锁方式的文章,这里就不多口舌了,大家baidu.google一下就水落石出了.在本博客中也写关于这两种锁方式实现的

Linux 线程编程2.0——线程同步-互斥锁

当我们需要控制对共享资源的存取的时候,可以用一种简单的加锁的方法来控制.我们可以创建一个读/写程序,它们共用一个共享缓冲区,使用互斥锁来控制对缓冲区的存取. 函数 pthread_mutex_init()用来生成一个互斥锁.其函数原型如下: #include<pthread.h> int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr): 第一个参数是互斥变量

第9章 线程编程（4）_线程同步1：互斥锁

5. 线程的互斥和同步 5.1 同步和互斥的概念 (1)线程同步:是一个宏观概念,在微观上包含线程的相互排斥和线程的先后执行的约束问题.解决同步方式一般采用条件变量和信号量. (2)线程互斥:线程执行的相互排斥(注意,它不关心线程间执行的先后顺序!).解决互斥一般使用互斥锁.读写锁和信号量. [编程实验]银行ATM(线程不安全的例子) //account.h #ifndef __ACCOUNT_H__ #define __ACCOUNT_H__ typedef struct { int code

线程通信（一）&mdash;&mdash; 互斥锁

在使用线程时,经常要注意的就是访问临界资源加锁. 在编码过程由于粗心忘记加锁将带来不可预知的错误.这类错误单次运行或小并发时难以复现,当数据量变大,用户数增多时,轻则系统崩溃,大则引起数据错误.造成损失. 线程中互斥锁与进程的信号量类似,也可以看做是PV操作,用于保护临界资源,确保只有一个线程访问. 下面代码是不加锁错误代码,其中也涉及到之前提到的线程编程时需要注意的一些小细节. 1 #include <pthread.h> 2 #include <unistd.h> 3 #inc

Java 线程锁机制 -Synchronized Lock 互斥锁 读写锁

synchronized 是互斥锁: lock 更广泛,包含了读写锁 读写锁特点: 1)多个读者可以同时进行读2)写者必须互斥(只允许一个写者写,也不能读者写者同时进行)3)写者优先于读者(一旦有写者,则后续读者必须等待,唤醒时优先考虑写者) 互斥锁特点: 一次只能一个线程拥有互斥锁,其他线程只有等待 所谓互斥锁, 指的是一次最多只能有一个线程持有的锁. 在jdk1.5之前, 我们通常使用synchronized机制控制多个线程对共享资源的访问. 而现在, Lock提供了比synchronize

Windows线程同步【3】互斥锁（Mutex）

我们前面讲过的临界区,如同一个小房间,张三进去了,李四就不能进,如果李四要进,必须等张三出来. 今天我们要讲的互斥锁,像一个物件,这个物件只能同时被一个线程持有.如此一来,便可以通过互斥锁来实现线程的同步. 一.创建 创建互斥锁的方法是调用函数CreateMutex: CreateMutex(&sa, bInitialOwner, szName); 第一个参数是一个指向SECURITY_ATTRIBUTES结构体的指针,一般的情况下,可以是nullptr. 第二个参数类型为BOOL,表示互斥锁创