signal函数和wait函数

signal函数和wait函数是Linux系统编程中常用的两个函数。

signal函数的作用是为指定的信号设置处理函数，其函数原型为：

void (*signal(int signum, void (*handler)(int)))(int);

其中，signum表示要设置处理函数的信号编号，handler表示要设置的信号处理函数。signal函数返回的是指向以前的信号处理程序的指针（安装在signum信号上的信号处理函数的指针）。

wait函数的作用是等待子进程结束并获取子进程的终止状态，其函数原型为：

pid_t wait(int *status);

其中，status是一个指向整型变量的指针，用于存储子进程的终止状态。wait函数返回的是子进程的进程ID。

在Linux系统编程中，通常会使用signal函数为指定的信号设置处理函数，以便在信号发生时进行相应的处理。而wait函数则常用于父进程等待子进程结束并获取其终止状态的情况下。

相关问题

pthread_cond_signal函数的例子

下面是一个使用pthread_cond_signal函数的例子：

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

#define NUM_THREADS 3

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

int count = 0;

void *thread_func(void *arg) {
    int *id = (int *) arg;
    printf("Thread %d started\n", *id);
    
    pthread_mutex_lock(&mutex);
    while (count < 5) {
        printf("Thread %d waiting\n", *id);
        pthread_cond_wait(&cond, &mutex);
        printf("Thread %d continuing\n", *id);
    }
    pthread_mutex_unlock(&mutex);
    
    printf("Thread %d finished\n", *id);
    return NULL;
}

int main() {
    pthread_t threads[NUM_THREADS];
    int ids[NUM_THREADS] = {0, 1, 2};
    
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_create(&threads[i], NULL, thread_func, &ids[i]);
    }
    
    pthread_mutex_lock(&mutex);
    for (int i = 0; i < 5; i++) {
        count++;
        printf("Main thread signalling\n");
        pthread_cond_signal(&cond);
    }
    pthread_mutex_unlock(&mutex);
    
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
    }
    
    return 0;
}

在该例子中，我们创建了三个线程并在主线程中使用pthread_cond_signal函数通知等待线程继续执行。线程等待条件变量cond，当主线程调用pthread_cond_signal函数时，其中一个线程将从等待中醒来并继续执行。注意，我们在使用条件变量时需要使用互斥锁mutex来保护共享数据。

wait signal

进程 wait signal 是操作系统中的一个重要概念，用于实现多进程协作。它是基于信号量机制实现的，可以用于控制并发访问共享资源的数量。当一个进程需要访问共享资源时，它会先申请信号量，如果信号量计数器大于 0，则进程可以访问共享资源，并将信号量计数器减 1；否则进程必须等待其他进程释放资源并增加信号量计数器。当一个进程释放了共享资源后，它会增加信号量计数器，从而唤醒等待该资源的其他进程。

下面是一个使用 Python 中的 multiprocessing 库实现进程 wait signal 的例子：

import multiprocessing

def worker(semaphore):
    print("Worker is waiting for the semaphore")
    semaphore.acquire()
    print("Worker acquired the semaphore")
    # 访问共享资源
    print("Worker is releasing the semaphore")
    semaphore.release()

if __name__ == '__main__':
    semaphore = multiprocessing.Semaphore(1)
    p1 = multiprocessing.Process(target=worker, args=(semaphore,))
    p2 = multiprocessing.Process(target=worker, args=(semaphore,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()

在这个例子中，我们创建了一个信号量对象 semaphore，并将其初始化为 1。然后创建了两个进程 p1 和 p2，它们都会调用 worker 函数。在 worker 函数中，进程会先等待 semaphore，如果 semaphore 的计数器大于 0，则进程可以访问共享资源，并将 semaphore 的计数器减 1；否则进程必须等待其他进程释放资源并增加 semaphore 的计数器。当进程释放了共享资源后，它会增加 semaphore 的计数器，从而唤醒等待该资源的其他进程。