信号量——Linux并发之魂

news2024/10/6 10:29:07

欢迎来到 破晓的历程的 博客

引言

今天，我们继续学习Linux线程本分，在Linux条件变量中，我们对条件变量的做了详细的说明，今天我们要利用条件变量来引出我们的另一个话题——信号量内容的学习。

1.复习条件变量

在上一期博客中，我们没有对条件变量做具体的使用，所以，这里我们通过一份代码来复习一下，接下来，我们实现基于BlockingQueue的生产者消费者模型。

1.1何为基于BlockingQueue的生产者消费者模型

BlockingQueue在多线程编程中阻塞队列(Blocking Queue)是一种常用于实现生产者和消费者模型的数据结构。其与普通的队列区别在于，当队列为空时，从队列获取元素的操作将会被阻塞，直到队列中被放入了元素；当队列满时，往队列里存放元素的操作也会被阻塞，直到有元素被从队列中取出(以上的操作都是基于不同的线程来说的，线程在对阻塞队列进程操作时会被阻塞)
如图：
在这里插入图片描述

1.2分析该模型

这里我想写多个生产线程和多个消费线程的模型
我们来分析一下。

  1. 首先生产任务的过程和消费任务的过程必须是互斥关系，不可以同时访问该队列（此时，这个队列是共享资源）。
  2. 当队列满时，生产线程就不能再生产任务，必须在特定的条件变量下等待；同理当队列为空时，消费线程就不能再消费任务，也必须在特定的条件变量下等待。
    所以，类应这样设计：
template<class T>
class BlockQueue
{
public:
    BlockQueue(const int &maxcap=gmaxcap):_maxcap(maxcap)
    {
        pthread_mutex_init(&_mutex,nullptr);
        pthread_cond_init(&_pcond,nullptr);
        pthread_cond_init(&_ccond,nullptr);

    }
    void push(const T&in)//输入型参数，const &
    {
        pthread_mutex_lock(&_mutex);
        while(is_full())
        {
            pthread_cond_wait(&_pcond,&_mutex);

        }
        _q.push(in);

        pthread_cond_signal(&_ccond);
        pthread_mutex_unlock(&_mutex);
    }
    void pop(T*out)
    {
        pthread_mutex_lock(&_mutex);
        while(is_empty())
        {
            pthread_cond_wait(&_ccond,&_mutex);
        }
        *out=_q.front();
        _q.pop();
        pthread_cond_signal(&_pcond);
        pthread_mutex_unlock(&_mutex);
    }
    ~BlockQueue()
    {
        pthread_mutex_destroy(&_mutex);
        pthread_cond_destroy(&_ccond);
        pthread_cond_destroy(&_pcond);
    }
private:
    bool is_empty()
    {
        return _q.empty();
    }
    bool is_full()
    {
        return _q.size()==_maxcap;
    }
private:
    std::queue<T> _q;
    int _maxcap; //队列中元素的上线
    pthread_mutex_t _mutex;
    pthread_cond_t _pcond; //生产者对应的条件变量
    pthread_cond_t _ccond;
};

由于我们不知道存储的数据类型，所以这里我们选择使用泛型编程的方式。
接下来就是要生产任务，为了可以观察到整个生产和消费任务的过程，我们可以生成两个随机数，然后进行运算。代码如下：

class CalTask
{
    using func_t = function<int(int, int, char)>;

public:
    CalTask() {}
    CalTask(int x, int y, char op, func_t func) 
        :_x(x),_y(y),_op(op),_callback(func)
    {}
    string  operator()()
    {
        int result=_callback(_x,_y,_op);
        char buffer[1024];
        snprintf(buffer,sizeof buffer,"%d %c %d=%d",_x,_op,_y,result);
        return buffer;
    }
    string toTaskstring()
    {
        char buffer[1024];
        snprintf(buffer,sizeof buffer,"%d %c %d=?",_x,_op,_y);
        return buffer;
    }   
private:
    int _x;
    int _y;
    char _op;
    func_t _callback;
};
const char*oper="+-*/%";
int mymath(int x,int y,char op)
{
    int result=0;
    switch(op)
    {
        case '+':
            result=x+y;
            break;
        case '-':
            result=x-y;
            break;
        case '*':
            result=x*y;
            break;
        case '/':
            if(y==0)
            {
                cerr<<"div zero error"<<endl;
                result=-1;
            }
            else
            {
                result=x/y;
            }
            break;
        case '%':
            if(y==0)
            {
                cerr<<"mod zero error"<<endl;
                result=-1;

            }
            else
            {
                result=x%y;
            }
        default:
            break;
    }
    return result;
}

接下来，我们来写整体的代码。

1.3完整代码

我们要创建三个文件：BlockQueue.hpp Task.hpp Main.cc各文件内容如下所示：

BlockQueue.hpp

#pragma once
#include<iostream>
#include<pthread.h>
#include<cstring>
#include<unistd.h>
#include<cassert>
#include<queue>
using namespace  std;
const int gmaxcap=100;
template<class T>
class BlockQueue
{
public:
    BlockQueue(const int &maxcap=gmaxcap):_maxcap(maxcap)
    {
        pthread_mutex_init(&_mutex,nullptr);
        pthread_cond_init(&_pcond,nullptr);
        pthread_cond_init(&_ccond,nullptr);

    }
    void push(const T&in)//输入型参数，const &
    {
        pthread_mutex_lock(&_mutex);
        while(is_full())
        {
            pthread_cond_wait(&_pcond,&_mutex);

        }
        _q.push(in);

        pthread_cond_signal(&_ccond);
        pthread_mutex_unlock(&_mutex);
    }
    void pop(T*out)
    {
        pthread_mutex_lock(&_mutex);
        while(is_empty())
        {
            pthread_cond_wait(&_ccond,&_mutex);
        }
        *out=_q.front();
        _q.pop();
        pthread_cond_signal(&_pcond);
        pthread_mutex_unlock(&_mutex);
    }
    ~BlockQueue()
    {
        pthread_mutex_destroy(&_mutex);
        pthread_cond_destroy(&_ccond);
        pthread_cond_destroy(&_pcond);
    }
private:
    bool is_empty()
    {
        return _q.empty();
    }
    bool is_full()
    {
        return _q.size()==_maxcap;
    }
private:
    std::queue<T> _q;
    int _maxcap; //队列中元素的上线
    pthread_mutex_t _mutex;
    pthread_cond_t _pcond; //生产者对应的条件变量
    pthread_cond_t _ccond;
};

Task.hpp

#pragma once
#include <iostream>
#include <string>
#include <cstdio>
#include<string>
#include <functional>
using namespace std;
class CalTask
{
    using func_t = function<int(int, int, char)>;

public:
    CalTask() {}
    CalTask(int x, int y, char op, func_t func) 
        :_x(x),_y(y),_op(op),_callback(func)
    {}
    string  operator()()
    {
        int result=_callback(_x,_y,_op);
        char buffer[1024];
        snprintf(buffer,sizeof buffer,"%d %c %d=%d",_x,_op,_y,result);
        return buffer;
    }
    string toTaskstring()
    {
        char buffer[1024];
        snprintf(buffer,sizeof buffer,"%d %c %d=?",_x,_op,_y);
        return buffer;
    }   
private:
    int _x;
    int _y;
    char _op;
    func_t _callback;
};
const char*oper="+-*/%";
int mymath(int x,int y,char op)
{
    int result=0;
    switch(op)
    {
        case '+':
            result=x+y;
            break;
        case '-':
            result=x-y;
            break;
        case '*':
            result=x*y;
            break;
        case '/':
            if(y==0)
            {
                cerr<<"div zero error"<<endl;
                result=-1;
            }
            else
            
           		result=x/y;
            }
            break;
        case '%':
            if(y==0)
            {
                cerr<<"mod zero error"<<endl;
                result=-1;
            }
            else
            {
                result=x%y;
            }
        default:
            break;
    }
    return result;
}

Main.cc

include "BlockQueue.hpp"
#include "Task.hpp"
#include<sys/types.h>
#include<unistd.h>
#include<ctime>
#include<iostream>
using namespace std;


void *productor(void *bqs_)
{
    BlockQueue<CalTask> *bqs=static_cast<BlockQueue<CalTask>*>(bqs_);
    while(true)
    {
        int x=rand()%10+1;
        int y=rand()%5+1;
        int opercode=rand()%(sizeof(oper));
        CalTask T(x,y,oper[opercode],mymath);
        bqs->push(T);
        cout<<"生产任务: ";
        cout<<T.toTaskstring()<<endl;
        sleep(1);
    }
}
void *consumer(void *bqs_)
{
    BlockQueue<CalTask>*bqs=static_cast<BlockQueue<CalTask>*>(bqs_);
    while(true)
    {
        CalTask T;
        bqs->pop(&T);
        cout<<"消费任务: ";
        cout<<T()<<endl;

    }
}
int main()
{
    BlockQueue<CalTask> bqs;
    pthread_t p[5];
    pthread_t c[5];
    for(int i=0;i<5;i++)
    {
        pthread_create(&p[i],nullptr,productor,&bqs);
        pthread_create(&c[i],nullptr,consumer,&bqs);
    }
    for(int i=0;i<5;i++)
    {
        pthread_join(p[i],nullptr);
        pthread_join(c[i],nullptr);
    }
}

在代码中，有几个点需要注意一下：
第一点：
在这里插入图片描述
pthread_cond_wait的第二个参数一定是我们正在使用的互斥锁，这个函数在被运行时，会以原子性的方式将锁释放，然后将自己挂起，等待被条件变量唤醒。该函数在被唤醒时，会自动重新获取持有的锁，然后继续向下执行。
假如数个生产者线程一起被唤醒，然后先后持有锁，接着继续生产任务，当队列剩余的空间小于这些生产者生产的任务时，就会出现问题，所以让所有被唤醒的线程先通过while循环，如果有剩余的空间，再进行任务的生产活动。

生产线程这样处理，消费线程也要这样处理

大家可以在自己试这敲一下，有问题可以在评论区和我交流。
接下来，我们来查找一下这些代码有哪些"不足的地方"

2.代码中的“不足”

一个线程在操作临界资源时，临界资源必须是满足条件的，然后线程才能对临界资源进行操作。比如：在如上代码中，生产者线程只有在队列(临界资源）有剩余空间的条件下，才能进行下一步操作。
可是，临界资源是否满足生产和消费的条件，我们不能事前得知，只等进入临界资源后，再进行进一步的检测。
所以，一般访问临界资源的过程为：先加锁，再检测，如果条件满足，就进行下一步的操作；反之，就将该线程挂起，释放锁，然后挂起等待，等到条件满足时，重新获得锁，接着进行下一步操作。
因为不可能事先得知是否满足条件，所以我们只能先加锁，进入临界资源内部进行检测。
只要我们申请了信号量，就默认对这部分资源的整体使用，但通常情况下，我们使用的仅仅是临界资源的一小部分。
实际情况中，有没有可能不同的线程访问临界资源不同部分的情况，有可能。所以，前辈大佬们给出了一种解决方案——信号量。

3.信号量

3.1什么是信号量

信号量的本质是一把计数器，一把衡量临界资源多少的计数器。只要拥有信号量，就在未来一定能够拥有临界资源的一部分。

申请信号量的本质：就是对临界资源的预定机制。

比如：我想去看电影，首先我要买票。我一旦买到票，无论我去不去看电影，都会有一个位置属于我。买票的过程==申请信号信号量的过程。
所以，在访问临界资源之前，我们可以申请信号量。通过申请信号量，我们就可以获知临界资源的使用情况。①只要申请成功，就一定有我可以访问的资源。②只要申请失败，说明条件不就绪，只能等待。如此，就不需要进入临界资源再进行检测了。

3.2信号量的相关接口

在这里插入图片描述
如上这些借口如果调用成功的话，返回0；调用失败的话，返回-1，并且错误原因被设置。
我们知道信号量的本质是一把计数器，所以信号量必须可以进行递增和递减的操作。

  • 信号量-1：申请资源，其过程必须是原子性的。简称P操作。
  • 信号量+1：归还资源，其过程必须是原子性的。简称V操作。
    所以，信号量的核心操作：PV原语。
    接下来，我们就使用信号量来完成我们的基于环形队列的生产消费模型。

3.3用信号量来实现基于环形队列的生产消费模型

3.3.1对环形队列的简单介绍

相信大家在C++学习期间到都模拟实现过环形队列队列。如图：
在这里插入图片描述
环形队列的逻辑结构为环形，但其存储结构实际上就是队列，其实就是一个数组，只不过用下标不断的%上队列的长度。
大家在模拟实现环形队列时，大家必定遇到的问题是：当rear==front时，究竟是环形队列已满还是环形队列为空呢？其实，这个问题有多种处理方式，今天就不讲了。
今天，我们的基于环形队列的生产消费模型必须遵守哪些规则呢？
我们来讲一个故事：
张三和李四在一个房间里做游戏，这个房间里有一张大圆桌，桌子上有很多的盘子。规定张三往每个盘子里放一个桃子🍑，然后李四在后边吃桃子🍑，由于李四还要吃桃子，所以速度一定比张三放的速度满。

在这里插入图片描述
总结一下，我们发现张三和李四必须满足这些规律：

  1. 李四不可以超过张三——消费者不可以超过生产者。
  2. 张三不可以把李四套一个圈——生产者不可以把消费者套一个圈。
  3. 张三和李四什么时候在一起？①盘子全为空，张三和李四在一起，张三先运行（生产者先运行）。②盘子全为满，张三和李四在一起，李四先运行（消费者先运行）。③其他情况，张三和李四指向不同的位置。

我们将这些规则迁移到环形队列的生产消费模型，就是生产消费模型应该遵守的规则：
①消费者不能超过生产者。②生产者不能把消费者套一个圈。③生产者和消费者什么情况下会在一起呢？空的时候和满的时候，对应不同的处理方式。④只要生产者和消费者指向不同的位置，就可以实现生产者和消费者的并发执行。只有在为空和为 满时，才会出现同步和互斥问题。

那这些规则由什么来保证呢？信号量。信号量是表征临界资源中资源数目的。
1.对于生产者而言，看中的是队列中的剩余空间——空间资源定义一个信号量。
2.对于消费者而言，看中的是队列中的数据——数据资源定义一个信号量。

接下来，我们基于这份伪代码来理解一下，看看能否满足我们的规则。
在这里插入图片描述生产者关注的是队列里的剩余空间，在队列为空时剩余空间为10，所以生产者可以顺利申请到信号量。但是由于空间中这部分资源已经被占用，所以无法归还。但是消费者所关注的队列中的数据资源不知不觉中已经多了一份。所以对消费者信号量应进行V操作。

消费者关注的是队列中的数据资源，队列刚开始为空时，数据资源为0，消费者申请失败。等到生产者申请神域空间成功后，生产了数据。所以消费者可以成功申请到数据资源信号量，然后消费数据。但不知不觉，队列中的剩余空间多了一份，所以应对剩余空间资源的信号量进行V操作。
若队列满时，剩余空间信号量为0，生产者申请信号量失败。此时，数据资源信号量为满，消费者可以申请到信号量，从而进行操作。所以必须消费者先运行。
若队列空时，数据资源信号量为0，消费者申请信号量失败。此时，剩余空间信号量为满，生产者可以申请到信号量，从而进行操作。所以必须生产者先运行。
所以，这伪代码完全符合我们的规则。接下来，我们编写单生产进程和单消费进程的代码。

编写代码

我们创建三个源文件：RingQueue.hpp main.cc Task.hpp
Ringqueue.hpp:

#pragma once

#include <iostream>
#include <vector>
#include <cassert>
#include <semaphore.h>
#include <pthread.h>

static const int gcap = 5;

template<class T>
class RingQueue
{
private:
    void P(sem_t &sem)
    {
        int n = sem_wait(&sem);
        assert(n == 0); // if
        (void)n;
    }
    void V(sem_t &sem)
    {
        int n = sem_post(&sem);
        assert(n == 0);
        (void)n;
    }
public:
    RingQueue(const int &cap = gcap): _queue(cap), _cap(cap)
    {
        int n = sem_init(&_spaceSem, 0, _cap);
        assert(n == 0);
        n = sem_init(&_dataSem, 0, 0);
        assert(n == 0);

        _productorStep = _consumerStep = 0;

        pthread_mutex_init(&_pmutex, nullptr);
        pthread_mutex_init(&_cmutex, nullptr);
    }
    // 生产者
    void Push(const T &in)
    {
        // ?: 这个代码 有没有优化的可能
        // 你认为：现加锁，后申请信号量，还是现申请信号量，在加锁？
        P(_spaceSem); // 申请到了空间信号量，意味着，我一定能进行正常的生产
        pthread_mutex_lock(&_pmutex);        
        _queue[_productorStep++] = in;
        _productorStep %= _cap;
        pthread_mutex_unlock(&_pmutex);
        V(_dataSem);
    }
    // 消费者
    void Pop(T *out)
    {
        // 你认为：现加锁，后申请信号量，还是现申请信号量，在加锁？
        P(_dataSem);
        pthread_mutex_lock(&_cmutex);
        *out = _queue[_consumerStep++];
        _consumerStep %= _cap;
        pthread_mutex_unlock(&_cmutex);
        V(_spaceSem);
    }
    ~RingQueue()
    {
        sem_destroy(&_spaceSem);
        sem_destroy(&_dataSem);

        pthread_mutex_destroy(&_pmutex);
        pthread_mutex_destroy(&_cmutex);
    }
private:
    std::vector<T> _queue;
    int _cap;
    sem_t _spaceSem; // 生产者 想生产，看中的是什么资源呢? 空间资源
    sem_t _dataSem;  // 消费者 想消费，看中的是什么资源呢? 数据资源
    int _productorStep;
    int _consumerStep;
    pthread_mutex_t _pmutex;
    pthread_mutex_t _cmutex;
};

Task.hpp

#pragma once

#include <iostream>
#include <string>
#include <cstdio>
#include <functional>

class Task
{
    using func_t = std::function<int(int,int,char)>;
    // typedef std::function<int(int,int)> func_t;
public:
    Task()
    {}
    Task(int x, int y, char op, func_t func)
    :_x(x), _y(y), _op(op), _callback(func)
    {}
    std::string operator()()
    {
        int result = _callback(_x, _y, _op);
        char buffer[1024];
        snprintf(buffer, sizeof buffer, "%d %c %d = %d", _x, _op, _y, result);
        return buffer;
    }
    std::string toTaskString()
    {
        char buffer[1024];
        snprintf(buffer, sizeof buffer, "%d %c %d = ?", _x, _op, _y);
        return buffer;
    }
private:
    int _x;
    int _y;
    char _op;
    func_t _callback;
};

const std::string oper = "+-*/%";

int mymath(int x, int y, char op)
{
    int result = 0;
    switch (op)
    {
    case '+':
        result = x + y;
        break;
    case '-':
        result = x - y;
        break;
    case '*':
        result = x * y;
        break;
    case '/':
    {
        if (y == 0)
        {
            std::cerr << "div zero error!" << std::endl;
            result = -1;
        }
        else
            result = x / y;
    }
        break;
    case '%':
    {
        if (y == 0)
        {
            std::cerr << "mod zero error!" << std::endl;
            result = -1;
        }
        else
            result = x % y;
    }
        break;
    default:
        // do nothing
        break;
    }
    return result;
}

main.cc

#include "RingQueue.hpp"
#include "Task.hpp"
#include <pthread.h>
#include <ctime>
#include <cstdlib>
#include <sys/types.h>
#include <unistd.h>

std::string SelfName()
{
    char name[128];
    snprintf(name, sizeof(name), "thread[0x%x]", pthread_self());
    return name;
}

void *ProductorRoutine(void *rq)
{
    // RingQueue<int> *ringqueue = static_cast<RingQueue<int> *>(rq);
    RingQueue<Task> *ringqueue = static_cast<RingQueue<Task> *>(rq);
    while(true)
    {
        // version1
        // int data = rand() % 10 + 1;
        // ringqueue->Push(data);
        // std::cout << "生产完成，生产的数据是：" << data << std::endl;

        // version2
        // 构建or获取任务 --- 这个是要花时间的！
        int x = rand() % 10;
        int y = rand() % 5;
        char op = oper[rand()%oper.size()];
        Task t(x, y, op, mymath);
        // 生产任务
        ringqueue->Push(t);
        // 输出提示
        std::cout <<  SelfName() << ", 生产者派发了一个任务: " << t.toTaskString() << std::endl;

        // sleep(1);
    }
}

void *ConsumerRoutine(void *rq)
{
    // RingQueue<int> *ringqueue = static_cast<RingQueue<int> *>(rq);
    RingQueue<Task> *ringqueue = static_cast<RingQueue<Task> *>(rq);

    while(true)
    {
        //version1
        // int data;
        // ringqueue->Pop(&data);
        // std::cout << "消费完成，消费的数据是：" << data << std::endl;
        // sleep(1);

        // version2
        Task t;
        //消费任务
        ringqueue->Pop(&t);
        std::string result = t(); // 消费也是要花时间的！
        std::cout <<  SelfName() << ", 消费者消费了一个任务: " << result << std::endl;

        // sleep(1);
    }
}

int main()
{
    srand((unsigned int)time(nullptr) ^ getpid() ^ pthread_self() ^ 0x71727374);
    // RingQueue<int> *rq = new RingQueue<int>();
    RingQueue<Task> *rq = new RingQueue<Task>();

    // 单生产，单消费，多生产，多消费 --> 只要保证，最终进入临界区的是一个生产，一个消费就行！
    // 多生产，多消费的意义？？
    pthread_t p[4], c[8];
    for(int i = 0; i < 4; i++) pthread_create(p+i, nullptr, ProductorRoutine, rq);
    for(int i = 0; i < 8; i++) pthread_create(c+i, nullptr, ConsumerRoutine, rq);

    for(int i = 0; i < 4; i++) pthread_join(p[i], nullptr);
    for(int i = 0; i < 8; i++) pthread_join(c[i], nullptr);
    delete rq;
    return 0;
}

大家可以自己敲一敲，试一下。
写到这里，这篇博客就结束了，下篇博客我们再见。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1895539.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

音频流格式启用数据流

音频流格式启用数据流

音频流格式启用数据流 音频流格式启用数据流使用 AudioStreamBasicDescription 结构在哪里以及如何设置流格式 音频流格式启用数据流 在单个样本帧级别处理音频数据时&#xff0c;就像使用音频单元一样&#xff0c;仅仅指定正确的数据类型来表示音频是不够的。单个音频样本值中…
阅读更多...
【spring MVC的执行流程】

【spring MVC的执行流程】

SpringMVC可以说是Servlet的封装&#xff0c;屏蔽了Servlet的很多细节&#xff0c;比如Servlet再获取参数的时候需要不停地getParameter,现在只要在SpringMVC方法定义对应的JavaBean&#xff0c;只要属性和参数名一致&#xff0c;SpringMVC就可以帮我们实现将参数封装到JavaBea…
阅读更多...
android应用的持续构建CI（三）-- 手动签名

android应用的持续构建CI（三）-- 手动签名

一、背景 关于android应用的签名及其原理&#xff0c;很多文章都有讲述&#xff0c;无意重复赘述。 本文紧接上文&#xff0c;站在运维的角度&#xff0c;对开发是透明的。 但是它又和gradle build 构建动作是紧密相关的。 第一步使用jdk的keytool生成证书文件&#xff0c;…
阅读更多...
kubeadm快速部署k8s集群

kubeadm快速部署k8s集群

Kubernetes简介 Kubernetes&#xff0c;简称k8s&#xff0c;容器编排引擎&#xff0c;以API编程的方式管理安排各个容器的引擎。 k8s会在多台node服务器上调度pod进行部署和扩缩容每个pod内部可以含&#xfeff;有多个container每个container本质上就是一个服务进程 1、k8s集…
阅读更多...
Python 3.x 下的 3D 游戏引擎

Python 3.x 下的 3D 游戏引擎

在 Python 3.x 中&#xff0c;有几个比较流行的用于开发 3D 游戏的引擎和库。虽然 Python 自身不是一个主流的游戏开发语言&#xff0c;但是可以通过这些库和引擎结合其它语言或者底层渲染引擎来实现复杂的游戏开发。 1、问题背景 在 Linux 系统中&#xff0c;尤其是 Debian 7…
阅读更多...
clone()方法

clone()方法

在Java中&#xff0c;clone() 方法是一个非常有趣且强大的工具&#xff0c;用于创建对象的一个副本。这个方法位于 Object 类中&#xff0c;因此可以被所有类使用。让我们讨论一下它的几个要点&#xff1a; 什么是克隆&#xff1f; 克隆就是创建一个对象的新副本&#xff0c;这…
阅读更多...
3-1 激活函数和神经网络思想

3-1 激活函数和神经网络思想

3-1 激活函数和神经网络思想 主目录点这里
阅读更多...
机器学习原理之 -- 梯度提升树（GBT）原理详解

机器学习原理之 -- 梯度提升树（GBT）原理详解

梯度提升树&#xff08;Gradient Boosting Trees, GBT&#xff09;是一种强大的机器学习算法&#xff0c;广泛应用于分类和回归任务。它通过集成多个弱学习器&#xff08;通常是决策树&#xff09;来构建一个强大的预测模型&#xff0c;具有较高的准确性和鲁棒性。本文将详细介…
阅读更多...
android应用的持续构建CI（四）-- 依赖环境（兼容多版本的gradle和jdk）

android应用的持续构建CI（四）-- 依赖环境（兼容多版本的gradle和jdk）

一、背景 android应用的构建前提是&#xff0c;安装好了gradle和jdk。在实际使用的过程中&#xff0c;不同的android应用&#xff0c;对gradle和jdk的版本要求不一。 于是&#xff0c;在jenkins服务器上&#xff0c;我们需要安装多种版本的gradle和jdk。 安装过jdk的小伙伴应…
阅读更多...
Rethinking Federated Learning with Domain Shift: A Prototype View

Rethinking Federated Learning with Domain Shift: A Prototype View

CVPR2023，针对分布式数据来自不同的域时，私有模型在其他域上表现出退化性能（具有域转移）的问题。提出用于域转移下联邦学习的联邦原型学习（FPL）。核心思想是构建集群原型和无偏原型，提供富有成效的领域知识和公平的收敛目标。将样本嵌入拉近到属于相同语义的集群原型，而…
阅读更多...
昇思25天学习打卡营第10天|利用 MindSpore 实现 BERT 对话情绪识别的完整攻略

昇思25天学习打卡营第10天|利用 MindSpore 实现 BERT 对话情绪识别的完整攻略

目录 环境配置 导入模块和库 准备数据集 数据集下载和压缩 数据加载和数据预处理 进行模型的构建和优化器的设置 配置和准备模型的训练过程 测量训练操作的执行时间 模型验证 模型推理 自定义推理数据集 环境配置 首先&#xff0c;利用“%%capture captured_output”来捕获…
阅读更多...
银湖资本在中国设立公司运营点，全球投资巨头的新篇章！

银湖资本在中国设立公司运营点，全球投资巨头的新篇章！

近日&#xff0c;全球知名私募股权投资公司银湖资本宣布在中国设立公司运营点。一点是银湖资本在国内安置了两个办事营业点&#xff0c;一个在黑龙江&#xff0c;一个在广州等一线城市。这一举动标志着银湖资本在全球范围内的扩展进入了新的阶段&#xff0c;同时也展示了其对中…
阅读更多...
iOS手机竖着拍的照片被旋转了90°的原因以及解决方案

iOS手机竖着拍的照片被旋转了90°的原因以及解决方案

EXIF.getData(IMG_FILE, function () { // IMG_FILE为图像数据 var orientation EXIF.getTag(this, “Orientation”); console.log(“Orientation:” orientation); // 拍照方向 }); 获取拍照方向的结果为1-8的数字&#xff1a; 注意&#xff1a;对于上面的八种方向中&a…
阅读更多...
Xilinx FPGA:vivado关于真双端口的串口传输数据的实验

Xilinx FPGA:vivado关于真双端口的串口传输数据的实验

一、实验内容 用一个真双端RAM&#xff0c;端口A和端口B同时向RAM里写入数据0-99&#xff0c;A端口读出单数并存入单端口RAM1中&#xff0c;B端口读出双数并存入但端口RAM2中&#xff0c;当检测到按键1到来时将RAM1中的单数读出显示到PC端&#xff0c;当检测到按键2到来时&…
阅读更多...
从单体服务到微服务：预初始化属性多模式 Web 应用开发记录＜四＞ FreeMarker 视图首次渲染优化

从单体服务到微服务：预初始化属性多模式 Web 应用开发记录＜四＞ FreeMarker 视图首次渲染优化

欢迎关注公众号&#xff1a;冬瓜白 相关文章&#xff1a; 多模式 Web 应用开发记录<一>背景&全局变量优化多模式 Web 应用开发记录<二>自己动手写一个 Struts多模式 Web 应用开发记录<三>预初始化属性 经过一段时间的开发和测试&#xff0c;我们成功地…
阅读更多...
java的工厂设备管理系统-计算机毕业设计源码16179

java的工厂设备管理系统-计算机毕业设计源码16179

摘要 在现代制造业中&#xff0c;高效的设备管理对于确保生产过程的顺利进行至关重要。为了满足工厂对于设备管理的需求&#xff0c;我们设计并实现了一个基于 Java 的工厂设备管理系统。 该系统旨在提供一个全面、可靠且易于使用的解决方案&#xff0c;以帮助工厂有效地管理…
阅读更多...
temu a4接口 逆向

temu a4接口 逆向

声明(lianxi a15018601872) 本文章中所有内容仅供学习交流使用&#xff0c;不用于其他任何目的&#xff0c;抓包内容、敏感网址、数据接口等均已做脱敏处理&#xff0c;严禁用于商业用途和非法用途&#xff0c;否则由此产生的一切后果均与作者无关&#xff01; 前言(lianxi …
阅读更多...
【️讲解下Laravel为什么会成为最优雅的PHP框架？】

【️讲解下Laravel为什么会成为最优雅的PHP框架？】

&#x1f3a5;博主&#xff1a;程序员不想YY啊 &#x1f4ab;CSDN优质创作者&#xff0c;CSDN实力新星&#xff0c;CSDN博客专家 &#x1f917;点赞&#x1f388;收藏⭐再看&#x1f4ab;养成习惯 ✨希望本文对您有所裨益&#xff0c;如有不足之处&#xff0c;欢迎在评论区提出…
阅读更多...
为什么进口主食冻干那么高贵？必入榜主食冻干总结分享

为什么进口主食冻干那么高贵？必入榜主食冻干总结分享

新手养猫人常常会有这样的疑问&#xff1a;为何进口主食冻干价格如此昂贵&#xff0c;但仍有大量养猫达人对其推崇备至&#xff1f;与国产主食冻干相比&#xff0c;进口产品的价格高出3-4倍之多&#xff0c;那么这高昂的价格背后&#xff0c;进口主食冻干是否真的值得推荐&…
阅读更多...
偏微分方程笔记（驻定与非驻定问题）

偏微分方程笔记（驻定与非驻定问题）

椭圆方程可以看成抛物方程 t → ∞ t\rightarrow\infty t→∞的情况。 抛物&#xff1a; 双曲&#xff1a;
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023