Desarrollo de programas Linux C, programación de subprocesos múltiples, programación de redes

Tabla de contenido

El desarrollo del programa Linux C se refiere al proceso de desarrollo utilizando el lenguaje C bajo el sistema operativo Linux. Linux es un sistema operativo de código abierto, que tiene las ventajas de estabilidad, seguridad y flexibilidad, por lo que ha sido ampliamente utilizado en muchos campos.

programación multiproceso

La programación de subprocesos múltiples se refiere a ejecutar múltiples subprocesos en un programa al mismo tiempo, cada subproceso tiene su propia ruta de ejecución y estado de ejecución. La programación de subprocesos múltiples puede mejorar la concurrencia y la capacidad de respuesta del programa , lo que permite que el programa utilice mejor el rendimiento de los procesadores de varios núcleos.

import threading

def print_numbers():
    for i in range(1, 11):
        print(i)

def print_letters():
    for letter in 'abcdefghij':
        print(letter)

if __name__ == '__main__':
    # 创建两个线程，分别执行print_numbers和print_letters函数
    thread1 = threading.Thread(target=print_numbers)
    thread2 = threading.Thread(target=print_letters)

    # 启动线程
    thread1.start()
    thread2.start()

    # 等待两个线程执行完毕
    thread1.join()
    thread2.join()

    print("程序执行完毕")

Ejecutar el código anterior generará números y letras al mismo tiempo, por ejemplo:

En este ejemplo, creamos dos subprocesos, un subproceso es responsable de imprimir números y el otro subproceso es responsable de imprimir letras.

Inicie un subproceso llamando start()a un método y el subproceso se ejecutará simultáneamente en segundo plano.

Luego, al llamar join()al método, el subproceso principal esperará a que los dos subprocesos secundarios terminen de ejecutarse antes de continuar.

Finalmente, el programa muestra "Ejecución del programa completa".

programación de red

La programación en red se refiere al proceso de utilizar protocolos de red para la transmisión y comunicación de datos en los programas. En Linux, puede usar la programación de sockets para implementar la programación de redes e implementar la comunicación de redes mediante la creación de sockets, el establecimiento de conexiones, el envío y la recepción de datos y otras operaciones.

Código

El siguiente es un código de muestra simple que demuestra el proceso de programación de subprocesos múltiples y programación de red usando lenguaje C bajo Linux:

#include <stdio.h> // 标准输入输出库
#include <stdlib.h> // 标准库函数库
#include <unistd.h> // 提供对操作系统的访问功能
#include <pthread.h> // 线程操作库
#include <sys/socket.h> // 提供套接字相关的函数和结构体
#include <netinet/in.h> // 提供互联网地址族相关的函数和结构体
#include <string.h> // 字符串操作库

#define PORT 8080
#define MAX_CLIENTS 5

void *client_handler(void *arg) {
    int client_socket = *(int *)arg; // 获取客户端套接字
    char buffer[1024];
    memset(buffer, 0, sizeof(buffer));
    read(client_socket, buffer, sizeof(buffer)); // 从客户端读取数据
    printf("Received message from client: %s\n", buffer);
    char *response = "Hello from server!";
    write(client_socket, response, strlen(response)); // 向客户端发送响应
    close(client_socket); // 关闭客户端套接字
    pthread_exit(NULL);
}

int main() {
    int server_socket, client_socket;
    struct sockaddr_in server_address, client_address;
    int address_length = sizeof(server_address);
    pthread_t threads[MAX_CLIENTS];

    // 创建服务器套接字
    server_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (server_socket < 0) {
        perror("Failed to create socket");
        exit(EXIT_FAILURE);
    }

    // 设置服务器地址和端口
    server_address.sin_family = AF_INET;
    server_address.sin_addr.s_addr = INADDR_ANY;
    server_address.sin_port = htons(PORT);

    // 绑定服务器套接字到指定地址和端口
    if (bind(server_socket, (struct sockaddr *)&server_address, sizeof(server_address)) < 0) {
        perror("Failed to bind socket");
        exit(EXIT_FAILURE);
    }

    // 监听客户端连接请求
    if (listen(server_socket, MAX_CLIENTS) < 0) {
        perror("Failed to listen");
        exit(EXIT_FAILURE);
    }

    printf("Server listening on port %d\n", PORT);

    int i = 0;
    while (1) {
        // 接受客户端连接请求
        client_socket = accept(server_socket, (struct sockaddr *)&client_address, (socklen_t *)&address_length);
        if (client_socket < 0) {
            perror("Failed to accept");
            exit(EXIT_FAILURE);
        }

        // 创建线程处理客户端请求
        if (pthread_create(&threads[i], NULL, client_handler, &client_socket) != 0) {
            perror("Failed to create thread");
            exit(EXIT_FAILURE);
        }

        i++;
    }

    // 等待所有线程结束
    for (int j = 0; j < i; j++) {
        pthread_join(threads[j], NULL);
    }

    // 关闭服务器套接字
    close(server_socket);

    return 0;
}