请编写程序实现生产者消费者问题，其中生产者线程和消费者线程各1个，缓存队列(循环队列)长度为10。生产者每隔100ms产生一个整型数据,产生的数据为0-99，共100个，消费者每隔80ms消费一个数据（从缓存队列中取出一个数据，并打印）。请用不同的时间间隔配置生产者消费者的时间间隔，并观察多线程程序的行为，以及缓存队列中数据的变化。

以下是一个简单的生产者消费者问题的实现，其中生产者线程和消费者线程各一个，缓存队列长度为10，生产者每隔100ms生产一个整型数据，消费者每隔80ms消费一个数据，直到消费完所有数据。

import threading
import time

# 缓存队列
queue = [None] * 10
front = 0
rear = 0

# 生产者线程
def producer():
    global queue, rear
    for i in range(100):
        item = i % 100
        while ((rear + 1) % len(queue)) == front:
            time.sleep(0.01)
        queue[rear] = item
        rear = (rear + 1) % len(queue)
        print(f"生产者生产了数据 {item}")
        time.sleep(0.1)

# 消费者线程
def consumer():
    global queue, front
    while True:
        while front == rear:
            time.sleep(0.01)
        item = queue[front]
        front = (front + 1) % len(queue)
        print(f"消费者消费了数据 {item}")
        time.sleep(0.08)
        if front == rear and item == 99:
            break

# 创建生产者和消费者线程
p = threading.Thread(target=producer)
c = threading.Thread(target=consumer)

# 启动线程
p.start()
c.start()

# 等待线程结束
p.join()
c.join()

在上面的代码中，我们使用了一个循环队列来实现缓存队列，其中`front`和`rear`分别表示队列的头部和尾部。生产者线程每隔100ms生产一个整型数据，如果队列已满，则会等待一段时间，直到队列有空位。消费者线程每隔80ms消费一个数据，如果队列为空，则会等待一段时间，直到队列有数据。当消费者线程消费完最后一个数据时，程序会结束。

我们可以使用不同的时间间隔来配置生产者和消费者的时间间隔，观察多线程程序的行为和缓存队列中数据的变化。例如，我们可以将生产者的时间间隔改为50ms，将消费者的时间间隔改为100ms：

# 生产者线程
def producer():
    global queue, rear
    for i in range(100):
        item = i % 100
        while ((rear + 1) % len(queue)) == front:
            time.sleep(0.01)
        queue[rear] = item
        rear = (rear + 1) % len(queue)
        print(f"生产者生产了数据 {item}")
        time.sleep(0.05)

# 消费者线程
def consumer():
    global queue, front
    while True:
        while front == rear:
            time.sleep(0.01)
        item = queue[front]
        front = (front + 1) % len(queue)
        print(f"消费者消费了数据 {item}")
        time.sleep(0.1)
        if front == rear and item == 99:
            break

在这种情况下，我们会发现生产者生产的速度比消费者快，缓存队列中的数据会一直增加，直到队列满了为止。如果我们将生产者的时间间隔改为200ms，将消费者的时间间隔改为50ms：

# 生产者线程
def producer():
    global queue, rear
    for i in range(100):
        item = i % 100
        while ((rear + 1) % len(queue)) == front:
            time.sleep(0.01)
        queue[rear] = item
        rear = (rear + 1) % len(queue)
        print(f"生产者生产了数据 {item}")
        time.sleep(0.2)

# 消费者线程
def consumer():
    global queue, front
    while True:
        while front == rear:
            time.sleep(0.01)
        item = queue[front]
        front = (front + 1) % len(queue)
        print(f"消费者消费了数据 {item}")
        time.sleep(0.05)
        if front == rear and item == 99:
            break

在这种情况下，我们会发现消费者消费的速度比生产者快，缓存队列中的数据会一直减少，直到队列为空为止。这些观察结果说明，生产者和消费者的时间间隔设置会影响缓存队列中数据的变化。