设计一个财务收支业务的程序，构建存钱、取钱两个线程。 存钱线程启动后，每隔1秒钟，随机往账户中存入[0,20]块钱。 每次存钱程序输出：in+空格+存入金额+空格+账户余额 当金额超过100时，唤醒取钱线程， 取钱线程被唤醒后，随机在账户中提取[50-100]块钱。 每次取钱程序输出：out+空格+支取金额+空格+账户余额

好的，这是一个经典的多线程应用题目，需要使用线程同步和互斥技术来保证数据安全和正确性。下面是一个基于 Python 的解决方案：

import threading
import random

class Bank:
    def __init__(self):
        self.balance = 0
        self.lock = threading.Lock()
        self.deposit_cond = threading.Condition(self.lock)
        self.withdraw_cond = threading.Condition(self.lock)

    def deposit(self):
        while True:
            amount = random.randint(0, 20)
            with self.lock:
                self.balance += amount
                print("in", amount, self.balance)
                if self.balance > 100:
                    self.withdraw_cond.notify()
            self.deposit_cond.wait(timeout=1)

    def withdraw(self):
        while True:
            with self.lock:
                while self.balance <= 100:
                    self.withdraw_cond.wait()
                amount = random.randint(50, 100)
                self.balance -= amount
                print("out", amount, self.balance)
            self.deposit_cond.notify()

bank = Bank()

t1 = threading.Thread(target=bank.deposit)
t2 = threading.Thread(target=bank.withdraw)

t1.start()
t2.start()

t1.join()
t2.join()

在这个程序中，我们使用了一个 Bank 类来表示银行账户，并定义了两个方法 deposit 和 withdraw 分别代表存钱和取钱操作。同时，Bank 类也包含了一个 balance 属性来表示账户余额，和一个 lock 对象用来实现线程同步和互斥。

在 deposit 方法中，我们使用了一个 while True 循环来不断地进行存钱操作。每次存钱，我们会随机生成一个 [0, 20] 的金额，然后使用 with self.lock 来获取锁对象，保证同一时间只有一个线程可以修改账户余额。如果存入金额后账户余额超过了 100 元，我们会使用 self.withdraw_cond.notify() 来通知取钱线程可以进行取钱操作了。最后，我们使用 self.deposit_cond.wait(timeout=1) 来等待 1 秒钟，然后继续进行下一轮存钱操作。

在 withdraw 方法中，我们同样使用了一个 while True 循环来不断地进行取钱操作。首先，我们使用 with self.lock 来获取锁对象，然后使用 while self.balance <= 100 和 self.withdraw_cond.wait() 来等待账户余额超过 100 元。一旦账户余额超过了 100 元，我们会随机生成一个 [50, 100] 的金额来进行取钱操作，然后使用 self.deposit_cond.notify() 来通知存钱线程可以进行存钱操作了。

最后，我们创建了两个线程 t1 和 t2 分别代表存钱和取钱线程，并启动它们。在主线程中，我们使用 t1.join() 和 t2.join() 来等待这两个线程结束。