import threading import time g_num = 0 def test1(num): global g_num lock.acquire() # 上锁 for i in range(num): g_num += 1 lock.release() # 解锁 print('test1-->', g_num) def test2(num): global g_num lock.acquire() for i in range(num): g_num += 1 lock.release() print('test2-->', g_num) lock = threading.Lock() # 创建一个锁 if __name__ == '__main__': t1 = threading.Thread(target=test1, args=(1000000,)) t2 = threading.Thread(target=test2, args=(1000000,)) t1.start() t2.start()
时间: 2024-04-27 09:20:05 浏览: 13
这是一个 Python 多线程程序,其中定义了两个函数 test1 和 test2。这两个函数都会对全局变量 g_num 进行加 1 操作,并且在操作前会先获取锁,在操作完成后再释放锁。
在主程序中,创建了两个线程 t1 和 t2,分别调用 test1 和 test2 函数,并传入参数 1000000。然后启动这两个线程,让它们并行地执行。
由于这两个线程都会对 g_num 进行操作,而且操作不是原子性的,因此需要使用锁来保证线程安全,避免多个线程同时修改同一个变量造成数据混乱。
相关问题
帮我看看这段代码为什么运行不出来import threading import time class Library(threading.Thread): def __init__(self): threading.Thread.__init__(self) self.book_num=0 def borrow(self): global book_count global lock while True: lock = threading.Lock() time.sleep(1) if book_count>0: lock.acquire() time.sleep(0.1) book_count-=1 # book_count=book_count-1 self.book_num+=1 lock.release() print(f"借走{self.book_num}本,现有图书{book_count}本") else: break def back(self): global book_count global lock while True: lock = threading.Lock() time.sleep(3) # time.sleep(0.1) lock.acquire() book_count += 1 # book_count=book_count+1 lock.release() self.book_num -= 1 print(f"归还{self.book_num}本,现有图书{book_count}本") book_count=100 result1=Library() result2=Library() result1.start() result2.start() result1.join()
这段代码有几个问题:
1. 在 borrow 和 back 方法里面,每次 while 循环都会重新创建一个锁对象。应该在外部创建好锁对象,然后将锁对象传递给 borrow 和 back 方法。
2. 在 borrow 方法里面,调用了 lock.acquire() 方法获得锁,但是在程序执行完毕后没有调用 lock.release() 方法释放锁。这会导致程序出现死锁。
3. 在 back 方法里面,self.book_num 减去 1 的代码应该在 lock.release() 方法之前执行,否则会导致程序出现竞争条件。
下面是修改后的代码:
```python
import threading
import time
class Library(threading.Thread):
def __init__(self, lock):
threading.Thread.__init__(self)
self.book_num = 0
self.lock = lock
def borrow(self):
global book_count
while True:
time.sleep(1)
if book_count > 0:
self.lock.acquire()
time.sleep(0.1)
book_count -= 1
self.book_num += 1
print(f"借走{self.book_num}本,现有图书{book_count}本")
self.lock.release()
else:
break
def back(self):
global book_count
while True:
time.sleep(3)
self.lock.acquire()
self.book_num -= 1
book_count += 1
print(f"归还{self.book_num}本,现有图书{book_count}本")
self.lock.release()
book_count = 100
lock = threading.Lock()
result1 = Library(lock)
result2 = Library(lock)
result1.start()
result2.start()
result1.join()
```
import threading num = 0 lock = threading.Lock() def handler_incry(): global num lock.acquire() for i in range(10): num += 1 print("handler_incry done, num =", num) lock.release() def handler_decry(): global num lock.acquire() for i in range(10): num -= 1 print("handler_decry done, num =", num) lock.release() if __name__ == '__main__': t1 = threading.Thread(target=handler_incry) t2 = threading.Thread(target=handler_decry) t1.start() t2.start() t1.join() t2.join()
这段代码是一个使用锁(Lock)实现线程同步和互斥的例子。其中,有两个线程分别对一个全局变量 num 进行加减操作,使用锁来保证同一时刻只有一个线程能够访问共享资源(即 num 变量)。
具体实现如下:
1. 定义全局变量 num 和锁 lock。
```python
import threading
num = 0
lock = threading.Lock()
```
2. 定义两个线程分别对 num 进行加和减操作。
```python
def handler_incry():
global num
lock.acquire() # 获取锁
for i in range(10):
num += 1
print("handler_incry done, num =", num)
lock.release() # 释放锁
def handler_decry():
global num
lock.acquire() # 获取锁
for i in range(10):
num -= 1
print("handler_decry done, num =", num)
lock.release() # 释放锁
```
3. 在主线程中创建两个子线程,并启动它们。
```python
if __name__ == '__main__':
t1 = threading.Thread(target=handler_incry)
t2 = threading.Thread(target=handler_decry)
t1.start() # 启动线程1
t2.start() # 启动线程2
t1.join() # 等待线程1执行完毕
t2.join() # 等待线程2执行完毕
```
当线程1获取锁并对 num 进行加操作时,线程2会被阻塞,直到线程1释放锁后才能获取锁并对 num 进行减操作。这样就保证了同一时刻只有一个线程能够访问共享资源,从而避免了数据竞争和死锁等问题。
总的来说,这段代码是一个简单的例子,展示了如何使用锁(Lock)实现线程同步和互斥。在实际应用中,需要根据具体场景选择合适的线程同步和互斥机制,以确保多线程程序的正确性和稳定性。