在Linux环境中，除pipe和clone公共内存通讯外，还可以采用shm和msg通讯方式，试查阅相关资料了解这些通讯方式，并使用上述任一种方式模拟实现“生产者/消费者”问题。

shm通讯方式是Linux下的一种共享内存通讯方式，多个进程可以共享同一段内存空间，从而实现进程间的通讯。msg通讯方式是Linux下的一种消息队列通讯方式，进程可以通过消息队列来传递消息。

下面是使用shm通讯方式实现“生产者/消费者”问题的代码示例：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>

#define BUFFER_SIZE 10
#define SHM_KEY 1234

struct shared_buffer {
    char buffer[BUFFER_SIZE];
    int write_index;
    int read_index;
};

int main() {
    int shmid;
    struct shared_buffer *shared_mem;
    char c;
    
    // 创建共享内存
    shmid = shmget(SHM_KEY, sizeof(struct shared_buffer), IPC_CREAT | 0666);
    if (shmid < 0) {
        perror("shmget");
        exit(1);
    }
    
    // 连接共享内存
    shared_mem = (struct shared_buffer*)shmat(shmid, NULL, 0);
    if (shared_mem == (void*)-1) {
        perror("shmat");
        exit(1);
    }
    
    // 初始化共享内存
    shared_mem->write_index = 0;
    shared_mem->read_index = 0;
    memset(shared_mem->buffer, ' ', BUFFER_SIZE);
    
    // 创建生产者进程
    if (fork() == 0) {
        int i = 0;
        while (1) {
            c = 'A' + i % 26;
            while ((shared_mem->write_index + 1) % BUFFER_SIZE == shared_mem->read_index) {
                // 缓冲区已满，等待消费者消费
                sleep(1);
            }
            shared_mem->buffer[shared_mem->write_index] = c;
            printf("生产者写入：%c\n", c);
            shared_mem->write_index = (shared_mem->write_index + 1) % BUFFER_SIZE;
            i++;
            sleep(1);
        }
    }
    
    // 创建消费者进程
    if (fork() == 0) {
        while (1) {
            while (shared_mem->write_index == shared_mem->read_index) {
                // 缓冲区已空，等待生产者生产
                sleep(1);
            }
            c = shared_mem->buffer[shared_mem->read_index];
            printf("消费者读取：%c\n", c);
            shared_mem->buffer[shared_mem->read_index] = ' ';
            shared_mem->read_index = (shared_mem->read_index + 1) % BUFFER_SIZE;
            sleep(1);
        }
    }
    
    // 等待子进程结束
    wait(NULL);
    wait(NULL);
    
    // 分离共享内存
    shmdt(shared_mem);
    // 删除共享内存
    shmctl(shmid, IPC_RMID, NULL);
    
    return 0;
}

上述代码使用shm通讯方式实现了一个简单的“生产者/消费者”问题。在主进程中创建了共享内存，并通过fork()创建了生产者和消费者两个子进程。生产者进程往共享内存的缓冲区中写入数据，消费者进程从共享内存的缓冲区中读取数据。通过共享内存的方式，实现了进程间的通讯。

注意：在使用shm通讯方式时，需要注意对共享内存的访问控制，以避免出现竞争条件。