Day1--FreeRTOS简介及多任务点灯、多任务传参、Mutex

已于 2022-11-30 18:34:30 修改
阅读量2.1k 收藏 26
点赞数 4
分类专栏： ESP32 FreeRTOS 文章标签： FREERTOS
于 2022-09-18 16:04:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45355603/article/details/126914079
版权

实时操作系统（Real Time Operating System，简称RTOS）

Arduino任务执行流程：单线程执行任务

 RTOS：可以同时执行所有Task，每个任务都有自己的循环

 操作系统排行：LINUX        WINDOWS        FREERTOS

ESP32架构：ESP32-IDF的底层运行的就是freestos

默认core1：编写程序        core2：蓝牙、wifi功能

任务优先级：

优先级高的任务先执行，比如中断

实时性要求比较高的任务用高优先级

实时性要求比较低的任务用低优先级，比如屏幕刷新，数据显示

多任务其实是CPU分时完成的，1ms执行一个任务，频率1Khz

freertos传递参数只能采用指针的方式，重点：结构体和指针

内存管理：任务到底需要多少内存？分配空间大小1024*N

任务优先级：

任务的绝对频率：vTaskDelayUntil

软件定时器Timer：一次性的，周期性的，非常有用

freertos提供的三种数据结构：队列单数据、流媒体缓存、消息缓存

多任务全局变量：对资源进行保护

二进制信号量：0和1

计数信号量：0~N

事件组等待：

事件组同步：

任务通知

多任务点灯

1GB（GigaByte）=1024MB

1MB（MegaByte）=1024KB

1KB（KiloByte）=1024B(字节)

1B（byte）字节=8Bit（binary digit）位

#include <Arduino.h>

void task1(void *pt)
{
  pinMode(23, OUTPUT);
  while (1)
  {
    digitalWrite(23, !digitalRead(23));
    vTaskDelay(500);
  }
}

void task2(void *pt)
{
  pinMode(21, OUTPUT);
  while (1)
  {
    digitalWrite(21, !digitalRead(21));
    vTaskDelay(700);
  }
}

void setup()
{
  // 参数1：task;  参数2：任务备注;  参数3:内存分配空间
  // 参数4：传递参数；  参数5：任务优先级； 参数6：对任务删除管理
  xTaskCreate(task1, "Blink 23", 1024, NULL, 1, NULL);
  xTaskCreate(task2, "Blink 21", 1024, NULL, 1, NULL);
}

void loop()
{
}

 通过空指针类型给task传递单个参数

#include <Arduino.h>

byte led1 = 21;
byte led2 = 22;
byte led3 = 23;

void task1(void *pt) // 接收的为空指针
{
  byte led_pin = *(byte *)pt; // 解耦
  pinMode(led_pin, OUTPUT);
  while (1)
  {
    digitalWrite(led_pin, !digitalRead(led_pin));
    vTaskDelay(500);
  }
}

void setup()
{
  // 参数1：task;  参数2：任务备注;  参数3:内存分配空间
  // 参数4：传递参数；  参数5：任务优先级； 参数6：对任务删除管理
  xTaskCreate(task1, "Blink 21", 1024, (void *)&led1, 1, NULL);
}

void loop()
{
}

给任务传递多个参数（重要）

通过空指针类型传递结构体

/*向任务中进行传多个参数*/
#include <Arduino.h>

typedef struct
{
  byte pin;
  int delayTime;
} LEDFLASH;
LEDFLASH led1, led2;

void ledFlash(void *pt)
{
  LEDFLASH *ptLedFlash = (LEDFLASH *)pt; // 数据解耦
  byte pin = ptLedFlash->pin;
  int delayTime = ptLedFlash->delayTime;

  pinMode(pin, OUTPUT);
  while (1)
  {
    digitalWrite(pin, !digitalRead(pin));
    vTaskDelay(delayTime);
  }
}

void setup()
{
  /*局部变量，结构体赋值一定要在setup里面，在外面会出错
  在外边，需要写成全局变量的形式*/
  led1.pin = 23;
  led1.delayTime = 1000;
  led2.pin = 21;
  led2.delayTime = 3000;

  xTaskCreate(ledFlash, "***", 1024, (void *)&led1, 1, NULL);
  xTaskCreate(ledFlash, "***", 1024, (void *)&led2, 1, NULL);
}
void loop() {}

可以通过void *pt空指针的方式传递单个参数，可以通过void *struct传递多个参数 

通过结构体传址的方式进行数据传输

任务共享全局变量（重要）

任务1：对商品的数量进行计算

任务2：显示商品的数量

重点：写操作只能有一个，读操作可以有多个

/*任务之间通过全局变量进行数据传递*/
#include <Arduino.h>

/*养成良好习惯，被多进程和中断调用的变量使用 volatile修饰符*/
/*ESP32是32位的，一定要定义为uint32_t，因为同一个变量占用CPU同一个通道
*/
volatile u_int32_t inventory = 100; // 总库存
volatile u_int32_t retailCount = 0; // 线下销售量

/*任务1：库存数量变化计算*/
void retailTask(void *pt)
{
  while (1)
  {
    /*以下实现了带有随机延迟的库存减1
    等效为 inventory--; retailCount++;*/
    u_int32_t inv = inventory;
    for (byte i; i < random(10, 100); i++)
    {
      vTaskDelay(i);
    }
    if (inventory > 0)
    {
      inventory = inv - 1;
      retailCount++;
    }
  };
  vTaskDelay(10);
}

/*任务2：显示库存和线下销售量*/
void showTask(void *pt)
{
  while (1)
  {
    printf("Inventory : %d\n", inventory);
    printf("   Retail :%d\n", retailCount);
    if (inventory == 0)
    {
      printf("\n------sales summary-------\n");
      printf("totail sales: %d\n\n", retailCount);
    }
    vTaskDelay(1000);
  }
}

void setup()
{
  Serial.begin(115200);
  xTaskCreate(retailTask, "库存数量变化", 1024 * 4, NULL, 1, NULL);
  xTaskCreate(showTask, "数量显示", 1024 * 4, NULL, 1, NULL);
}
void loop() {}

使用相互排斥 Mutex 来解决竞争冒险Race Condition（重要）

注意：在对全局变量数据进行访问时，使用Mutex，不能在程序一开始就获取钥匙，在if里对共享资源计算完就立刻释放钥匙，不要把释放钥匙语句放到任务最后

在上面一个示例中，数据计算时容易出现竞争冒险的问题，采用Mutex对数据进行保护，解决多个任务同时对共享资源访问造成的问题。

Mutex互斥锁，先把共享资源放进保险柜里（只有一把钥匙），任务（例如task1）先申请钥匙，再对共享资源进行访问，Task2如果想要访问共享资源，需要等到task1归还钥匙。

使用步骤：

  1. 创建一把锁, create
  2. 在指定时间内获取钥匙, take
  3. 归还钥匙，give

  语法：

  SemaphoreHandle_t xHandler; 创建Handler

  xHandler = xSemaphoreCreateMutex(); 创建一个MUTEX 返回NULL，或者handler

  xSemaphoreGive(xHandler); 释放

  xSemaphoreTake(xHanlder, timeout); 指定时间内获取信号量 返回pdPASS, 或者pdFAIL

  理解方法：

  MUTEX的工作原理可以想象成

  共享的资源被锁在了一个箱子里，只有一把钥匙，有钥匙的任务才能对改资源进行访问

/*
  程序： Tasks之间数据传递
        有多任务同时写入，或者数据大小超过cpu内存通道时，或者对共享资源的访问时候，需要有防范机制
        使用MUTEX对数据对Cirtical Section的内容进行保护
        可以想象成MUTEX就是一把锁

  公众号：孤独的二进制

  语法：
  SemaphoreHandle_t xHandler; 创建Handler
  xHandler = xSemaphoreCreateMutex(); 创建一个MUTEX 返回NULL，或者handler
  xSemaphoreGive(xHandler); 释放
  xSemaphoreTake(xHanlder, timeout); 指定时间内获取信号量 返回pdPASS, 或者pdFAIL

  理解方法：
  MUTEX的工作原理可以想象成
  共享的资源被锁在了一个箱子里，只有一把钥匙，有钥匙的任务才能对改资源进行访问
*/

// 养成良好习惯，被多进程和中断调用的变量使用 volatile 修饰符
volatile uint32_t inventory = 100; //总库存
volatile uint32_t retailCount = 0; //线下销售量
volatile uint32_t onlineCount = 0; //线上销售量

SemaphoreHandle_t xMutexInventory = NULL; //创建信号量Handler

TickType_t timeOut = 1000; //用于获取信号量的Timeout 1000 ticks


void retailTask(void *pvParam) {
  while (1) {

    // 在timeout的时间内如果能够获取就继续
    // 通俗一些：获取钥匙
    if (xSemaphoreTake(xMutexInventory, timeOut) == pdPASS) {
      //被MUTEX保护的内容叫做 Critical Section


      //以下实现了带有随机延迟的 inventory减1；
      //等效为 inventory--； retailCount++；
      uint32_t inv = inventory;
      for (int i; i < random(10, 100); i++) vTaskDelay(pdMS_TO_TICKS(i));
      if (inventory > 0) {
        inventory = inv - 1;
        retailCount++;

        //释放钥匙
        xSemaphoreGive(xMutexInventory);
      } else {
        //无法获取钥匙
      }


    };

    vTaskDelay(100); //老板要求慢一些，客户升级后，可以再加快速度
  }
}

void onlineTask(void *pvParam) {
  while (1) {

    // 在timeout的时间内如果能够获取二进制信号量就继续
    // 通俗一些：获取钥匙
    if (xSemaphoreTake(xMutexInventory, timeOut) == pdPASS) {
      //被MUTEX保护的内容叫做 Critical Section
      //以下实现了带有随机延迟的 inventory减1；
      //等效为 inventory--； retailCount++；
      uint32_t inv = inventory;
      for (int i; i < random(10, 100); i++) vTaskDelay(pdMS_TO_TICKS(i));
      if (inventory > 0) {
        inventory = inv - 1;
        onlineCount++;

        //释放钥匙
        xSemaphoreGive(xMutexInventory);
      } else {
        //无法获取钥匙
      }
    };

    vTaskDelay(100); //老板要求慢一些，客户升级后，可以再加快速度
  }
}


void showTask(void *pvParam) {
  while (1) {

    printf("Inventory : %d\n", inventory);
    printf("  Retail : %d, Online : %d\n", retailCount, onlineCount);


    if (inventory == 0 ) {
      uint32_t totalSales = retailCount + onlineCount;
      printf("-----SALES SUMMARY-----\n");
      printf("  Total Sales:  %d\n", totalSales);
      printf("  OverSales:  %d\n", 100 - totalSales);
    }
    vTaskDelay(pdMS_TO_TICKS(1000));
  }
}

void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);

  xMutexInventory = xSemaphoreCreateMutex(); //创建MUTEX

  if (xMutexInventory == NULL) {
    printf("No Enough Ram, Unable to Create Semaphore.");
  } else {
    xTaskCreate(onlineTask,
                "Online Channel",
                1024 * 4,
                NULL,
                1,
                NULL);
    xTaskCreate(retailTask,
                "Retail Channel",
                1024 * 4,
                NULL,
                1,
                NULL);
    xTaskCreate(showTask,
                "Display Inventory",
                1024 * 4,
                NULL,
                1,
                NULL);
  }

}

void loop() {
}

 MUTEX实例

使用MPU6050传感器时，可以创建一个结构体存储7个数据（芯片温度、3轴角速度、3轴角度）

MPU6050的数据写进结构体中，然后屏幕进行读取

两个任务，一个读，一个写，一定要用MUTEX进行数据保护

原因：不管是读操作还是写操作，它都是一个独立的task，这样用freertos运行多任务就会出现某个任务因为分配的时间到了，对数据的处理被迫中断，然后另一个任务又开始对数据进行操作，而这时的数据很可能只有一半是操作完成，另一半还未完成的状态，这样的数据状态会产生很大的运算错误，非常危险。所以一个参数只要有两个或以上task要对其进行操作，就必须上钥匙。

/*
   程序：  MPU6050 & MUTEX
   公众号：孤独的二进制
*/
#include <Arduino.h>
#include <Adafruit_MPU6050.h>
#include <Adafruit_Sensor.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27, 20, 4);

Adafruit_MPU6050 mpu;
Adafruit_Sensor *mpu_temp, *mpu_accel, *mpu_gyro;

typedef struct
{
  float temp;
  float accX;
  float accY;
  float accZ;
  float gyroX;
  float gyroY;
  float gyroZ;
} MPU6050;

MPU6050 mpu6050;

SemaphoreHandle_t xMutexMPU6050 = NULL; //创建信号量Handler
TickType_t timeOut = 1000;              //用于获取信号量的Timeout 1000 ticks

void mpu6050Task(void *pvParam)
{

  mpu.begin();

  mpu_temp = mpu.getTemperatureSensor();
  mpu_temp->printSensorDetails();

  mpu_accel = mpu.getAccelerometerSensor();
  mpu_accel->printSensorDetails();

  mpu_gyro = mpu.getGyroSensor();
  mpu_gyro->printSensorDetails();

  sensors_event_t accel;
  sensors_event_t gyro;
  sensors_event_t temp;

  while (1)
  {

    if (xSemaphoreTake(xMutexMPU6050, timeOut) == pdPASS)
    {

      //获取MPU数据
      mpu_temp->getEvent(&temp);
      mpu_accel->getEvent(&accel);
      mpu_gyro->getEvent(&gyro);

      mpu6050.temp = temp.temperature;
      mpu6050.accX = accel.acceleration.x;
      mpu6050.accY = accel.acceleration.y;
      mpu6050.accZ = accel.acceleration.z;
      mpu6050.gyroX = gyro.gyro.x;
      mpu6050.gyroY = gyro.gyro.y;
      mpu6050.gyroZ = gyro.gyro.z;

      xSemaphoreGive(xMutexMPU6050); //释放钥匙
    }
    else
    {
      // Unable to obtain MUTEX
    }

    vTaskDelay(500);
  }
}

void lcdTask(void *ptParam)
{ // LCD任务主体

  lcd.init();
  lcd.backlight();

  //定义是 2004 LCD
  byte lcdLine = 4;
  byte lcdChar = 20;

  //创建一个二维的的数组
  //注意长度是 lcdChar+1 最后还有一个位置要给换行符
  char line0[lcdChar + 1], line1[lcdChar + 1], line2[lcdChar + 1], line3[lcdChar + 1];
  char *line[] = {
      line0,
      line1,
      line2,
      line3,
  };

  while (1)
  {

    if (xSemaphoreTake(xMutexMPU6050, timeOut) == pdPASS)
    {

      // 组合数据
      sprintf(line0, "     MPU6050 %d", xTaskGetTickCount() / 100);
      sprintf(line1, " Temperature  %.2f", mpu6050.temp);
      sprintf(line2, " ACC  %.2f %.2f %.2f", mpu6050.accX, mpu6050.accY, mpu6050.accZ);
      sprintf(line3, " GYRO %.2f %.2f %.2f", mpu6050.gyroX, mpu6050.gyroY, mpu6050.gyroZ);

      xSemaphoreGive(xMutexMPU6050); //释放钥匙
    }
    else
    {
      // Unable to obtain MUTEX
    }

    // 显示数据
    for (int i = 0; i < 4; i++)
    {
      lcd.setCursor(0, i);
      lcd.print(line[i]);
    }

    vTaskDelay(1000);
  }
}

void setup()
{
  Serial.begin(115200);

  xMutexMPU6050 = xSemaphoreCreateMutex(); //创建MUTEX

  xTaskCreate(mpu6050Task, "MPU6050", 1024 * 8, NULL, 1, NULL);
  vTaskDelay(1000); //让MPU6050提前先运行一秒获取第一笔数据
  xTaskCreate(lcdTask, "lcd", 1024 * 8, NULL, 1, NULL);
}

void loop() {}
⁢稚子
关注
  • 4
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ESP32-IDF开发实例-FreeRTOS任务参数传递
视觉与物联智能
06-07 1831
任务参数 在前面的实例中 ESP32开发实例-FreeRTOS任务创建 ESP32开发实例-FreeRTOS在指定CPU中创建并运行任务 我们成功在创建并运行了任务，那么如何将参数传递给任务？这就是本实例将要介绍的内容。 FreeRTOS的xTaskCreate函数和xTaskCreatePinnedToCore函数支持在创建任务时，传递任务参数。 1、硬件准备 NodeMCU ESP32-S V3.0开发板一块 数据线一条 2、软件准备 vscode ESP-IDF的vscode扩展 在vs
全局变量弊端
maosql
08-14 1163
@[TOC]全局变量的弊端 在没有操作系统概念之前，我个人写程序真的是全局变量满天飞，简直是内部变量都不想定义，想到一个变量，只要没有特别要求，不过脑子直接就是全局变量，感觉很好用，方便简单，其他模块需要使用的话直接extern过去，感觉美滋滋。 最近学习单片机FreeRTOS（软件开发一样适用）时候学到消息队列忽然意识到全局变量的危害性，现在我们写一个小工程可能都不在意，但是当我们写稍微大一点的工程的时候 必须 必须 必须 重视的一件事情，因为感觉重要所以单独写出来，方便给看到的朋友提个醒 下面是我这个章
FreeRTOS(ESP32)学习日记004-使用相互排斥 Mutex 来解决竞争冒险
weixin_58392839的博客
03-04 1110
在esp32的FreeRTOS中使用互斥量Mutex解决竞争冒险问题（ArduinoIDE）
FreeRTOS——互斥量篇
最新发布
顺顺崽的博客
07-10 719
互斥量（Mutex）是一种同步机制，用于在并发编程环境中保护共享资源，确保在任意时间只有一个任务能够访问该资源。它的名称来源于“互斥”，意即互斥量可以互相排斥，以防止资源被多个任务同时访问，从而避免数据竞争和不一致性问题。
freertos任务参数
weixin_48657573的博客
11-07 173
实现多个任务利用同一个函数，传进不同的任务参数，打印不同的任务内容。多个人用同一个电脑干不同工作，美工用电脑干美工，程序员用电脑敲代码。
FreeRtos mutex
p=f/s
03-16 391
FreeRtos中二值信号量、计数信号量、互斥锁、递归互斥锁都是用queue来实现的，mutex的使用涉及到任务优先级的提升和恢复，本篇以mutex的源码实现来分析其中原理。
ESP32 FreeRTOS-任务输入参数(2)
believe666的博客
10-06 1233
创建FreeRTOS时候的数据参数的传入
ESP32 FREERTOS多任务下I2C多个设备操作。
光密信息
03-01 1948
/互相信号量释放，释放IIC设备。注意驱动放在LVGL 驱动里面（需要源码私聊）设备注册也是放在这里。运行效果【ESP32S3工业HMI-哔哩哔哩】 https://b23.tv/HDT9TGe。这个经过调试两个原因可能，一个就是你的信号量释放位置有问题。task 8025任务也是一样，注意就是init时将设备注册屏蔽。开发过程中设备多任务争用问题通过互斥信号量解决。1、先出现设备注册冲突，屏蔽后一个I2C注册。另一个就是任务内存过小。
【FreeRTOS】多任务创建
凉开水白菜的博客
11-03 697
在上一章我们完成了工程的创建后面代码都会基于这个模板来编写，本章就学习一下实时操作系统给我们带来最直观的优势，多任务执行；
FreeRtos学习笔记-----------------任务状态等参数的查询
m0_46451722的博客
02-06 292
API函数展示 实验 实验内容：统计各个任务的运行时间和CPU使用时间占比等信息 所用API函数： void vTaskGetRunTimeStats( char * pcWriteBuffer ) PRIVILEGED_FUNCTION; /* pcWriteBuffer表示存储数据的内存 */ 首先，在FreeRtosConfig.h中 更改如下两个宏 #define configGENERATE_RUN_TIME_STATS 1 ...
2.freeRTOS使用互斥锁（Mutex）解决多任务竞争冒险
m0_60134435的博客
01-23 2800
竞争冒险是指当多个任务同时尝试修改共享资源时，由于执行顺序的不确定性，导致程序产生意外结果或未定义行为的情况。这可能包括数据损坏、逻辑错误或系统崩溃等问题。在嵌入式系统中，竞争冒险是一种常见的错误，特别是在没有适当同步机制的情况下。使用互斥锁是在多任务系统中确保共享资源安全访问的一种重要方法。通过适当地使用互斥锁，我们能够有效地避免竞争冒险，提高系统的稳定性和可靠性。在FreeRTOS中，互斥锁的简单实现使得开发者可以方便地应对多任务并发访问共享资源的挑战。
FreeRTOS传递结构体例程、传递数据指针例程.7z
08-01
使用FreeRTOS的消息队列传递结构体，值传递拷贝方式；传递指针所存储的地址，实现更高效的数据访问！
FreeRTOS笔记（六）互斥量mutex
m0_58575472的博客
03-14 1499
在上图中，有个低优先级的任务（LP）和高优先级的任务（HP），两个任务都可以对一个资源进行操作。如果一个保存数据的全局变量在被一个任务操作的过程中，又被多个更高优先级的任务抢占并处理，那么最后这个支离破碎的数据将会毫无意义，破坏了数据的独立完整性；从外部的视角看，此时中等优先级的任务MD相当于抢占了高优先级的任务HP，而高优先级的任务HP表现起来却又像是有最低的优先级。优先级继承会暂时提高获得互斥量的任务的优先级，使得含有互斥量的任务的优先级和想要获取互斥量的任务中的最高优先级一样。宏定义会再次打开中断。
关于FreeRTOS调用创建任务时传递参数
qq_1021154513
10-31 5854
先看函数原型 BaseType_t xTaskCreate( TaskFunction_t pxTaskCode, const char * const pcName, const configSTACK_DEPTH_TYPE usStackDepth, void * const pvParameters, ...
FreeRTOS初级篇----一个函数创建多个任务
山的博客
08-01 1167
FreeRTOS使用同一个函数创建多个任务。
FreeRTOS_互斥量(Mutex)
w237838的博客
11-11 361
资源还是共享的，线程间也还是竞争的，但通过锁将资源的访问变为互斥操作，而后与时间有关的错误也不会在产生了。互斥量是一种特殊的信号量，所以获取、释放、删除的API基本和信号量的通用。互斥量的获取、释放一般不在中断中执行，所以此处无FromISR结尾函数。每个线程在对资源操作前都尝试先加锁，成功加锁才能操作，操作结束后解锁。注意：同一个时刻，只能有一个线程持有该锁。使用互斥量时，先创建，然后获取，再释放。互斥量是一种特殊的二进制信号量。在有多线程访问共享资源时使用。
FreeRTOS中mutex用法
m0_37817135的博客
11-09 5056
FreeRTOS中mutex用法： FreeRTOS为了解决资源保护的问题引入了互斥量（Mutex）。 Mutex 的发音是 /mjuteks/ ，其含义为互斥(体)，这个词是Mutual Exclude的缩写。 Mutex是一把钥匙，一个人拿了就可进入一个房间，出来的时候把钥匙交给队列的第一个。一般的用法是用于串行化对critical section代码的访问，保证这段代码不会被并行的运行。 mutex是一个二进制标志，可以通过它来确保执行流在代码关键区(critical section of code
FreeRTOS——互斥量（mutex）
weixin_63780683的博客
11-17 141
可以看到，使用信号量确实也可以实现互斥访问，但是不完美。它的核心在于：谁上锁，就只能由谁开锁。
FreeRTOS实时操作系统任务参数传递
Gary_Dengxh的博客
03-26 215
【代码】FreeRTOS实时操作系统任务参数传递。
micropython-ESP32 freertos uasyncio 多核心调用
06-10
在 micropython-ESP32 中，可以使用 FreeRTOS 和 uasyncio 模块来实现多任务调度。具体步骤如下： 1. 导入 FreeRTOS 和 uasyncio 模块： ```python import uasyncio as asyncio import gc gc.collect() import micropython micropython.alloc_emergency_exception_buf(100) import rtos ``` 2. 创建任务函数： ```python async def task1(): while True: print("Hello from task1!") await asyncio.sleep(1) async def task2(): while True: print("Hello from task2!") await asyncio.sleep(2) ``` 3. 创建任务句柄： ```python task1_handle = rtos.Task(task1, "Task1", 1024*4, 2) task2_handle = rtos.Task(task2, "Task2", 1024*4, 2) ``` 4. 启动任务： ```python task1_handle.start() task2_handle.start() ``` 以上代码表示创建了两个任务，分别是 `task1` 和 `task2`，并将它们分别分配给了两个不同的核心上运行。在 `task1` 中，我们每秒钟打印一次 "Hello from task1!"，在 `task2` 中，我们每两秒钟打印一次 "Hello from task2!"。通过在主程序中启动这两个任务，它们将在两个不同的核心上同时运行。 需要注意的是，在多核心调用中，需要确保所有任务都是非阻塞的，即不能在任务中使用阻塞式函数。另外，如果有多个任务需要访问共享资源，需要使用锁等机制来确保数据的同步和访问的安全性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值