对于基础题目系统调用编程中的第2题（即：使用semaphore，并利用该程序生成2个进程（注意：非线程），这两个进程写同一个文件，要求：a.互斥写，即只有一个进程写完后，才能让另一个进程写; b. 一个进程写入内容：“自己学号的后3位PROC1 MYFILE1”；另一个进程写入内容：“自己学号的后3位PROC2 MYFILE2”），将该程序的semaphore替换成使用strict alternation算法的忙等待互斥锁完成。

好的，以下是使用忙等待实现互斥锁的示例代码：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <semaphore.h>

#define SHM_NAME "/myshm"
#define FILE1 "MYFILE1"
#define FILE2 "MYFILE2"

typedef struct {
    sem_t mutex;
    int turn;
} shared_data;

int main()
{
    int fd1, fd2, i;
    char *addr1, *addr2;
    shared_data *data;

    // 创建共享内存
    int shmfd = shm_open(SHM_NAME, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
    if (shmfd == -1) {
        perror("shm_open");
        exit(EXIT_FAILURE);
    }

    // 设置共享内存大小
    if (ftruncate(shmfd, sizeof(shared_data)) == -1) {
        perror("ftruncate");
        exit(EXIT_FAILURE);
    }

    // 将共享内存映射到进程地址空间中
    data = mmap(NULL, sizeof(shared_data), PROT_READ | PROT_WRITE, MAP_SHARED, shmfd, 0);
    if (data == MAP_FAILED) {
        perror("mmap");
        exit(EXIT_FAILURE);
    }

    // 初始化互斥锁和turn
    sem_init(&data->mutex, 1, 1);
    data->turn = 0;

    // 创建进程
    pid_t pid = fork();
    if (pid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    } else if (pid == 0) {
        // 子进程写入内容到 FILE1
        fd1 = open(FILE1, O_WRONLY | O_CREAT | O_TRUNC, 0666);
        if (fd1 == -1) {
            perror("open");
            exit(EXIT_FAILURE);
        }

        for (i = 0; i < 10; i++) {
            while (1) {
                // 等待自己的轮到
                sem_wait(&data->mutex);

                if (data->turn == 0) {
                    // 写入内容并切换轮到
                    sprintf(addr1, "%s PROC1  %s\n", "your_id", FILE1);
                    data->turn = 1;
                    break;
                }

                // 轮到另一个进程，释放互斥锁
                sem_post(&data->mutex);
            }

            // 写入完成，释放互斥锁
            sem_post(&data->mutex);
            sleep(1);
        }

        exit(EXIT_SUCCESS);
    } else {
        // 父进程写入内容到 FILE2
        fd2 = open(FILE2, O_WRONLY | O_CREAT | O_TRUNC, 0666);
        if (fd2 == -1) {
            perror("open");
            exit(EXIT_FAILURE);
        }

        for (i = 0; i < 10; i++) {
            while (1) {
                // 等待自己的轮到
                sem_wait(&data->mutex);

                if (data->turn == 1) {
                    // 写入内容并切换轮到
                    sprintf(addr2, "%s PROC2  %s\n", "your_id", FILE2);
                    data->turn = 0;
                    break;
                }

                // 轮到另一个进程，释放互斥锁
                sem_post(&data->mutex);
            }

            // 写入完成，释放互斥锁
            sem_post(&data->mutex);
            sleep(1);
        }

        exit(EXIT_SUCCESS);
    }
}

上述代码中，我们使用了忙等待的方式来实现互斥锁。在每个进程中，使用一个 `while` 循环来等待自己的轮到，如果轮到了就执行写入操作，否则就释放互斥锁，让另一个进程获得轮到。

需要注意的是，使用忙等待的方式会使 CPU 占用率较高，对系统的性能会产生一定的影响。在实际开发中，为了避免这种情况，可以使用更高效的互斥锁实现方式，例如信号量或条件变量。