设有如下计算程序：x = ( A2+B2 ) × C2 /( B+C ) 其中，每一个操作看作一个进程。要求： 1．画出此计算程序的进程流图，并注明各进程对应的操作； 2．用信号灯的 P、V 操作实现这些进程的同步，用一种结构化的程序设计语言写出程序描述。

进程流图如下所示：

      +-----------+          +-----------+       +-----------+
A --> |  Process1 | -------->|  Process2 | ----> |  Process3 |
      +-----------+          +-----------+       +-----------+
                |                    |                   |
                |                    |                   |
                V                    V                   V
           +----------+          +---------+         +----------+
           | Process4 |          | Process5|         | Process6 |
           +----------+          +---------+         +----------+

其中，各进程对应的操作如下：

Process1：计算 A 的平方
Process2：计算 B 的平方
Process3：计算 C 的平方
Process4：计算 A2 + B2
Process5：计算 B + C
Process6：计算 (A2 + B2) × C2 / (B + C)

下面使用信号量实现这些进程的同步，使用 Python 语言编写程序描述：

from threading import Semaphore, Thread

# 定义信号量
sem_A = Semaphore(1)
sem_B = Semaphore(1)
sem_C = Semaphore(1)
sem_result = Semaphore(0)

# 定义变量
A = 2
B = 3
C = 4
result = 0

# 定义进程函数
def process1():
    global A
    sem_A.acquire()
    A = A * A
    sem_A.release()
    sem_result.release()

def process2():
    global B
    sem_B.acquire()
    B = B * B
    sem_B.release()
    sem_result.release()

def process3():
    global C
    sem_C.acquire()
    C = C * C
    sem_C.release()
    sem_result.release()

def process4():
    global A, B
    sem_A.acquire()
    sem_B.acquire()
    result = A + B
    sem_A.release()
    sem_B.release()
    sem_result.release()

def process5():
    global B, C
    sem_B.acquire()
    sem_C.acquire()
    result = B + C
    sem_B.release()
    sem_C.release()
    sem_result.release()

def process6():
    global result
    sem_result.acquire()
    sem_result.acquire()
    sem_result.acquire()
    sem_result.acquire()
    sem_result.acquire()
    result = result * C / result
    print(result)

# 创建线程
t1 = Thread(target=process1)
t2 = Thread(target=process2)
t3 = Thread(target=process3)
t4 = Thread(target=process4)
t5 = Thread(target=process5)
t6 = Thread(target=process6)

# 启动线程
t1.start()
t2.start()
t3.start()
t4.start()
t5.start()
t6.start()

# 等待线程结束
t1.join()
t2.join()
t3.join()
t4.join()
t5.join()
t6.join()

注意，在进程 6 中需要使用 5 次 acquire 操作，因为需要等待 5 个进程都计算完毕才能进行计算。