unix系统编程day07--线程同步，进程同步

最新推荐文章于 2022-06-02 00:21:17 发布
最新推荐文章于 2022-06-02 00:21:17 发布
阅读量251 收藏 1
点赞数
分类专栏： unix系统编程 unix系统编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_38081836/article/details/87951428
版权

同步概念

线程同步

  • 理解：多个线程之间有序的执行。

数据混乱原因

  1. 资源共享（独享资源不会）
  2. 调度随机（意味着数据访问出现竞争）
  3. 缺乏合理的线程调度机制

互斥量mutex

pthread_mutex_t

解释：可以简单认为是一把锁，拥有0和1两个值，0为加锁状态，1为解锁状态

主要应用函数

pthread_mutex_init

  • 函数原型：int pthread_mutex_init(pthread_mutex_t *mutex,const pthread_mutexattr_t *attr)
  • 作用：初始化一个锁
  • 返回值：成功返回0，失败返回错误号

pthread_mutex_destroy

  • 函数原型：int pthread_mutex_destroy(pthread_mutex_t *mutex)
  • 作用：销毁一个锁
  • 返回值：成功返回0，失败返回错误号

pthread_mutex_lock

  • 函数原型：int pthread_mutex_lock(pthread_mutex_t *mutex)
  • 作用：给一个锁上锁
  • 返回值：成功返回0，失败返回错误号

pthread_mutex_unlock

  • 函数原型：int pthread_mutex_unlock(pthread_mutex_t *mutex)
  • 作用：给一个锁解锁
  • 返回值：成功返回0，失败返回错误号

pthread_mutex_trylock

  • 函数原型：int pthread_mutex_trylock(pthread_mutex_t *mutex);
  • 作用：查看一个锁是否为上锁状态
  • 返回值：未上锁返回0，否则返回错误号

死锁

两种造成死锁的方式

  1. 连续两次调用pthread_mutex_lock函数导致死锁，程序阻塞
  2. 线程A拥有A锁，请求B锁，但是线程B拥有B锁，请求A锁。

第二种死锁代码演示

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

pthread_mutex_t mutex1, mutex2;

void *t_fun(void * arg) {
    while(1) {
        pthread_mutex_lock(&mutex1);
        printf("hello ");
        sleep(2);
        pthread_mutex_lock(&mutex2);
        printf("world\n");
        sleep(1);
        pthread_mutex_unlock(&mutex1);
        pthread_mutex_unlock(&mutex2);
    }
}

int main(void) {
    pthread_mutex_init(&mutex1, NULL);
    pthread_mutex_init(&mutex2, NULL);
    pthread_t tid;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_create(&tid, &attr, t_fun, NULL);
    sleep(1);
    while(1) {
        pthread_mutex_lock(&mutex2);
        printf("World\n");
        sleep(1);
        pthread_mutex_lock(&mutex1);
        printf("Hello ");
    }
    pthread_attr_destroy(&attr);
    pthread_mutex_destroy(&mutex1);
    pthread_mutex_destroy(&mutex2);
    return 0;
}

如何解决死锁

  1. 加锁之前检查是否解锁
  2. 如果trylock失败，那么释放自己拥有的锁

读写锁

读写锁特性

写独占，读共享，写锁优先级高。
写锁独占，读锁可以共享，如果读写锁同时出现，写锁的优先级高于读锁

相关函数

pthread_rwlock_init

  • 具体参见manpages

pthread_rwlock_destroy

  • 具体参见manpages

pthread_rwlock_rdlock

  • 具体参见manpages

pthread_rwlock_wrlock

  • 具体参见manpages

pthread_rwlock_unlock

  • 具体参见manpages

pthread_rwlock_tryrdlock

  • 具体参见manpages

pthread_rwlock_trywrlock

  • 具体参见manpages

以上函数仿照mutex函数，并且成功返回0，失败返回错误号

条件变量

特性：条件变量本身不是锁！但它可以造成线程阻塞。通常和互斥锁配合，给多线程提供一个回合的场所。

条件变量

相关函数

pthread_cond_init

  • 具体参见manpages

pthread_cond_destroy

  • 具体参见manpages

pthread_cond_wait

  • 函数原型int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
  • 函数作用：
    1. 阻塞线程并等待cond条件满足，又带你想sigsuspend函数
    2. 解锁mutex
    3. 该函数被唤醒的时候返回，解除线程的阻塞，并重新获得mutex
      1.2.为原子操作，也就是说在调用该函数的时候两个操作同时完成
  • 返回值：成功返回0，失败返回错误号

pthread_cond_timedwait

  • 相对于_wait函数，timedwait多了最后一个参数
  • timespec *abstime结构体中有两个变量，一个是秒，一个是纳秒，这个时间是相对于Liunx元年（1970/1/1 0:0:0）来定义的，所以如果需要定时需要首先获取当前时间，然后+？（来设置多少秒的定时）
time_t cur = time(NULL)；
timespec t = {cur + 1, 0);//用来定时1s
pthread_cond_timedwait(&cond, &mutex, &t);

pthread_cond_signal

  • 函数原型：int pthread_cond_signal(pthread_cond_t *cond);
  • 函数作用：解除通过条件cond阻塞的线程
  • 返回值：成功返回0，失败返回错误号

pthread_cond_broadcast

  • 函数作用：解除通过条件cond阻塞的线程
  • 返回值：成功返回0，失败返回错误号

生产者消费者模型

模型简介

该模型为存在一个共享数据区，消费者去消耗共享数据区的内容，生产者去生产共享数据区的数据，生产者和消费者的线程之间要相互配合，通过条件变量实现线程同步。

代码实现模型

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

struct Message {
    Message * nex;
    int num;
};
Message *head, *tail;
pthread_mutex_t lock       = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t  has_product = PTHREAD_COND_INITIALIZER;

void * productor(void * arg) {
    while(1) {
        tail = (Message *)malloc(sizeof(Message));
        tail->num = rand() % 1000 + 1;
        printf("product num = %d\n", tail->num);
        pthread_mutex_lock(&lock);
        tail->nex = head;
        head = tail;
        pthread_mutex_unlock(&lock);

        pthread_cond_signal(&has_product);
        sleep(rand() % 5);
    }
    return NULL;
}

void * consumer(void * arg) {
    while(1) {
        pthread_mutex_lock(&lock);
        while(head == NULL) {
            pthread_cond_wait(&has_product, &lock);
        }
        Message * mp = head;
        head = head->nex;
        pthread_mutex_unlock(&lock);
        printf("Eat num = %d\n", mp->num);
        free(mp);
        sleep(rand() % 5);
    }
    return NULL;
}


int main(void) {
    pthread_t pid, cid;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
    pthread_create(&pid, &attr, productor, NULL);
    pthread_create(&cid, &attr, consumer, NULL);
    pthread_join(pid, NULL);
    pthread_join(cid, NULL);
    return 0;
}

信号量

强化版的互斥量，互斥量我们可以看作是0或1（我们只是这么认为，但是互斥量仍然是结构体）
信号量：sem_t 类型

常用函数

sem_init函数

  • 函数原型：int sem_init(sem_t *sem, int pshared, unsigned int value);
  • 参数解释：第二个参数为0是线程间共享，为1是进程间共享，第三个参数为信号量
  • 返回值成功返回0，失败返回-1

sem_destroy函数

sem_wait函数

  • 相当于lock

sem_post函数

  • 相当于unlock

sem_trywait函数

  • 相当于trylock

sem_timedwait函数

使用信号量实现生产者消费者模型

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

#define NUM 5

sem_t sem_product, sem_blank;
int a[NUM];

void * fun_consumer(void * arg) {
    int i = 0;
    while(1) {
        sem_wait(&sem_blank);
        a[i] = rand() % 1000;
        printf("product ------%d\n", a[i]);
        sem_post(&sem_product);
        i = (i + 1) % NUM;
        sleep(rand() % 3);
    }
    return NULL;
}

void * fun_producter(void * arg) {
    int i = 0;
    while(1) {
        sem_wait(&sem_product);
        printf("consumer ----- %d\n", a[i]);
        sem_post(&sem_blank);
        i = (i + 1) % NUM;
        sleep(rand() % 3);
    }
    return NULL;
}


int main(void) {
    pthread_t tid[2];
    sem_init(&sem_product, 0, 0);
    sem_init(&sem_blank, 0, NUM);

    pthread_create(&tid[0], NULL, fun_producter, NULL);
    pthread_create(&tid[1], NULL, fun_consumer, NULL);

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

    sem_destroy(&sem_product);
    sem_destroy(&sem_blank);

    return 0;
}

进程间互斥量

我们知道互斥量在线程中可以灵活的使用，但是互斥量在进程中也可以做到共享

代码演示

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/mman.h>
struct Message {
    int num;
    pthread_mutex_t mutex;
    pthread_mutexattr_t mutex_attr;
};

int main(void) {
    srand(time(NULL));
    Message * msg;
    msg = (Message * )mmap(NULL, sizeof(Message), PROT_WRITE | PROT_READ, MAP_SHARED | MAP_ANON, -1, 0);
    memset(msg, 0, sizeof(*msg));
    pthread_mutexattr_init(&msg->mutex_attr);
    pthread_mutexattr_setpshared(&msg->mutex_attr, PTHREAD_PROCESS_SHARED);
    pthread_mutex_init(&msg->mutex, &msg->mutex_attr);
    pid_t pid;
    pid = fork();
    if(pid == 0) {
        while(1) {
            pthread_mutex_lock(&msg->mutex);
            msg->num++;
            printf("child pthread -------- +1 %d\n", msg->num);
            pthread_mutex_unlock(&msg->mutex);
            sleep(rand() % 3);
        }
    } else if(pid > 0) {
        while(1) {
            pthread_mutex_lock(&msg->mutex);
            msg->num += 2;
            printf("------------ parent += 2  %d\n", msg->num);
            pthread_mutex_unlock(&msg->mutex);
            sleep(rand() % 3);
        }
    }
    return 0;
}

文件锁

文件锁用于进程间通讯使用，类似于线程之间的读写锁，但是使用fcntl函数实现

fcntl函数

  • 函数原型：int fcntl(int fildes, int cmd, ...);

副参cmd在文件锁中的应用

在文件锁中用需要用到三个cmd

  1. F_SETLCK：参数为flock结构体，加锁
  2. F_SETLCKW：参数为flock结构体，加锁
  3. F_UNLOCK：解锁

⚠️需要注意的是：文件锁中加锁和解锁需要的是同一个函数，不同的是flock结构体中的东西。

flock结构体

struct flock {
    off_t       l_start;    /* starting offset */
    off_t       l_len;      /* len = 0 means until end of file */
    pid_t       l_pid;      /* lock owner */
    short       l_type;     /* lock type: read/write, etc. */
    short       l_whence;   /* type of l_start */
};

l_type：三种类型，分别为 F_WRLCK（写锁），F_RDLCK（读锁），F_UNLCK（解锁）
l_whence：其实位置
l_start：偏移量
l_len：加锁的长度，如果为0操作的是整个文件
l_pid：拥有这个flock的进程id

⚠️注意：文件锁只能用在进程中，并不能用在线程中，因为各个线程共享文件描述符，同样共享了文件结构体，fcntl又是通过文件描述符操作的文件结构体，所以在线程中不能使用。

使用fcntl加锁解锁文件演示

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
void sys_err(const char * msg){
    perror(msg);
    exit(1);
}

int main(int argc, char ** argv) {
    if(argc != 2) {
        puts("./file_lock filename");
        exit(1);
    }
    if(access(argv[1], F_OK) < 0) {
        sys_err(const_cast<char *>("file not exist"));
    }
    int fd;
    if((fd = open(argv[1], O_RDWR)) < 0) {
        sys_err(const_cast<char *>("open failed"));
    }
    struct flock f_lock;
    memset(&f_lock, 0, sizeof(f_lock));
    //f_lock.l_type = F_RDLCK;        /* 可选读锁 */
     f_lock.l_type = F_WRLCK;     /* 可选写锁 */
    f_lock.l_whence = SEEK_SET;
    f_lock.l_start = 0;
    f_lock.l_len = 0;

    fcntl(fd, F_SETLKW, &f_lock);

    printf("GET LOCK!!!\n");
    sleep(10);
    
    f_lock.l_type = F_UNLCK;

    fcntl(fd, F_SETLKW, &f_lock);
    printf("LOSE LOCK!\n");
    return 0;
}
zephyr_pro
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
编程资料 －C# 多线程
踏雪无痕
11-12 1万+
编程资料 － 多线程C#多线程编程实例实战作者： 刘弹 www.ASPCool.com 时间:2003-5-17 上午 10:24:05 阅读次数:10996单个写入程序/多个阅读程序在.Net 类库中其实已经提供了实现，即System.Threading.ReaderWriterLock 类。本文通过对常见的单个写入/多个阅读程序的分析来探索c#的多线程编程。问题的提出所谓单个写入程序/多个阅读
python开发之线程与进程
冠军阿狗的博客
03-31 994
python开发之线程与进程一、线程与进程1. 线程（thread）2. 进程（process）3. 进程与线程的区别4. Python GIL(Global Interpreter Lock 全局解释器锁)二、threading模块1. 线程的两种调用方式2. Join & Daemon三、锁1. 同步锁(Lock)同步锁与GIL的关系？2. 线程死锁和递归锁3. 条件变量(Condit...
运行时: 使进程和线程同步
Mycro的专栏
12-02 1399
内容：进程和线程同步计时器循环互斥锁结束语再论管道参考资料 关于作者对本文的评价相关内容：Linux、Windows 2000 和 Windows XP 中的管道块内存复制，第一部分块内存复制，第二部分订阅:developerWorks 时事通讯Linux 和 Windows 上的高性能编程技术Edward G. Bradford 博士高级程序员, IBM2001 年 10 月 19 日在 Ed
进程与线程&同步与异步
ql0722的专栏
02-09 1035
进程是程序的一次执行，是系统资源（CPU时间、内存）分配的基本单位。 线程是进程的一个执行流，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位，一个进程可以有多个线程，多个线程可以并发执行，线程与同属一个进程的其他线程共享进程所拥有的全部资源。 与进程比较 线程的优点： 启动一个线程比启动一个进程节省资源，同一进程下的线程共享数据空间，方便通信。 线程的缺点： 一个线程
进程同步和线程同步
Sunshine的专栏
05-30 6092
怎样同步多个线程或多个进程的活动。为允许在线程或进程间共享数据，同步是必需的。          互斥锁和条件变量是同步的基本组成部分。互斥锁和条件变量出自POSIX.1线程标准，它们总是可用来同步一个进程内的各个线程的。如果一个互斥锁或条件变量存放在多个进程间共享的某个内存中，那么POSIX还允许它用于这些进程间的同步。互斥锁、条件变量、读写锁、信号量均可用于进程、线程的同步。 多线
进程同步与线程同步
weixin_43496874的博客
09-20 1552
目录 进程同步 1. 临界区 2. 同步与互斥 3. 信号量 4. 管程 线程同步 一、线程同步和线程互斥 线程同步： 线程互斥： 二、线程同步的方式 1、互斥锁 互斥锁的特点： 2、条件变量： 3、信号量 4、读写锁 5、自旋锁 进程同步 1. 临界区 对临界资源进行访问的那段代码称为临界区。 为了互斥访问临界资源，每个进程在进入临界区之前，需要先进行检查...
IO进程线程Day5 文件夹拷贝 从文件中读取数据到内存，从内存写入到文件 父子进程发送消息
最新发布
04-04
总的来说，"IO进程线程Day5"的学习涵盖了文件操作、文件夹拷贝以及进程间通信的基础知识，这些都是进行系统级编程和开发高效应用程序不可或缺的技能。掌握这些概念和技巧，能够帮助开发者更好地理解和处理计算机系统...
C++多线程编程入门
04-26
- **线程同步**: 使用互斥锁(`std::mutex`)、条件变量(`std::condition_variable`)等机制来同步线程间的操作，防止数据竞争和死锁等问题。 - **线程终止**: 可以通过调用`std::thread::join()`等待线程结束，或者`...
9 Python编程语言与测试框架 - 软件测试
weixin_54698622的博客
07-20 946
软件测试所有内容笔记正在陆续更新中，笔记已经在本地记录，全部为自己手动记录的笔记及总结，正在开始更新中，后续会逐步更新并完善到 软件测试学习内容总结 专栏。 本节内容：Python编程语言与测试框架 文章目录1. python标准库Python 标准库常见模块2. python多线程处理什么是进程什么是线程Python与线程两种线程管理3. python 常用的第三方库pytestrequests4. pip依赖管理与虚拟环境pip 介绍虚拟环境5. python unittest测试框架1. 单元测试.
同步对象
camelisi的专栏
10-18 486
http://blog.csdn.net/qunbinyue/article/details/1491146 Windows共设置了4种主要的同步对象，分别是临界区（Critical Section）、互斥量（Mutex）、信号量（Semaphore）和事件（Event）。MF
进程同步和线程同步概述
wang13342322203的博客
07-24 1322
楼主本来是要继续写服务器并发的，但是后续的服务器相关点都和进程线程联系在一起，所以先把进程线程相关内容写完吧！ 这次只写进程线程的概述，实际操作后续博文逐一代码实现。 进程同步or进程通信/线程同步or线程通信？ 这两组概念迷惑我至今，网上和书籍对这个的描述也是爱用啥用啥的感觉，今天又重新理了一遍。 什么是同步：同步就是数据保持一致，无论是进程还是线程，都是实现了代码执行流程的分支，多个分支同...
进程通信与线程同步
pzp201833的博客
03-26 866
一  进程通信进程通信是指进程之间信息的交换。当进程之间需要传送大量数据时，需要利用操作系统提供的高级通信工具。其中windows和linux系统有不同的通信工具。windows：管道、共享内存、消息队列、socket。linux：管道、信号、消息队列、共享内存、socket。（1）管道管道连接一个读进程和一个写进程以及实现两个进程通信的一个共享文件（管道）。写进程向管道中输入字符流数据，读进程从...
进程与线程的同步方式
Broken_Wave的博客
09-03 1288
1、线程同步： 临界区（Critical Section）、互斥量（Mutex）、信号量（Semaphore）、事件（Event） 1）、临界区：通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。在任意时刻只允许一个线程对共享资源进行访问，如果有多个线程试图访问公共资源，那么在有一个线程进入后，其他试图访问公共资源的线程将被挂起，并一直等到进入临界区的线程离开，临界区在被...
线程/进程同步
居老师的博客
04-18 276
我们都知道在多线程里，每个线程并不一定是顺序执行的，它们基本是以各自独立的、不可预知的速度向前推进，但有时候我们又希望多个线程能密切合作，以实现一个共同的任务。 例子，线程 1 是负责读入数据的，而线程 2 是负责处理数据的，这两个线程是相互合作、相互依赖的。线程 2 在没有收到线程 1 的唤醒通知时，就会一直阻塞等待，当线程 1 读完数据需要把数据传给线程 2 时，线程 1 会唤醒线程 2，并把数据交给线程 2 处理。 所谓同步，就是并发进程/线程在一些关键点上可能需要互相等待与互通消息，这种相互制约
线程同步、进程同步、互斥量、信号量、条件变量等
knowledgebao的博客
06-02 559
线程同步 临界区criticalsections,互斥量mutex互斥锁,事件通知机制event,信号量semaphore,读写锁,条件变量condition,自旋锁,其他概念 进程同步 信号量,信号signal,管道,消息队列,共享内存,文件,套接字socket通信...
进程的同步与通信，进程与线程同步的区别，进程与线程通信的区别
weixin_33724570的博客
08-10 228
2013-08-10 15:45:31 这两天看进程的同步与通信，看了几本书上的介绍，也从网上搜了很多资料，越看越迷惑，被这几个问题搞得很纠结。 进程同步与互斥的区别？ 进程的同步方式有哪些？ 进程的通信方式有哪些？ 进程同步与通信的区别是什么？ 线程的同步/通信与进程的同步/通信有区别吗？ 在好多教材上（包括国内与国外的）也没有明确这些概念，现在对每个问题还没有准确的答案，...
linux互斥锁_pthread_mutex_反复调用
saturn254的专栏
05-24 2566
一、互斥锁 1.1 基本API： #include <pthread.h> int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr); int pthread_mutex_destroy(pthread_mutex_t *mutex); 1.2 属性API： int pthread_mutexattr_init(pthread_mutexa
Golang-并发之互斥锁
木子阳的工作记录站
05-17 181
互斥锁 定义 当多个goroutine同时访问一个资源的时候需要加上互斥锁防止出错。互斥锁能保证同时只有一个goroutine访问共享资源。Go语言中使用sync包的Mutex类型诗选互斥锁。 // Go语言中对 Mutex 的定义 // A Mutex is a mutual exclusion lock. // The zero value for a Mutex i...
《Linux编程接口：Linux和UNIX系统编程手册》- Michael Kerrisk
线程同步是多线程编程中的关键，书中通过示例详细阐述了互斥锁、条件变量、信号量等同步原语的使用。此外，还讨论了信号处理，包括信号的发送、接收以及它们在程序控制流中的作用。 书中还特别强调了与标准的兼容性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值