百度360必应搜狗淘宝本站头条
java配置环境变量fill_parent函数指针百度网盘下载速度慢破解方法谷歌浏览器免费入口
当前位置：网站首页 > 技术流 > 正文

多线程5——线程同步（多线程怎么同步）

citgpt 2024-08-01 13:31 11 浏览 0 评论

线程同步（同，协同、协助、互相配合的意思），可以理解为线程A和B一块配合，A执行到一定程度时要依靠B的结果，于是A停下来，B执行；B执行后将结果告知A，A再继续执行。

在并发情况下，指令执行的先后顺序由内核决定。同一个线程内部，指令按照先后顺序执行，但不同线程之间的指令很难说清楚是哪一个先执行。如果运行的结果依赖于多线程执行的顺序，那么就会形成竞争条件，每次运行的结果可能会不同，所以应该尽量避免竞争条件的形成。

多线程5——线程同步（多线程怎么同步）

线程同步的常见方法：互斥锁，读写锁，条件变量，信号量。

（1）不加锁

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

// 剩余票数100张
int tickets = 100;

void *selltickets(void *arg)
{
    while (tickets > 0)
    {
        // printf("%ld 正在卖第%d张门票\n", pthread_self(), tickets);
        tickets--;
    }

    pthread_exit(NULL);
}

int main(int argc, char **argv)
{
    // 启动3个窗口（线程），同时售票
    // 观察多线程并发操作临界资源时，
    // 会不会出现余票为负数的情况？
    pthread_t t1, t2, t3;
    pthread_create(&t1, NULL, selltickets, NULL);
    pthread_create(&t2, NULL, selltickets, NULL);
    pthread_create(&t3, NULL, selltickets, NULL);

    // 阻塞主线程，等待子线程结束
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);

    printf("余票： %d\n", tickets);

    // 退出主线程
    pthread_exit(NULL);
    return 0;
}
编译并运行程序
baohua@node1:~$ gcc threadsync.c -lpthread -o main
baohua@node1:~$ ./main
余票： -2

注意：程序运行结果不唯一！！！

结论：观察到多线程并发操作全局变量（临界资源）时，出现多卖的问题。

（2）互斥锁

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

// 声明一个互斥锁
pthread_mutex_t mutex;
// 剩余票数100张
int tickets = 100;

void *selltickets(void *arg)
{
    while (1)
    {
        // 加锁
        pthread_mutex_lock(&mutex);

        if (tickets > 0)
        {
            printf("线程id：%ld 正在卖第%d张门票\n", pthread_self(), tickets);
            tickets--;
        } else {
            // 这里要先解锁，再跳出循环！！！
            pthread_mutex_unlock(&mutex);
            break;
        }

        // 解锁
        pthread_mutex_unlock(&mutex);

        // 让线程竞争临界资源，表现的更明显一点
        sleep(1);
    }

    pthread_exit(NULL);
}

int main(int argc, char **argv)
{
    // 初始化互斥锁
    pthread_mutex_init(&mutex, NULL);

    // 启动3个窗口（线程），同时售票
    // 观察多线程并发操作临界资源时，
    // 会不会出现余票为负数的情况？
    pthread_t t1, t2, t3;
    pthread_create(&t1, NULL, selltickets, NULL);
    pthread_create(&t2, NULL, selltickets, NULL);
    pthread_create(&t3, NULL, selltickets, NULL);

    // 阻塞主线程，等待子线程结束
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);

    printf("余票： %d\n", tickets);

    // 注销互斥锁
    pthread_mutex_destroy(&mutex);

    // 退出主线程
    pthread_exit(NULL);

    return 0;
}

编译并运行程序
baohua@node1:~$ gcc threadsync.c -lpthread -o main
baohua@node1:~$ ./main
线程id：140218611173120 正在卖第100张门票
线程id：140218602780416 正在卖第99张门票
线程id：140218594387712 正在卖第98张门票
......出于篇幅考虑，中间省略若干行........
线程id：140218594387712 正在卖第3张门票
线程id：140218602780416 正在卖第2张门票
线程id：140218611173120 正在卖第1张门票
余票： 0

（3）读写锁

线程对共享资源的访问分为两类：读操作和写操作。

多线程并发下，写操作不安全，但读操作是安全的。因此，在读多写少的场景下，出于提高性能的目的，应允许多个线程同一时刻读取同一数据，但是互斥锁不满足这种情况，由此引申出了另一种锁机制——读写锁。

读写锁特点：

  • 有线程在读取数据时，允许其他线程执行读操作，但不允许执行写操作
  • 有线程在写数据时，不允许其他线程执行写操作和读操作
  • 写操作是独占的，优先级高
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

int num = 1;             //定义全局变量
pthread_rwlock_t rwlock; //创建读写锁

void *writenum(void *arg)
{
    while (1)
    {
        //加写锁
        pthread_rwlock_wrlock(&rwlock); 
        num++;
        printf("num++ ,tid: %ld,num:%d\n", pthread_self(), num);
        pthread_rwlock_unlock(&rwlock);
        sleep(1);
    }

    pthread_exit(NULL);
}

void *readnum(void *arg)
{
    while (1)
    {
        //加读锁
        pthread_rwlock_rdlock(&rwlock); 
        printf("==read ,tid: %ld,num:%d\n", pthread_self(), num);
        sleep(1);
        pthread_rwlock_unlock(&rwlock);
        usleep(10);
    }

    pthread_exit(NULL);
}

int main(int argc, char **argv)
{
    //初始化读写锁
    pthread_rwlock_init(&rwlock, NULL);

    //存放3个写线程号
    pthread_t wtids[3];
    //存放5个读线程号
    pthread_t rtids[5];

    for (int i = 0; i < 3; i++)
    {
        //创建写的线程
        pthread_create(&wtids[i], NULL, writenum, NULL);
    }

    for (int i = 0; i < 5; i++)
    {
        //创建读的线程
        pthread_create(&rtids[i], NULL, readnum, NULL);
    }

    for (int i = 0; i < 3; i++)
    {
        pthread_join(wtids[i], NULL);
    }

    for (int i = 0; i < 5; i++)
    {
        pthread_join(rtids[i], NULL);
    }

    //释放读写锁
    pthread_rwlock_destroy(&rwlock);

    pthread_exit(NULL);
    return 0;
}

（4）条件变量

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

int i = 0;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condvar = PTHREAD_COND_INITIALIZER;

void *threadfunc(void *pvoid)
{
    while (1)
    {
        pthread_mutex_lock(&mutex);
        if (i < 200)
        {
            i++;
            pthread_cond_signal(&condvar);    /**< 子线程唤醒主线程 */
            pthread_mutex_unlock(&mutex);
        }
        else
        {
            pthread_mutex_unlock(&mutex);
            break;
        }
    }

    return NULL;
}

int main(int argc, char **argv)
{
    pthread_t tid;
    pthread_create(&tid, NULL, &threadfunc, NULL);

    pthread_mutex_lock(&mutex);

    while (i < 100)
    {
        pthread_cond_wait(&condvar, &mutex);
    }

    printf("i = %d\n", i);
    pthread_mutex_unlock(&mutex);
    pthread_join(tid, NULL);
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&condvar);

    return 0;
}

子线程每次唤醒条件变量并释放互斥锁之后，将与主线程一同竞争互斥锁。也就是说，等待条件变量的线程在被唤醒时，并不自动获得互斥锁。

（5）信号量

信号量本质上是一个非负的整数计数器，它被用来控制对公共资源的访问。

根据信号量的值来判断是否对公共资源具有访问权限，当信号量的值大于0时，可以访问，否则将阻塞。

信号量带有两个原子操作 P 和 V，一次 P 操作使信号量减1，一次 V 操作使信号量加 1。

#include <semaphore.h>
// 初始化信号量
int sem_init(sem_t *sem, int pshared, unsigned int value);
        -sem：信号变量的地址
        -pshared：0-用在线程  非0-用在进程
        -value：信号量中的值

// 信号量 P 操作（减 1）
int sem_wait(sem_t *sem);

// 以非阻塞的方式来对信号量进行减 1 操作
int sem_trywait(sem_t *sem);

// 信号量 V 操作（加 1）
int sem_post(sem_t *sem);

// 获取信号量的值
int sem_getvalue(sem_t *sem, int *sval);

// 销毁信号量
int sem_destroy(sem_t *sem);
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>

// 定义两个信号量
sem_t sem_g, sem_p;
char ch = 'a';

// 此线程改变字符ch的值
void *pthread_g(void *arg)
{
    while (1)
    {
        sem_wait(&sem_g);
        ch++;
        sem_post(&sem_p);

        if (ch > 'z')
        {
            break;
        }
    }

    pthread_exit(NULL);
}

// 此线程打印ch的值
void *pthread_p(void *arg)
{
    while (1)
    {
        sem_wait(&sem_p);

        if (ch > 'z')
        {
            break;
        }

        printf("%c", ch);
        fflush(stdout);

        sem_post(&sem_g);
    }

    pthread_exit(NULL);
}

/**
 * 输出26个小写字母
 */
int main(int argc, char *argv[])
{
    pthread_t tid1, tid2;
    // 初始化信号量为0
    sem_init(&sem_g, 0, 0);
    // 初始化信号量为1
    sem_init(&sem_p, 0, 1);

    pthread_create(&tid1, NULL, pthread_g, NULL);
    pthread_create(&tid2, NULL, pthread_p, NULL);

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

    sem_destroy(&sem_g);
    sem_destroy(&sem_p);

    pthread_exit(NULL);

    return 0;
}

相关推荐

js中arguments详解

一、简介了解arguments这个对象之前先来认识一下javascript的一些功能：其实Javascript并没有重载函数的功能，但是Arguments对象能够模拟重载。Javascrip中每个函数...

firewall-cmd 常用命令

目录firewalldzone说明firewallzone内容说明firewall-cmd常用参数firewall-cmd常用命令常用命令 回到顶部firewalldzone...

epel-release 是什么

EPEL-release（ExtraPackagesforEnterpriseLinux）是一个软件仓库，它为企业级Linux发行版（如CentOS、RHEL等）提供额外的软件包。以下是关于E...

FullGC详解 什么是 JVM 的 GC
FullGC详解 什么是 JVM 的 GC

前言：背景：一、什么是JVM的GC?JVM（JavaVirtualMachine）。JVM是Java程序的虚拟机，是一种实现Java语言的解...

2024-10-26 08:50 citgpt

使用Spire.Doc组件利用模板导出Word文档
  • 使用Spire.Doc组件利用模板导出Word文档
  • 使用Spire.Doc组件利用模板导出Word文档
  • 使用Spire.Doc组件利用模板导出Word文档
  • 使用Spire.Doc组件利用模板导出Word文档
跨域（CrossOrigin）

1.介绍　　1)跨域问题：跨域问题是在网络中，当一个网络的运行脚本（通常时JavaScript）试图访问另一个网络的资源时，如果这两个网络的端口、协议和域名不一致时就会出现跨域问题。　　　　通俗讲...

微服务架构和分布式架构的区别

1、含义不同微服务架构：微服务架构风格是一种将一个单一应用程序开发为一组小型服务的方法，每个服务运行在自己的进程中，服务间通信采用轻量级通信机制(通常用HTTP资源API)。这些服务围绕业务能力构建并...

深入理解与应用CSS clip-path 属性
深入理解与应用CSS clip-path 属性

clip-pathclip-path是什么clip-path 是一个CSS属性，允许开发者创建一个剪切区域，从而决定元素的哪些部分可见，哪些部分会被隐...

2024-10-25 11:51 citgpt

HCNP Routing&Switching之OSPF LSA类型（二）
  • HCNP Routing&Switching之OSPF LSA类型（二）
  • HCNP Routing&Switching之OSPF LSA类型（二）
  • HCNP Routing&Switching之OSPF LSA类型（二）
  • HCNP Routing&Switching之OSPF LSA类型（二）
Redis和Memcached的区别详解
  • Redis和Memcached的区别详解
  • Redis和Memcached的区别详解
  • Redis和Memcached的区别详解
  • Redis和Memcached的区别详解
Request.ServerVariables 大全

Request.ServerVariables("Url")返回服务器地址Request.ServerVariables("Path_Info")客户端提供的路...

python操作Kafka

目录一、python操作kafka1.python使用kafka生产者2.python使用kafka消费者3.使用docker中的kafka二、python操作kafka细...

Runtime.getRuntime().exec详解

Runtime.getRuntime().exec详解概述Runtime.getRuntime().exec用于调用外部可执行程序或系统命令，并重定向外部程序的标准输入、标准输出和标准错误到缓冲池。...

promise.all详解 promise.all是干什么的
promise.all详解 promise.all是干什么的

promise.all详解promise.all中所有的请求成功了，走.then()，在.then()中能得到一个数组，数组中是每个请求resolve抛出的结果...

2024-10-24 16:21 citgpt

Content-Length和Transfer-Encoding详解
  • Content-Length和Transfer-Encoding详解
  • Content-Length和Transfer-Encoding详解
  • Content-Length和Transfer-Encoding详解
  • Content-Length和Transfer-Encoding详解

取消回复欢迎 你 发表评论:

一周热门
最近发表
标签列表
本站资源收集于网络以及网友投稿，其版权归原创者所有，如有侵害到你的权益，或有不妥之处，
请联系jellybean52032@gmail.com，提供原文链接地址以及资料原创证明，本站将会立即删除。