线程的同步与互斥

最新推荐文章于 2024-09-10 12:11:43 发布
最新推荐文章于 2024-09-10 12:11:43 发布
阅读量690 收藏 26
点赞数 13
文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_59605320/article/details/140274904
版权

多线程共享同一进程的地址空间。

优点： 线程之间通讯 就变得很容易

通过全局变量实现数据的共享和交换

缺点： 多个线程同时访问共享对象时需要引入同步和互斥的概念！！！

互斥： 同一时间 只能有一个任务（进程或线程）执行，谁先执行不确定！！

同步： 同一时间 只能有一个任务（进程或线程）执行，有顺序的执行！！

同步是 特殊的互斥！！！！

一、全局变量资源共享

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
int a = 10;

void *func(void *arg)
{
    while (1)
    {
        printf("%s a = %d\n", (char *)arg, a);
        sleep(1);
    }
    char *p = "任务1结束";
    pthread_exit((void *)p);
}
void *func1(void *arg)
{
    while (1)
    {
        printf("%s a = %d\n", (char *)arg, a);
        sleep(1);
    }
    char *p = "任务2结束";
    pthread_exit((void *)p);
}

int main(int argc, char const *argv[])
{
    // 创建两个线程
    pthread_t lwp1, lwp2;

    pthread_create(&lwp1, NULL, func, "---------");
    pthread_create(&lwp2, NULL, func1, "=========");
    sleep(3);
    while (1)
    {
        a++;
        sleep(1);
    }
    return 0;
}

二、互斥锁

用于 线程间 互斥！！

互斥锁是一种简单的加锁方式,用来控制共享资源的访问。

互斥锁 主要有两种状态： 加锁（lock） 和解锁 （unlock）

同一时刻，只能有一个任务上锁 ！！！其他任务阻塞 ---->访问临界资源前上锁（其他任务阻塞），访问结束 解锁（其他任务才能上锁）

死锁，访问前 上锁，访问后 不解锁！！！

三、互斥锁的操作流程

在访问共享资源前，对互斥锁进行加锁

在访问共享资源后，对互斥锁进行解锁

对互斥锁进行加锁后，任何试图再次对互斥锁加锁的任务 都会阻塞！！直到锁被释放。

四、互斥锁类型及其操作

互斥锁的数据类型： pthread_mutex_t

1.定义一把锁

pthread_mutex_t mutx;

2.初始化锁

#include <pthread.h>
//静态初始化不需要释放互斥锁，动态初始化必须释放互斥锁
//静态分配的互斥锁：
    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
//动态分配互斥锁:
int pthread_mutex_init(pthread_mutex_t *restrict mutex,
 const pthread_mutexattr_t *restrict attr);
功能：
   初始化互斥锁
参数：
   restrict mutex：互斥锁地址。类型是 pthread_mutex_t 。
   restrict attr：设置互斥量的属性，通常可采用默认属性，即可将 attr 设为 NULL。
       可以使用宏
            PTHREAD_MUTEX_INITIALIZER 静态初始化互斥锁，
            比如：pthread_mutex_t mutex =
PTHREAD_MUTEX_INITIALIZER;
            这种方法等价于使用 NULL 指定的 attr 参数调用
        pthread_mutex_init() 来完成动态初始化，不同之处在于 PTHREAD_MUTEX_INITIALIZER 宏不进行
错误检查。
返回值：
   成功返回0，成功申请的锁默认是打开的。
   失败返回非0。

使用方法

静态初始化:
pthread_mutex_t mutx = PTHREAD_MUTEX_INITIALIZER; 
动态初始化 ----> 推荐
pthread_mutex_t mutx;
pthread_mutex_init(&mutx,NULL);

3.销毁互斥锁

#include <pthread.h>
int pthread_mutex_destroy(pthread_mutex_t *mutex);
功能：
    销毁指定的一个互斥锁。互斥锁在使用完毕后，必须要对互斥锁进行销毁，以释放资源。
参数：
    mutex：互斥锁地址。
返回值:
    成功：0
    失败：非 0 错误码

pthread_mutex_destroy(&mutx);

4.上锁：访问临界资源前

有很多资源一次只能供一个任务使用。一次仅允许一个任务使用的资源称为临界资源 ---> 许多物理设备都属于临界资源，如输入机、打印机、磁带机等。

#include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);
功能：
    对互斥锁上锁，若互斥锁已经上锁，则调用者阻塞，直到互斥锁解锁后再上锁。
参数：
    mutex：互斥锁地址。
返回值：
    成功返回0，
    失败返回非0。

5.试着上锁

#include <pthread.h>
int pthread_mutex_trylock(pthread_mutex_t *mutex);
功能：
    调用该函数时，若互斥锁未加锁，则上锁，返回 0；
    若互斥锁已加锁，则函数直接返回失败，即 EBUSY
参数：
    mutex：互斥锁地址。
返回值：
    成功返回0
    失败返回非0。

6.解锁

#include <pthread.h>
int pthread_mutex_unlock(pthread_mutex_t *mutex);
功能：
    对指定的互斥锁解锁。
参数：
    mutex：互斥锁地址。
返回值：
    成功：0
    失败：非0 错误码

五、互斥锁的案例demo

1.多个任务之间 抢资源 不用互斥锁

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

void printf_string(void *str)
{
    char *p = (char *)str;
    int i = 0;
    while (p[i] != '\0')
    {
        printf("%c", p[i++]);
        fflush(stdout);
        sleep(1);
    }
}

void *func(void *arg)
{
    printf_string(arg);
}
void *func1(void *arg)
{
    printf_string(arg);
}

int main(int argc, char const *argv[])
{
    // 创建两个线程
    pthread_t lwp1, lwp2;

    pthread_create(&lwp1, NULL, func, "hello world?");
    pthread_create(&lwp2, NULL, func1, "nihao chengdu!");

    pthread_join(lwp1, NULL);
    pthread_join(lwp2, NULL);
    return 0;
}

2.多任务之间 使用互斥锁

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

// 定义锁
pthread_mutex_t mutx;

void printf_string(void *str)
{
    char *p = (char *)str;
    int i = 0;
    while (p[i] != '\0')
    {
        printf("%c", p[i++]);
        fflush(stdout);
        sleep(1);
    }
}

void *func(void *arg)
{
    // 上锁
    pthread_mutex_lock(&mutx);
    // 使用临界资源 标准输出
    printf_string(arg);
    // 解锁
    pthread_mutex_unlock(&mutx);
}
void *func1(void *arg)
{
    // 上锁
    pthread_mutex_lock(&mutx);
    // 使用临界资源 标准输出
    printf_string(arg);
    // 解锁
    pthread_mutex_unlock(&mutx);
}

int main(int argc, char const *argv[])
{
    // 初始化锁
    pthread_mutex_init(&mutx, NULL);
    // 创建两个线程
    pthread_t lwp1, lwp2;

    pthread_create(&lwp1, NULL, func, "hello world?");
    pthread_create(&lwp2, NULL, func1, "nihao chengdu!");

    pthread_join(lwp1, NULL);
    pthread_join(lwp2, NULL);
    // 销毁锁
    pthread_mutex_destroy(&mutx);
    return 0;
}

3.死锁：不允许

六、读写锁

如果只有两个任务，一个读 一个写！！ -----> 互斥锁

如果3个或3个以上 任务， 多个读，多个写 ----> 建议用读写锁！！

1、读写锁的概念

多个任务读操作不受影响， 如果有任务写 其他多个读任务（不允许读，也不允许写）， 如果多个任务在读，读的任务不受影响，但是写的任务（不允许写）。

一个任务读操作时，其它任务可以读，不能写，一个或多个任务上读锁成功，其它任务可以上读锁，不能上写锁

一个任务写操作时，其它任务不能读/写，一个任务上写锁成功时，其它任务不能上读锁和写锁

再简单点：

1）如果某线程申请了读锁，其它线程可以再申请读锁，但不能申请写锁。

2）如果某线程申请了写锁，其它线程不能申请读锁，也不能申请写锁。

POSIX 定义的读写锁的数据类型是： pthread_rwlock_t

2.操作流程及API

1.定义锁

pthread_rwlock_t  rwlock;

2.初始化读写锁

#include <pthread.h> 
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr); 
功能：
    用来初始化 rwlock 所指向的读写锁。
参数：
    rwlock: 指向要初始化的读写锁指针。
    attr：读写锁的属性指针。如果 attr 为 NULL 则会使用默认的属性初始化读写锁，否则使用指定
的 attr 初始化读写锁。
返回值:
    成功：0
    失败：非0
 
 静态初始化  
 pthread_rwlock_t my_rwlock = PTHREAD_RWLOCK_INITIALIZER; 
    这种方法等价于使用 NULL 指定的 attr 参数调用 pthread_rwlock_init() 来完成动态初始化，
    不同之
处在于 PTHREAD_RWLOCK_INITIALIZER 宏不进行错误检查。

3.销毁读写锁

#include <pthread.h>
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
功能：
    用于销毁一个读写锁，并释放所有相关联的资源（所谓的所有指的是由 pthread_rwlock_init() 自
动申请的资源） 。
参数：
    rwlock：读写锁指针。
返回值：
    成功：0
    失败：非 0 错误码

4.申请读锁：写会阻塞

#include <pthread.h>
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
功能：
    以阻塞方式在读写锁上获取读锁（读锁定）。
    如果没有写者持有该锁，并且没有写者阻塞在该锁上，则调用线程会获取读锁。
    如果调用线程未获取读锁，则它将阻塞直到它获取了该锁。一个线程可以在一个读写
锁上多次执行读锁定。
    线程可以成功调用 pthread_rwlock_rdlock() 函数 n 次，但是之后该线程必须调用
    pthread_rwlock_unlock() 函数 n 次才能解除锁定。
参数：
    rwlock：读写锁指针。
返回值：
    成功：0
    失败：非 0 错误码

5.试着申请读锁

int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
用于尝试以非阻塞的方式来在读写锁上获取读锁。
如果有任何的写者持有该锁或有写者阻塞在该读写锁上，则立即失败返回。

6.申请读锁：读写都阻塞

#include <pthread.h>
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
功能：
    在读写锁上获取写锁（写锁定）。
    如果没有写者持有该锁，并且没有写者读者持有该锁，则调用线程会获取写锁。
    如果调用线程未获取写锁，则它将阻塞直到它获取了该锁。
参数：
    rwlock：读写锁指针。
返回值：
    成功：0
    失败：非 0 错误码

7.试着申请写锁

int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
    用于尝试以非阻塞的方式来在读写锁上获取写锁。
    如果有任何的读者或写者持有该锁，则立即失败返回。

8.读写锁解锁

#include <pthread.h>
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
功能：
    无论是读锁或写锁，都可以通过此函数解锁。
参数：
    rwlock：读写锁指针。
返回值：
    成功：0
    失败：非 0 错误码

3.读写锁案例demo

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
int a = 10;
pthread_rwlock_t rwlock;
void *rfunc(void *arg)
{
    while (1)
    {
        // 申请读锁
        pthread_rwlock_rdlock(&rwlock);
        // 读资源
        printf("%s a = %d\n", (char *)arg, a);
        // 解锁
        pthread_rwlock_unlock(&rwlock);
        sleep(1);
    }
}
void *rfunc1(void *arg)
{
    while (1)
    {
        // 申请读锁
        pthread_rwlock_rdlock(&rwlock);
        // 读资源
        printf("%s a = %d\n", (char *)arg, a);
        // 解锁
        pthread_rwlock_unlock(&rwlock);
        sleep(1);
    }
}
void *wfunc(void *arg)
{
    while (1)
    {
        // 申请写锁
        pthread_rwlock_wrlock(&rwlock);
        // 写资源
        a++;
        printf("%s a = %d\n", (char *)arg, a);
        // 解锁
        pthread_rwlock_unlock(&rwlock);
        sleep(1);
    }
}

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

    // 创建两个线程
    pthread_t lwp1, lwp2, lwp3;

    pthread_create(&lwp1, NULL, rfunc, "线程1 读数据：");
    pthread_create(&lwp2, NULL, rfunc1, "线程2 读数据：");
    pthread_create(&lwp3, NULL, wfunc, "线程3 写入数据：");

    pthread_join(lwp1, NULL);
    pthread_join(lwp2, NULL);
    pthread_join(lwp3, NULL);

    // 销毁锁
    pthread_rwlock_destroy(&rwlock);
    return 0;
}

七、条件变量：条件判断

1.条件变量概述

与互斥锁不同，条件变量是用来等待而不是用来上锁的，条件变量本身不是锁！

条件变量用来自动阻塞一个线程，直到某特殊情况发生为止。

通常条件变量和互斥锁同时使用。 条件变量的两个动作：

条件不满, 阻塞线程

当条件满足, 通知阻塞的线程开始工作。

条件变量的类型: pthread_cond_t。

2.条件变量的操作及API

1.定义条件变量

//定义条件变量
pthread_cond_t cond;

2.条件变量初始化

静态初始化：
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
动态初始化
#include <pthread.h>
int pthread_cond_init(pthread_cond_t *cond,
const pthread_condattr_t *restrict attr);
功能：
    初始化一个条件变量
参数：
    cond：指向要初始化的条件变量指针。
    attr：条件变量属性，通常为默认值，传 NULL 即可
返回值：
    成功：0
    失败：非 0 错误号

3.销毁条件变量

#include <pthread.h>
int pthread_cond_destroy(pthread_cond_t *cond);
功能：
    销毁一个条件变量
参数：
    cond：指向要初始化的条件变量指针
返回值：
    成功：0
    失败：非 0 错误

4.等待条件满足：阻塞等待条件满足

#include <pthread.h>
int pthread_cond_wait(pthread_cond_t *cond,
pthread_mutex_t *mutex);
功能：
    阻塞等待一个条件变量
        a) 阻塞等待条件变量 cond（参 1）满足
        b) 释放已掌握的互斥锁（解锁互斥量）相当于 pthread_mutex_unlock(&mutex);
            a) b) 两步为一个原子操作 ---> 不可中断。
        c) 当被唤醒，pthread_cond_wait 函数返回时，解除阻塞并重新申请获取互斥锁
pthread_mutex_lock(&mutex);
参数：
    cond：指向要初始化的条件变量指针
    mutex：互斥锁
返回值：
    成功：0
    失败：非 0 错误号

int pthread_cond_timedwait(pthread_cond_t *restrict cond,


pthread_mutex_t *restrict mutex,
const struct timespec *restrict abstime);
功能：
    限时等待一个条件变量
参数：
    cond：指向要初始化的条件变量指针
    mutex：互斥锁
    abstime：绝对时间
返回值：
    成功：0
    失败：非 0 错误号

5.唤醒等待在条件变量上阻塞的线程

#include <pthread.h>
int pthread_cond_signal(pthread_cond_t *cond);
功能：
    唤醒至少一个阻塞在条件变量上的线程
参数
    cond：指向要初始化的条件变量指
返回值
    成功：0
    失败：非 0 错误号

int pthread_cond_broadcast(pthread_cond_t *cond);
功能：
    唤醒全部阻塞在条件变量上的线程
参数：
    cond：指向要初始化的条件变量指针
返回值：
    成功：0
    失败：非 0 错误号

3.条件变量的工作原理

4.条件变量案例：生产者消费者

消费者 买货物 生产者生产货物

如果 货物数量为 0 不能买

当 货物 数量超过 50 ,生产者 不生产

------> 生产者 2个 消费者 3个

生产者 做了调整，先不着急上锁 ，先判断数量 才上锁

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
// 锁
pthread_mutex_t mutx;
// 条件变量
pthread_cond_t cond;
// 产生数量
int count = 3;

// 消费者
void *xf_func(void *arg1)
{
    while (1)
    {
        // 进仓库买货物 上锁
        pthread_mutex_lock(&mutx);
        while (count == 0)
        {
            // 没有货物
            printf("%s: 仓库没货了！ 等待生产\n", (char *)arg1);
            // 条件变量阻塞等待---> 1、解锁 2、等条件满足的通知 3、上锁
            pthread_cond_wait(&cond, &mutx);
        }
        // 买产品
        count -= 1;
        printf("%s 消费了1个产品，当前：%d\n", (char *)arg1, count);
        // 买完后 解锁
        pthread_mutex_unlock(&mutx);
        // 使用产品
        sleep(2);
    }
}

// 生产者
void *sc_func(void *arg)
{
    while (1)
    {
        // 判断产品数量
        while (count >= 10)
        {
            printf("产品太多：%d,暂停生产,休息2s\n", count);
            sleep(2);
        }
        // 产品数量 < 10；
        // 生产产品
        sleep(1);
        // 产品拿到仓库
        //  给仓库上锁
        pthread_mutex_lock(&mutx);
        count += 1;
        printf("%s 生产的产品已经搬到仓库，当前数量：%d\n", (char *)arg, count);

        // 通知消费者 当前仓库 有货物
        pthread_cond_broadcast(&cond);
        // 把货物搬到仓库后 解锁
        pthread_mutex_unlock(&mutx);
    }
}

int main(int argc, char const *argv[])
{
    // 如果只用一维数组  名字会覆盖
    char name1[3][32] = {0};
    char name2[2][32] = {0};
    // 初始化锁
    pthread_mutex_init(&mutx, NULL);
    // 条件变量初始化
    pthread_cond_init(&cond, NULL);
    // 创建3个消费者
    pthread_t xf[3];
    for (int i = 0; i < 3; i++)
    {
        sprintf(name1[i], "xf_%d", i);
        pthread_create(xf + i, NULL, xf_func, (void *)name1[i]);
    }
    // 创建2个生产者
    pthread_t sc[2];
    for (int i = 0; i < 2; i++)
    {
        sprintf(name2[i], "sc_%d", i);
        pthread_create(sc + i, NULL, sc_func, (void *)name2[i]);
    }

    // 回收生产者线程
    for (int i = 0; i < 2; i++)
    {
        pthread_join(sc[i], NULL);
    }
    // 回收消费者线程
    for (int i = 0; i < 3; i++)
    {
        pthread_join(xf[i], NULL);
    }
    // 销毁锁
    pthread_mutex_destroy(&mutx);
    // 销毁条件变量
    pthread_cond_destroy(&cond);
    return 0;
}

养猪专业指导员
关注
  • 13
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
【操作系统】多线程同步与互斥
兔子王
11-04 2423
【实验内容】（1）编写程序，使用Linux操作系统中的信号量机制模拟实现生产者-消费者问题。设有一个生产者和一个消费者，缓冲区可以存放产品，生产者不断生成产品放入缓冲区，消费者不断从缓冲区中取出产品，消费产品。（2）以上实验只模拟了一个产品的放入与取出，请修改代码，以模拟实现多个产品的放入与取出。
【3】c++多线程技术之线程同步与互斥
以道御术
04-12 395
线程安全问题与数据竞争是多线程编程中的重要概念。在C++中，线程安全问题主要涉及到多个线程对共享数据的访问，如果多个线程同时访问同一块内存区域，并且至少有一个线程对该区域进行写入操作，那么就可能发生数据竞争（Data Race）。数据竞争可能导致程序行为不可预测，甚至可能引发严重的错误。为了避免数据竞争，我们需要使用一些同步机制，如互斥锁（Mutex）和条件变量（Condition Variable）等。下面是一个简单的例子，展示了如何使用C++的std::mutex。
Linux系统编程——多任务的同步与互斥
秋叶原 && Mike || 麦克
05-30 1万+
同步是一种更为复杂的互斥，而互斥是一种特殊的同步。也就是说互斥是两个任务之间不可以同时运行，他们会相互排斥，必须等待一个线程运行完毕，另一个才能运行，而同步也是不能同时运行，但他是必须要安照某种次序来运行相应的线程（也是一种互斥）！因此互斥具有唯一性和排它性，但互斥并不限制任务的运行顺序，即任务是无序的，而同步的任务之间则有顺序关系。
windows系统c++多线程开发
m0_37170593的博客
02-20 3363
线程的一些基本概念 一、线程的基本概念。 基本概念：线程，即轻量级进程（LWP:LightWeight Process），是程序执行流的最小单元。一个标准的线程由线程ID、当前指令指针（PC），寄存器集合和堆栈组成。线程是进程中的一个实体，是被系统独立调度和分派的基本单位。线程不拥有系统资源，近拥有少量运行必须的资源。 二、线程的基本状态。 基本状态：就绪、阻塞和运行三种基本状态。 就绪
多线程的同步与互斥（互斥锁、条件变量、读写锁、自旋锁、信号量）
热门推荐
青萍之末的博客
10-06 7万+
一、同步与互斥的概念   现代操作系统基本都是多任务操作系统，即同时有大量可调度实体在运行。在多任务操作系统中，同时运行的多个任务可能： 都需要访问/使用同一种资源； 多个任务之间有依赖关系，某个任务的运行依赖于另一个任务。 【同步】：   是指散步在不同任务之间的若干程序片断，它们的运行必须严格按照规定的某种先后次序来运行，这种先后次序依赖于要完成的特定的任务。最基本的场景就是：两个或两个以...
Linux下的多线程编程二（线程的同步与互斥）
snow_5288的博客
06-14 4552
一、什么叫做线程的同步与互斥？为什么需要同步与互斥？ 二、互斥量 三、条件变量 四、信号量 五、读写锁
【Linux】多线程同步与互斥
gangaue的博客
01-25 934
这篇文章给大家带来线程同步与互斥的学习！！！
Python技术如何进行线程同步与互斥.docx
07-30
在Python编程中，线程同步与互斥是实现多线程安全和高效运行的关键技术。线程同步主要解决的问题是当多个线程访问共享资源时，如何保证数据的一致性和避免竞态条件。Python提供了多种工具来实现这一目标，包括互斥锁...
Python实现的多线程同步与互斥锁功能示例
09-21
### Python实现的多线程同步与互斥锁功能详解 在多线程编程中，确保线程间的正确同步是至关重要的。特别是在多个线程访问共享资源时，如果没有正确的同步机制，可能会导致竞态条件（race condition），从而引发不可...
C语言猜数小游戏
m0_62872215的博客
09-05 457
用C语言写一个猜数小游戏，要求数字是整数小于1000且随即生成，玩家需要输入数字，程序给出提示，直至最终猜到最终正确的数字，游戏结束。
C语言 | Leetcode C语言题解之第393题UTF-8编码验证
m0_59237910的博客
09-09 365
C语言 | Leetcode C语言题解之第393题UTF-8编码验证
C/C++的自由落体运动
m0_64395065的博客
09-06 398
一个球从100m高度自由落下,每次落地后反跳回原来高度的一半,再落下,再反弹.求它在第N次落地时共经过多少米?
23. C 语言，%d 和 %i的区别
dingdongkk~博客
09-05 228
都用来打印十进制整数。
【最新华为OD机试E卷-支持在线评测】查找充电设备组合(200分)-多语言题解-(Python/C/JavaScript/Java/Cpp)
春秋招笔试突围
09-06 242
🍭 大家好这里是，一枚热爱算法的程序员✨ 本系列打算持续跟新的三语言AC题解💻 ACM金牌🏅️团队| 多次AK大厂笔试 ｜ 编程一对一辅导。
CCF刷题计划——梯度求解（map表示公式）
Caspiannn的博客
09-10 322
参考。
Matlab界面GUI设计的车牌定位[Matlab界面GUI设计].zip
最新发布
09-10
linux常用命令大全
【独家首发】基于matlab沙猫群算法SCSO-GMDH风电数据回归预测【含Matlab源码 7530期】.zip
09-10
CSDN海神之光上传的全部代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：Main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除Main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 智能优化算法优化GMDH回归预测系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO优化GMDH回归预测 4.4.2 粒子群算法PSO/蛙跳算法SFLA优化GMDH回归预测 4.4.3 灰狼算法GWO/狼群算法WPA优化GMDH回归预测 4.4.4 鲸鱼算法WOA/麻雀算法SSA优化GMDH回归预测 4.4.5 萤火虫算法FA/差分算法DE优化GMDH回归预测 4.4.6 其他优化算法优化GMDH回归预测
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值