Lenguaje de programación : c ++
Entorno de ejecución : Linux versión 4.19.42-v7 + (dom @ dom-XPS-13-9370) (gcc versión 4.9.3 (crosstool-NG crosstool-ng-1.22.0-88-g8460611)) # 1219 SMP martes 14 de mayo 21:20:58 CEST, 2019
Objetivo : cuando se está ejecutando un hilo, el programa principal u otro hilo puede cambiar la variable de destino en tiempo real cambiando las variables globales. Por ejemplo, aquí, el host soy yo, para ejecutar un hilo cliente estructurado tcp en la Raspberry Pi. Y los datos recopilados a través del subproceso de la cámara se procesan en tiempo real a través del subproceso del cliente tcp y se envían de vuelta al servidor (esto es solo para la transferencia de datos entre dos subprocesos, si recuerda usar subprocesos mutex entre varios subprocesos, para evitar errores de datos)
En primer lugar, no es necesario usar una estructura, está bien simplemente establecer una variable global y usarla directamente. Usar un diagrama de estructura es mucho mejor en términos de encapsulación y consistencia, especialmente cuando hay muchos tipos de mismo tipo. Cuando es necesario definir los parámetros ( ￣ △ ￣)
Ejemplo 1 : Un ejemplo de uso directo de variables globales para interactuar con parámetros entre el hilo y el programa principal.
Descripción del proceso:
1. Primero defina una variable global de tipo flotante cha_zuo_you = 0;
2. También defina una función llamada judje para funciones de hilo
3 . Bien, comenzamos desde la función principal. En la función principal, cree un hilo
4 con un número de hilo en hilo1, y continúe ejecutando el programa principal, de modo que la variable global cha_zuo_you agregue uno cada 2 segundos.
5. Mientras que el el programa principal se está ejecutando, Thread thread1 también comenzó a ejecutar su programa, imprimiendo el valor de la variable global cha_zuo_you, cabe señalar que cuando se imprime aquí el valor de la variable global cha_zuo_you, el programa principal también está modificando el valor de la variable global cha_zuo_you, por lo que si eliminamos la función de suspensión, es posible imprimir múltiples valores iguales en un cierto período de tiempo o imprimir otros valores.
在这里插入代码片
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <iostream>
#include <sstream>
pthread_t thread1;//创建线程名称
float cha_zuo_you = 0;//全局变量
void * judje(void *arg)//注意好这里线程用的函数是带信号的哦,
//具体原因参考pthread_create函数定义*(自己搜)
{
while(1)
{
printf(" 线程judje输出变量cha_zuo_you的值为: %f,并延时两秒 \n ",cha_zuo_you);
sleep(2);
}
}
int main(void)
{
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
//(以上3句用来设置线程的属性,
//这里设置为PTHREAD_CREATE_DETACHED 则新线程不
//能用pthread_join()来同步，且在退出时自行释放所占用的资源。)
if (0 != pthread_create(&thread1, &attr, judje, NULL ))//
{
printf("error when create pthread,%d\n", errno);
return 1;
}
while(1)
{
cha_zuo_you = cha_zuo_you + 1;
printf("主程序将变量cha_zuo_you加一并延时两秒\n");
sleep(2);
}
}
El efecto de ejecución es el siguiente
Ejemplo 2 : A continuación, agregamos una estructura de estructura
struct dir_motor
{
float a = 10;
float *left_right = &cha_zuo_you;//参数1
float *top_under = &cha_qian_hou;
float *Re_lv = &Relative_distance;
};
Descripción del proceso (utilicé cursiva y ^^ donde hay cambios):
1. ^^ primero define 4 variables globales de tipo flotante (incluidas las variables globales cha_zuo_you);
2 ^^ define una estructura llamada dir_motor
3. Se define una función llamada judje para la función de subproceso
3. Bien, comenzamos desde la función principal. En la función principal, cree un subproceso número
4 en thread1, y continúe ejecutando el programa principal, haciendo que la variable global cha_zuo_you cada 2 Agregue uno
* 5 por segundo . ^ ^ Al mismo tiempo que se ejecuta el programa principal, thread thread1 también comienza a ejecutar su programa, y el valor de correct_num se usa para averiguar qué variable global se imprimirá (aquí correct_num es 1, por lo que todavía está imprimiendo el variable global cha_zuo_you Value),
esta vez vale la pena señalar que el valor de un definido en la estructura se imprime aquí para comparar la diferencia al imprimir,
es decir
p = pstru->left_right;//left_right是一个float *类型的指针,
printf(" 输出全局变量cha_zuo_you的值等于: %f \n ",*(p));
printf("输出a类型的值%f\n",pstru->a);
//.. Yo soy la línea divisoria ...
El siguiente es un ejemplo de código simple de pasar parámetros en subprocesos múltiples a través de variables globales de estructura (struct). Preste atención a la definición en la estructura dir_motor cuando se utilizan variables globales y la clase de estructura común con tipo de variable (es decir, a) La diferencia entre la definición y referencia en el programa
下面是帮助大家理解程序为总结的话,建议边看程序边配上这里的图一起理解,当然如果你对c
中的指针理解很深刻的话,直接看程序就好了
El siguiente es un resumen para ayudarlo a comprender el programa. Se recomienda que mire el programa mientras hace coincidir la imagen aquí (es un poco feo, se recomienda guardar la imagen y girarla 90 grados en sentido antihorario para verla, solo escriba una pequeña oración, este artículo solo está publicado en CSDN, si alguna cuenta oficial se ha subido, se ha utilizado descaradamente como su original o se ha cargado, recuerde notificarme, aunque su nivel es promedio) entiendan juntos, por supuesto, si entienda muy bien el puntero en c Si es profundo, mire el programa directamente
En primer lugar, asumimos:
tipo float escribir un asterisco * LEFT_RIGHT dirección a 0x01
Tipo de tipo float cha_zuo_you está 0x11 dirección de
tipo tipo de estructura dir_motor asterisco de pstru dirección es 0x56
Existen los siguientes procedimientos para obtener las siguientes palabras
1.pstru-> left_right representa la variable que representa la variable cuya dirección es 0x01 almacenada en la dirección donde se encuentra pstru (es decir, 0x56), es decir, left_right (por eso pstru-> left_right se suma cuando el valor de cha_zuo_you aparece en el hilo El motivo del asterisco)
2. pstru-> a significa que el valor de la variable cuya dirección es 0x66 almacenada en la dirección donde se encuentra pstru (es decir, 0x56) es 10.000000
(en realidad, la dirección 0x56 de pstru almacena 4 direcciones, a saber, la estructura dir_motor. Los valores almacenados en los cuatro tipos de direcciones de la clase son las direcciones de los cuatro tipos de la clase de estructura dir_motor. Por supuesto, esta afirmación también es inexacta. La capacidad de almacenamiento de un espacio de direcciones físicas es limitado. De hecho, esto se llama pstru. El espacio de direcciones es más de un espacio de direcciones cuando hay muchas variables definidas en la estructura dir_motor. Aquí, para facilitar la comprensión, este espacio de direcciones se denomina 0x56))
3. La dirección de la variable left_right es 0x01
4. * left_right significa la variable left_right El valor 0x11 almacenado en la dirección (es decir, 0x01) es el valor de la variable de dirección (es decir, 0), es decir * left_right = 0 (Por supuesto, el programa principal agrega 1 cada 2 segundos)
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <iostream>
#include <sstream>
pthread_t thread1;
int correct_num = 1;
float Relative_distance = 0;
float cha_zuo_you = 0;
float cha_qian_hou = 0;
struct dir_motor
{
float a = 10;
float *left_right = &cha_zuo_you;//参数1
float *top_under = &cha_qian_hou;
float *Re_lv = &Relative_distance;
};
struct dir_motor pstru1;
//00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
//
void * judje(void *arg)
{
int num;
float *p;
dir_motor *pstru;
pstru = (struct dir_motor *) arg;
//(对arg的强制类型转换,即将指向 传入该judje线程函数的dir_motor类型
//的pstru1变量的 指针arg 指向的类型空间变成dir_motor类型 )
//多缓一缓理解
switch (correct_num)//(通过全局变量correct_num选择指针p
//指向什么类型(这里是指的left_right指针指的cha_zuo_you的
//地址)
{
case 1:
p = pstru->left_right;//left_right是一个float *类型的指针,
correct_num = correct_num + 1;
num = 1;
break;
case 2:
p = pstru->left_right;
correct_num = correct_num + 1;
num = 2;
break;
case 3:
p = pstru->top_under;
correct_num = correct_num + 1;
num = 3;
break;
case 4:
p = pstru->top_under;
correct_num = correct_num + 1;
num = 4;
break;
case 5:
p = pstru->Re_lv;
correct_num = correct_num + 1;
num = 5;
break;
}
while(1)
{
printf("输出a类型的值%f\n",pstru->a);
printf(" 线程judje输出变量cha_zuo_you的值为: %f,并延时两秒 \n ",*(p));
sleep(2);
}
}
int main(void)
{
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
if (0 != pthread_create(&thread1, &attr, judje, &pstru1 ))//将定义的pstru地址给judje中定义的指针pstru指
{
printf("error when create pthread,%d\n", errno);
return 1;
}
while(1)
{
cha_zuo_you = cha_zuo_you + 1;
printf("主程序将变量cha_zuo_you加一并延时两秒\n");
sleep(2);
}
}
El siguiente es el diagrama de ejecución del ejemplo dos
Bueno, el archivo en ejecución en Linux se coloca aquí. De hecho, es el mismo que el anterior. Al
compilar, use make y falla (el cpp se cambia y no hay respuesta)
o desea volver a generar el archivo compilado . El nombre del archivo compilado se cambia en CMakeLists.txt. Elimine otros archivos y solo conserve los
dos archivos ResultColorTest.cpp CMakeLists.txt y luego use
cmake. Para regenerar (si desea compilar varios archivos cpp juntos, debe cambiar el contenido de CMakeLists.txt)