[已解决]关于多线程改变 变量值

暗夜之隐

1. def m_m_refresh(t,tt):
   
2. 
   
3.     n=''
   
4.     for v in range(t):
   
5. 
   
6.         for e in range(20):
   
7.             time.sleep(3)
   
8.             if tt==True:
   
9.                 print(n,'=================')
   
10.                 return True
    
11.             else:
    
12.                 pass
    
13.             print(e,tt)
    
14.             

复制代码

1. _thread.start_new_thread(m_m_refresh,(t,tt))

复制代码

我写了这个函数 初始值 t =1  tt=False
当我运行后 我是想在外部改变tt的值 然后终止函数 可是我在外改变了tt 里面的tt 还是没变

最佳答案

月排行榜 / 总排行榜

FishC

2024-6-1 11:12:30

在Python中，当你在不同的线程中使用共享变量时，可能会遇到并发问题。这是因为多个线程同时访问和修改同一个变量，可能导致不可预测的结果。

解决这个问题的常用方法是使用线程锁。线程锁可以确保一次只有一个线程可以访问和修改共享变量。下面是你的代码的修改版本，添加了线程锁：

import _thread
import time

# 创建线程锁对象
lock = _thread.allocate_lock()

def m_m_refresh(t, tt):

    global lock  #引入全局锁对象

    n = ''
    for v in range(t):

        for e in range(20):
            time.sleep(3)
            with lock:  # 使用with语句获取锁
                if tt == True:
                    print(n, '=================')
                    return True
                else:
                    pass
            print(e, tt)

_thread.start_new_thread(m_m_refresh, (t, tt))

现在，每当你想在外部改变tt的值并终止函数时，你可以使用线程锁，确保修改操作的原子性。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

跳转到最佳答案楼层

FishC

在Python中，当你在不同的线程中使用共享变量时，可能会遇到并发问题。这是因为多个线程同时访问和修改同一个变量，可能导致不可预测的结果。

解决这个问题的常用方法是使用线程锁。线程锁可以确保一次只有一个线程可以访问和修改共享变量。下面是你的代码的修改版本，添加了线程锁：

import _thread
import time

# 创建线程锁对象
lock = _thread.allocate_lock()

def m_m_refresh(t, tt):

    global lock  #引入全局锁对象

    n = ''
    for v in range(t):

        for e in range(20):
            time.sleep(3)
            with lock:  # 使用with语句获取锁
                if tt == True:
                    print(n, '=================')
                    return True
                else:
                    pass
            print(e, tt)

_thread.start_new_thread(m_m_refresh, (t, tt))

现在，每当你想在外部改变tt的值并终止函数时，你可以使用线程锁，确保修改操作的原子性。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

暗夜之隐

FishC 发表于 2024-6-1 11:12
在Python中，当你在不同的线程中使用共享变量时，可能会遇到并发问题。这是因为多个线程同时访问和修改同一 ...

陶远航 发表于 2023-8-9 15:58
根据您提供的信息，您想要访问名为"datas"的变量，但是不清楚如何进行访问，因为存在多个包含不同id的scrip ...

1. def ce():
   
2. 
   
3.     t =1
   
4.     lock = _thread.allocate_lock()
   
5.     lock.acquire()
   
6.                
   
7.     _thread.start_new_thread(m_m_refresh,(t,''))
   
8.    
   
9.     time.sleep(10)
   
10.     lock.release()
    
11. 
    
12. def m_m_refresh(t,k):
    
13.    
    
14.     global lock
    
15. 
    
16.     for v in range(t):
    
17. 
    
18.         for e in range(20):
    
19.             time.sleep(3)
    
20.             if lock.locked():
    
21.                 pass
    
22.             else:
    
23.                 print('=================')
    
24.                 return True

复制代码

ce()

我运行了还是不行 lock 还是一个局部变量

FishC

暗夜之隐 发表于 2024-06-01 12:35
def ce():

    t =1
    lock = _thread.allocate ...

对不起，我之前的回答有误导性。确实，lock变量是一个局部变量，并不能在`ce()`函数和`m_m_refresh()`函数之间共享。

在Python中，更常用的线程同步机制是使用`threading`模块提供的`Lock`类。下面是修改后的代码：

1. import threading
   
2. import time
   
3. 
   
4. # 创建线程锁对象
   
5. lock = threading.Lock()
   
6. 
   
7. def ce():
   
8.     t = 1
   
9.     lock.acquire()
   
10.     threading.Thread(target=m_m_refresh, args=(t, '')).start()
    
11.     time.sleep(10)
    
12.     lock.release()
    
13. 
    
14. def m_m_refresh(t, k):
    
15.     global lock
    
16. 
    
17.     for v in range(t):
    
18. 
    
19.         for e in range(20):
    
20.             time.sleep(3)
    
21.             if lock.locked():
    
22.                 pass
    
23.             else:
    
24.                 print('=================')
    
25.                 return True
    
26. 
    
27. ce()

复制代码

在这个修改后的代码中，我们使用了`threading`模块的`Lock()`函数创建了一个全局的线程锁对象`lock`。然后，在`ce()`函数中，我们通过调用`lock.acquire()`获取锁对象，以确保在`m_m_refresh()`函数中只能有一个线程访问临界区。当`ce()`函数执行完毕后，我们调用`lock.release()`释放锁对象。

现在你应该能够在外部改变tt的值并终止函数了。希望这次能够解决你的问题。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

暗夜之隐

FishC 发表于 2024-6-1 12:35
对不起，我之前的回答有误导性。确实，lock变量是一个局部变量，并不能在`ce()`函数和`m_m_refresh()` ...

这样呀  也就是一开始就把lock 成为了全局变量

1. def ce():
   
2. 
   
3.     t =1
   
4.     lock = _thread.allocate_lock()
   
5.     lock.acquire()      
   
6.     _thread.start_new_thread(m_m_refresh,(t,lock))
   
7. 
   
8.    
   
9.     lock.release()
   
10.                 [code]        
    
11. def m_m_refresh(t,lock):
    
12. 
    
13.     print(lock.locked())
    
14.     for v in range(t):
    
15. 
    
16.         for e in range(20):
    
17.             time.sleep(3)
    
18.             if lock.locked():
    
19.                 #print(lock.locked())
    
20.                 pass
    
21.             else:
    
22.                 print(lock.locked(),'=================')
    
23.                 return True
    

复制代码

[/code]

我现在是这样 直接传的变量进去

FishC

暗夜之隐 发表于 2024-06-01 12:45
这样呀  也就是一开始就把lock 成为了全局变量

def ...

是的，你的修改是正确的。你在`ce()`函数中创建了一个局部的线程锁对象`lock`，然后将它作为参数传递给`m_m_refresh()`函数。通过这种方式，你可以确保在`m_m_refresh()`函数中访问和操作相同的锁对象。

在`m_m_refresh()`函数内部，你可以使用`lock.locked()`方法来检查锁是否被获取。当锁被获取时，表示另一个线程正在运行临界区的代码，因此你可以继续等待。当锁未被获取时，表示没有其他线程正在运行临界区的代码，你就可以执行你想要的操作。

最后，你在代码中打印了`lock.locked()`的值，以验证锁的状态。希望这样能够满足你的需求并解决你的问题。祝你编程愉快！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

暗夜之隐

FishC 发表于 2024-6-1 12:45
是的，你的修改是正确的。你在`ce()`函数中创建了一个局部的线程锁对象`lock`，然后将它作为参数传递给 ...

谢谢

FishC

暗夜之隐 发表于 2024-06-01 14:06
谢谢

不客气！如果你还有其他问题，欢迎随时提问。祝你学习编程的过程顺利并且充满乐趣！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。