用c语言创建两个进程分别只有 A 和 B 其中的一个锁，并互相等待对方的锁

在C语言中，可以使用进程创建函数fork()来创建新的进程。要实现两个进程分别只有A和B其中一个锁，并互相等待对方的锁，可以使用进程间通信机制中的互斥锁（mutex）来实现。

下面是一个简单的示例代码：

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

pthread_mutex_t lockA, lockB;

void* processA(void* arg) {
    printf("Process A is running\n");
    
    // 加锁A
    pthread_mutex_lock(&lockA);
    printf("Process A has acquired lock A\n");
    
    // 等待锁B
    printf("Process A is waiting for lock B\n");
    pthread_mutex_lock(&lockB);
    printf("Process A has acquired lock B\n");
    
    // 释放锁B
    pthread_mutex_unlock(&lockB);
    printf("Process A has released lock B\n");
    
    // 释放锁A
    pthread_mutex_unlock(&lockA);
    printf("Process A has released lock A\n");
    
    printf("Process A is exiting\n");    pthread_exit(NULL);
}

void* processB(void* arg) {
    printf("Process B is running\n");
    
    // 加锁B
    pthread_mutex_lock(&lockB);
    printf("Process B has acquired lock B\n");
    
    // 等待锁A
    printf("Process B is waiting for lock A\n");
    pthread_mutex_lock(&lockA);
    printf("Process B has acquired lock A\n");
    
    // 释放锁A
    pthread_mutex_unlock(&lockA);
    printf("Process B has released lock A\n");
    
    // 释放锁B
    pthread_mutex_unlock(&lockB);
    printf("Process B has released lock B\n");
    
    printf("Process B is exiting\n");
    pthread_exit(NULL);
}

int main() {
    // 初始化互斥锁
    pthread_mutex_init(&lockA, NULL);
    pthread_mutex_init(&lockB, NULL);
    
    // 创建进程A
    pthread_t threadA;
    if (pthread_create(&threadA, NULL, processA, NULL) != 0) {
        perror("Failed to create thread A");
        return 1;
    }
    
    // 创建进程B
    pthread_t threadB;
    if (pthread_create(&threadB, NULL, processB, NULL) != 0) {
        perror("Failed to create thread B");
        return 1;
    }
    
    // 等待进程A结束
    if (pthread_join(threadA, NULL) != 0) {
        perror("Failed to join thread A");
        return 1;
    }
    
    // 等待进程B结束
    if (pthread_join(threadB, NULL) != 0) {
        perror("Failed to join thread B");
        return 1;
    }
    
    // 销毁互斥锁
    pthread_mutex_destroy(&lockA);
    pthread_mutex_destroy(&lockB);
    
    return 0;
}

在上述代码中，我们使用了两个互斥锁`lockA`和`lockB`来实现进程A和进程B之间的互斥。进程A首先获取锁A，然后等待锁B；而进程B首先获取锁B，然后等待锁A。这样，两个进程就会互相等待对方的锁，从而实现了互斥。