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

暗夜之隐

def m_m_refresh(t,tt):

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

        for e in range(20):
            time.sleep(3)
            if tt==True:
                print(n,'=================')
                return True
            else:
                pass
            print(e,tt)
            

_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 ...

def ce():

    t =1
    lock = _thread.allocate_lock()
    lock.acquire()
                
    _thread.start_new_thread(m_m_refresh,(t,''))
    
    time.sleep(10)
    lock.release()

def m_m_refresh(t,k):
    
    global lock

    for v in range(t):

        for e in range(20):
            time.sleep(3)
            if lock.locked():
                pass
            else:
                print('=================')
                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`类。下面是修改后的代码：

import threading
import time

# 创建线程锁对象
lock = threading.Lock()

def ce():
    t = 1
    lock.acquire()
    threading.Thread(target=m_m_refresh, args=(t, '')).start()
    time.sleep(10)
    lock.release()

def m_m_refresh(t, k):
    global lock

    for v in range(t):

        for e in range(20):
            time.sleep(3)
            if lock.locked():
                pass
            else:
                print('=================')
                return True

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 成为了全局变量

def ce():

    t =1
    lock = _thread.allocate_lock()
    lock.acquire()       
    _thread.start_new_thread(m_m_refresh,(t,lock))

    
    lock.release()
                [code]        
def m_m_refresh(t,lock):

    print(lock.locked())
    for v in range(t):

        for e in range(20):
            time.sleep(3)
            if lock.locked():
                #print(lock.locked())
                pass
            else:
                print(lock.locked(),'=================')
                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 小助理，如未能正确解答您的问题，请继续追问。