Python多线程编程——资源共享

电玩女神 2023-02-26 13:29 99阅读 0赞

转载来源：https://github.com/jackfrued/Python-100-Days/blob/master/Day01-15%2F13.%E8%BF%9B%E7%A8%8B%E5%92%8C%E7%BA%BF%E7%A8%8B.md

问题描述：

因为多个线程可以共享进程的内存空间，因此要实现多个线程间的通信相对简单，大家能想到的最直接的办法就是设置一个全局变量，多个线程共享这个全局变量即可。但是当多个线程共享同一个变量（我们通常称之为“资源”）的时候，很有可能产生不可控的结果从而导致程序失效甚至崩溃。如果一个资源被多个线程竞争使用，那么我们通常称之为“临界资源”，对“临界资源”的访问需要加上保护，否则资源会处于“混乱”的状态。下面的例子演示了100个线程向同一个银行账户转账（转入1元钱）的场景，在这个例子中，银行账户就是一个临界资源，在没有保护的情况下我们很有可能会得到错误的结果：

  1. # -*- coding: utf-8 -*-
  2. # -*- coding: utf-8 -*-
  3. from time import sleep, time
  4. from threading import Thread
  7. class Account(object):
  9.     def __init__(self):
  10.         self._balance = 0
  12.     def deposit(self, money):
  13.         # 计算存款后的余额
  14.         new_balance = self._balance + money
  15.         # 模拟受理存款业务需要0.01秒的时间
  16.         sleep(0.01)
  17.         # 修改账户余额
  18.         self._balance = new_balance
  20.     @property
  21.     def balance(self):
  22.         return self._balance
  25. class AddMoneyThread(Thread):
  27.     def __init__(self, account, money):
  28.         super().__init__()
  29.         self._account = account
  30.         self._money = money
  32.     def run(self):
  33.         self._account.deposit(self._money)
  36. def main():
  37.     account = Account()
  38.     threads = []
  40.     start = time()
  41.     # 创建100个存款的线程向同一个账户中存钱
  42.     for _ in range(5):
  43.         t = AddMoneyThread(account, 1)
  44.         threads.append(t)
  45.         t.start()
  46.     # 等所有存款的线程都执行完毕
  47.     for t in threads:
  48.         t.join()
  49.     end = time()
  50.     print('账户余额为: ￥%d元，花费的时间为%.3f' % (account.balance, end - start))
  53. if __name__ == '__main__':
  54.     main()
  56. # 账户余额为: ￥1元，花费的时间为0.012

解决办法：

运行上面的程序，结果让人大跌眼镜，100个线程分别向账户中转入1元钱，结果居然远远小于100元。之所以出现这种情况是因为我们没有对银行账户这个“临界资源”加以保护，多个线程同时向账户中存钱时，会一起执行到new_balance = self._balance + money这行代码，多个线程得到的账户余额都是初始状态下的0，所以都是0上面做了+1的操作，因此得到了错误的结果。在这种情况下，“锁”就可以派上用场了。我们可以通过“锁”来保护“临界资源”，只有获得“锁”的线程才能访问“临界资源”，而其他没有得到“锁”的线程只能被阻塞起来，直到获得“锁”的线程释放了“锁”，其他线程才有机会获得“锁”，进而访问被保护的“临界资源”。下面的代码演示了如何使用“锁”来保护对银行账户的操作，从而获得正确的结果。示例：

  1. # -*- coding: utf-8 -*-
  2. from time import sleep, time
  3. from threading import Thread, Lock
  6. class Account(object):
  8.     def __init__(self):
  9.         self._balance = 0
  10.         self._lock = Lock()
  12.     def deposit(self, money):
  13.         # 先获取锁才能执行后续的代码
  14.         self._lock.acquire()
  15.         try:
  16.             # 计算存款后的余额
  17.             new_balance = self._balance + money
  18.             # 模拟受理存款业务需要0.01秒的时间
  19.             sleep(0.01)
  20.             # 修改账户余额
  21.             self._balance = new_balance
  22.         finally:
  23.             # 在finally中执行释放锁的操作保证正常异常锁都能释放
  24.             self._lock.release()
  26.     @property
  27.     def balance(self):
  28.         return self._balance
  31. class AddMoneyThread(Thread):
  32.     def __init__(self, account, money):
  33.         super().__init__()
  34.         self._account = account
  35.         self._money = money
  37.     def run(self):
  38.         self._account.deposit(self._money)
  41. def main():
  42.     account = Account()
  43.     threads = []
  45.     start = time()
  46.     # 创建100个存款的线程向同一个账户中存钱
  47.     for _ in range(5):
  48.         t = AddMoneyThread(account, 1)
  49.         threads.append(t)
  50.         t.start()
  51.     # 等所有存款的线程都执行完毕
  52.     for t in threads:
  53.         t.join()
  54.     end = time()
  55.     print('账户余额为: ￥%d元，花费的时间为%.3f' % (account.balance, end - start))
  58. if __name__ == '__main__':
  59.     main()
  61. # 账户余额为: ￥5元，花费的时间为0.055

讨论（非转载）：

  • 对于原作者的解决方法：通过“锁”来保护“临界资源”，对于一般的操作是个不错的方法，即：
    在同一个线程里面对“临街资源”的访问和修改必须要在一个“锁”之内完成，这样可以保证线程对“临街资源”的修改对其他线程产生影响。

  • 但是当对“临街资源”的访问和修改过程是一个比较耗时的操作的时候，即占了该线程所耗时间的绝大部分的时候，则会严重削弱多线程所带来的执行效率的提升，如：

    -- coding: utf-8 --

    from time import sleep, time
    from threading import Thread, Lock

  1. class Account(object):
  3.     def __init__(self):
  4.         self._balance = 0
  5.         self._lock = Lock()
  7.     def deposit(self, money):
  8.         # 先获取锁才能执行后续的代码
  9.         self._lock.acquire()
  10.         try:
  11.             # 计算存款后的余额
  12.             new_balance = self._balance + money
  13.             # 模拟受理存款业务需要2秒的时间
  14.             sleep(2)
  15.             # 修改账户余额
  16.             self._balance = new_balance
  17.         finally:
  18.             # 在finally中执行释放锁的操作保证正常异常锁都能释放
  19.             self._lock.release()
  21.     @property
  22.     def balance(self):
  23.         return self._balance
  26. class AddMoneyThread(Thread):
  27.     def __init__(self, account, money):
  28.         super().__init__()
  29.         self._account = account
  30.         self._money = money
  32.     def run(self):
  33.         self._account.deposit(self._money)
  36. def main():
  37.     account = Account()
  38.     threads = []
  40.     start = time()
  41.     # 创建100个存款的线程向同一个账户中存钱
  42.     for _ in range(5):
  43.         t = AddMoneyThread(account, 1)
  44.         threads.append(t)
  45.         t.start()
  46.     # 等所有存款的线程都执行完毕
  47.     for t in threads:
  48.         t.join()
  49.     end = time()
  50.     print('账户余额为: ￥%d元，花费的时间为%.3f' % (account.balance, end - start))
  53. if __name__ == '__main__':
  54.     main()
  56. # 账户余额为: ￥5元，花费的时间为10.004

在该例子中，线程“锁”内部的操作耗费了大量的时间（即：sleep(2)），多线程对执行效率的提升效果非常小。

  1. # -*- coding: utf-8 -*-
  2. from time import sleep, time
  3. from threading import Thread, Lock
  6. class Account(object):
  8.     def __init__(self):
  9.         self._balance = 0
  10.         self._lock = Lock()
  12.     def deposit(self, money):
  13.         sleep(2)
  14.         # 先获取锁才能执行后续的代码
  15.         self._lock.acquire()
  16.         try:
  17.             # 计算存款后的余额
  18.             new_balance = self._balance + money
  19.             # 模拟受理存款业务需要0.01秒的时间
  20.             sleep(0.01)
  21.             # 修改账户余额
  22.             self._balance = new_balance
  23.         finally:
  24.             # 在finally中执行释放锁的操作保证正常异常锁都能释放
  25.             self._lock.release()
  27.     @property
  28.     def balance(self):
  29.         return self._balance
  32. class AddMoneyThread(Thread):
  33.     def __init__(self, account, money):
  34.         super().__init__()
  35.         self._account = account
  36.         self._money = money
  38.     def run(self):
  39.         self._account.deposit(self._money)
  42. def main():
  43.     account = Account()
  44.     threads = []
  46.     start = time()
  47.     # 创建100个存款的线程向同一个账户中存钱
  48.     for _ in range(5):
  49.         t = AddMoneyThread(account, 1)
  50.         threads.append(t)
  51.         t.start()
  52.     # 等所有存款的线程都执行完毕
  53.     for t in threads:
  54.         t.join()
  55.     end = time()
  56.     print('账户余额为: ￥%d元，花费的时间为%.3f' % (account.balance, end - start))
  59. if __name__ == '__main__':
  60.     main()
  62. # 账户余额为: ￥5元，花费的时间为2.056

但是，当线程中“锁”外面的操作远耗时（sleep(2)）大于“锁”内部的操作（sleep(0.01)）的时候，多线程对执行效率的提升效果非常明显。

发表评论

表情：
评论列表 （有 0 条评论，99人围观）

还没有评论，来说两句吧...

相关阅读