编写一个程序，在主线程中创建4个新线程，所有线程都输出自己的线程号。linux

可以使用pthread库来创建和管理线程。具体的代码如下：

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

// 线程函数
void *thread_func(void *arg) {
    printf("线程号：%ld\n", (long)pthread_self());
    return NULL;
}

int main() {
    pthread_t threads[4]; // 存储线程ID的数组

    for (int i = 0; i < 4; i++) {
        pthread_create(&threads[i], NULL, thread_func, NULL); // 创建线程
    }

    // 等待所有线程执行完毕
    for (int i = 0; i < 4; i++) {
        pthread_join(threads[i], NULL);
    }

    return 0;
}

在主线程中，我们使用`pthread_create`函数创建了4个新线程，并将线程的ID存储在`threads`数组中。每个线程执行的函数是`thread_func`，在函数中输出自己的线程号。最后，我们使用`pthread_join`函数等待所有线程执行完毕。

相关问题

在linux下编写一个can通信接收程序，要求接收两个不同id的数据帧，并使用多线程，使得接收线程不影响主线程

要在Linux下编写一个CAN通信接收程序，您需要使用CAN接口库（SocketCAN或can-utils）和编程语言（例如C或Python）。以下是一个使用C编写的CAN通信接收程序示例，该程序可以接收两个不同ID的数据帧，并使用多线程来避免接收线程阻塞主线程：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <pthread.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include <linux/can.h>
#include <linux/can/raw.h>

#define CAN_INTERFACE "can0"  // CAN接口名称
#define CAN_ID1 0x123         // 第一个接收的CAN ID
#define CAN_ID2 0x456         // 第二个接收的CAN ID

void *can_receive_function(void *arg) {
    int s;
    struct sockaddr_can addr;
    struct ifreq ifr;
    struct can_frame frame;
    int nbytes;

    // 创建CAN套接字
    if ((s = socket(PF_CAN, SOCK_RAW, CAN_RAW)) < 0) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    // 获取CAN接口信息
    strcpy(ifr.ifr_name, CAN_INTERFACE);
    ioctl(s, SIOCGIFINDEX, &ifr);

    // 绑定CAN套接字到CAN接口
    addr.can_family = AF_CAN;
    addr.can_ifindex = ifr.ifr_ifindex;
    if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        perror("bind");
        exit(EXIT_FAILURE);
    }

    // 接收CAN数据帧
    while (1) {
        nbytes = read(s, &frame, sizeof(struct can_frame));
        if (nbytes < 0) {
            perror("read");
            break;
        }

        // 根据CAN ID判断是否为需要接收的数据帧
        if (frame.can_id == CAN_ID1) {
            printf("Received CAN frame with ID 0x%x\n", frame.can_id);
            // 处理第一个接收的数据帧
        } else if (frame.can_id == CAN_ID2) {
            printf("Received CAN frame with ID 0x%x\n", frame.can_id);
            // 处理第二个接收的数据帧
        }
    }

    // 关闭CAN套接字
    close(s);

    return NULL;
}

int main() {
    pthread_t can_receive_thread;

    // 创建CAN接收线程
    if (pthread_create(&can_receive_thread, NULL, can_receive_function, NULL) != 0) {
        perror("pthread_create");
        exit(EXIT_FAILURE);
    }

    // 主线程继续执行其他任务
    while (1) {
        // 可以在这里执行其他任务，不受接收线程影响
        sleep(1);
    }

    return 0;
}

在上面的示例中，主线程在创建CAN接收线程后继续执行其他任务，而CAN接收线程在不断地接收CAN数据帧并进行处理，不会影响主线程的执行。

2. Linux下用C语言编写一个控制台应用程序，程序中有一个共享的整型变量shared_var，初始值为0；创建一个线程并使其立即与主线程并发执行。新创建的线程与主线程均不断地循环，并输出shared_var 的值。主线程在循环中不断地对shared_var 进行加1操作，即每次循环shared_var 被加1；而新创建的线程则不断地对shared_var 进行减1 操作，即每次循环shared_var 被减1观察程序运行的结果，

这里是一个简单的实现：

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

int shared_var = 0; // 共享整型变量

void *decrease(void *arg) {
    while (1) {
        shared_var--; // 减1操作
        printf("Decrease: shared_var = %d\n", shared_var);
    }
    return NULL;
}

int main() {
    pthread_t tid;
    pthread_create(&tid, NULL, decrease, NULL); // 创建线程

    while (1) {
        shared_var++; // 加1操作
        printf("Increase: shared_var = %d\n", shared_var);
    }

    pthread_join(tid, NULL); // 等待线程结束
    return 0;
}

在这个程序中，我们使用了 pthread 库来创建新的线程。主线程和新线程都会不断循环并输出 shared_var 的值。主线程在每次循环中都会将 shared_var 加1，新线程则会将 shared_var 减1。

由于两个线程同时操作 shared_var，因此需要注意线程同步的问题。在这个例子中，我们没有使用任何锁或者信号量，因此可能会出现竞争条件。但是，由于本例中的操作非常简单，因此不会对结果产生影响。如果涉及到更复杂的操作，就需要使用相应的线程同步机制来保证程序的正确性。