编写程序 sender，它创建一个共享内存，然后随机产生一个100以内的计算表达 式（例如12+34），并将这串表达式字符串通过共享内存发送给 receiver；最后， receiver完成表达式运算后，将计算结果(36)写到共享内存 ，sender收到应答消息 后，将接收到的计算结果显示在终端屏幕上。上述计算重复10次后，sender向receiver 发送”end”，等待recever发送”over”信息后，删除共享内存，结束程序的运行。

下面是一个基于 Python 的 `sender` 和 `receiver` 程序的示例：

sender.py：

import random
import sys
import time
from multiprocessing import shared_memory, Process


def sender(shm_name):
    # 创建共享内存
    shm = shared_memory.SharedMemory(name=shm_name, create=True, size=100)
    # 发送10个随机的计算表达式
    for i in range(10):
        # 随机生成两个数字和一个运算符
        a, b = random.randint(0, 99), random.randint(0, 99)
        op = random.choice(['+', '-', '*', '/'])
        expr = f"{a} {op} {b}"
        # 将计算表达式写入共享内存
        shm.buf[:len(expr)] = bytes(expr, 'utf-8')
        print(f"Sent: {expr}")
        # 等待receiver计算结果
        while not shm.buf[len(expr)]:
            time.sleep(0.1)
        # 读取receiver计算结果
        result = int(shm.buf[len(expr):])
        print(f"Received: {result}")
        # 清空共享内存
        shm.buf[:len(expr)] = bytes(' ' * len(expr), 'utf-8')
        shm.buf[len(expr):] = bytes(' ' * 10, 'utf-8')
    # 发送结束消息
    shm.buf[:3] = bytes('end', 'utf-8')
    # 等待receiver发送over消息
    while not (shm.buf[0] == ord('o') and shm.buf[1] == ord('v') and shm.buf[2] == ord('e') and shm.buf[3] == ord('r')):
        time.sleep(0.1)
    # 删除共享内存
    shm.close()
    shm.unlink()


if __name__ == '__main__':
    if len(sys.argv) != 2:
        print("Usage: python sender.py <shm_name>")
        sys.exit(1)
    sender(sys.argv[1])

receiver.py：

import sys
import time
from multiprocessing import shared_memory


def receiver(shm_name):
    # 打开共享内存
    shm = shared_memory.SharedMemory(name=shm_name, create=False, size=100)
    # 接收sender发送的消息
    while True:
        # 读取共享内存中的消息
        expr = shm.buf[:10].tobytes().decode('utf-8').strip()
        if expr == 'end':
            # 发送over消息
            shm.buf[:4] = bytes('over', 'utf-8')
            break
        if expr:
            # 计算表达式
            result = eval(expr)
            # 将计算结果写入共享内存
            shm.buf[10:20] = bytes(str(result).ljust(10), 'utf-8')
            # 清空表达式
            shm.buf[:10] = bytes(' ' * 10, 'utf-8')
            print(f"Calculated: {expr} = {result}")
        time.sleep(0.1)
    # 关闭共享内存
    shm.close()


if __name__ == '__main__':
    if len(sys.argv) != 2:
        print("Usage: python receiver.py <shm_name>")
        sys.exit(1)
    receiver(sys.argv[1])

以上代码使用了 Python 的 multiprocessing 模块来实现进程间通信。具体来说，使用了共享内存来传递计算表达式和计算结果。在 sender 进程中，随机生成计算表达式，并将其写入共享内存，然后等待 receiver 进程计算结果。在 receiver 进程中，不断读取共享内存中的计算表达式，计算结果，并将结果写入共享内存。在完成 10 次计算之后，sender 进程发送结束消息，等待 receiver 进程发送 over 消息后删除共享内存并退出。