设计一个数据采集及处理系统，编写两个任务--task1（）和task2（）。其中，taska（）负责采集数据，每次采集10个int类型的数据，并将采集到的数据保存到buffer数组中；task2（）负责数据处理，将task1（）采集到的10个int类型的数据计算求和，并将计算结果输出。task1（）在访问buffer数组时，task2（）不能访问buffer数组，同理，task2（）在访问buffer数组时，task1（）不能访问buffer数组；通过信号量对buffer数组的访问进行控制。

这个问题可以通过使用多线程和信号量来实现。下面是一种可能的解决方案：

import threading
import time

# 创建一个共享的 buffer 数组
buffer = [0] * 10

# 创建两个信号量
lock1 = threading.Lock()  # 用于 task1 访问 buffer 数组时的互斥
lock2 = threading.Lock()  # 用于 task2 访问 buffer 数组时的互斥

# 创建一个变量，用于保存 task1 采集的数据
data = [0] * 10

# 定义 task1 函数，用于采集数据
def task1():
    global buffer, data
    while True:
        # 采集数据
        for i in range(10):
            data[i] = i + 1
        
        # 获取 lock1 信号量
        lock1.acquire()
        
        # 将采集到的数据保存到 buffer 数组中
        for i in range(10):
            buffer[i] = data[i]
        print("task1: buffer =", buffer)
        
        # 释放 lock1 信号量
        lock1.release()
        
        # 休眠 1 秒钟
        time.sleep(1)


# 定义 task2 函数，用于处理数据
def task2():
    global buffer
    while True:
        # 获取 lock2 信号量
        lock2.acquire()
        
        # 计算 buffer 数组中的数据之和
        total = sum(buffer)
        print("task2: total =", total)
        
        # 释放 lock2 信号量
        lock2.release()
        
        # 休眠 1 秒钟
        time.sleep(1)


# 创建两个线程分别执行 task1 和 task2 函数
t1 = threading.Thread(target=task1)
t2 = threading.Thread(target=task2)

# 启动两个线程
t1.start()
t2.start()

# 等待两个线程结束
t1.join()
t2.join()

在这个代码中，我们创建了两个信号量 lock1 和 lock2 来控制 buffer 数组的访问。在 task1 函数中，我们首先采集数据，并将采集到的数据保存到 data 数组中。然后获取 lock1 信号量，将 data 数组的数据复制到 buffer 数组中，并释放 lock1 信号量。在 task2 函数中，我们获取 lock2 信号量，计算 buffer 数组中的数据之和，并释放 lock2 信号量。

由于 lock1 和 lock2 信号量的存在，每次只有一个线程能够访问 buffer 数组，从而保证了数据的正确性。