多线程资源访问 - 锁的放置位置

在本文中，我们将探讨多线程编程中常见的问题 - 当多个线程需要写入同一个文件时，如何使用锁来防止并发问题。我们将重点关注锁的正确使用方法：是将锁作为全局变量还是在每个线程中单独创建锁。

2、解决方案

方法一：使用文件子类进行锁定

一种方法是创建一个带有锁的文件子类，如下所示：

class LockedWrite(file):
    """ Wrapper class to a file object that locks writes """
    def __init__(self, *args, **kwds):
        super(LockedWrite, self).__init__(*args, **kwds)
        self._lock = Lock()

    def write(self, *args, **kwds):
        self._lock.acquire()
        try:
            super(LockedWrite, self).write(*args, **kwds)
        finally:
            self._lock.release()

然后，在代码中使用此子类来替换原有的文件对象：

def main():
    f = LockedWrite('foo.txt', 'a')

    for i in range(20):
        agent = Agent(i, f)
        agent.start()

class Agent(Thread):
    def __init__(self, thread_num, fileobj):
        Thread.__init__(self)
        self.thread_num = thread_num
        self._file = fileobj    

    # ...

    def write_result(self):
        self._file.write('hello from thread %s\n' % self.thread_num)

这种方法将文件锁定放在文件中本身，使得代码更加简洁。

方法二：在方法外创建锁

另一种方法是在方法外创建锁，如下所示：

class Agent(Thread):
    mylock = Lock()
    def write_result(self):
        self.mylock.acquire()
        try:
            ...
        finally:
            self.mylock.release()

或者，如果您使用 Python 2.5 或更高版本，可以使用 with 语句：

class Agent(Thread):
    mylock = Lock()
    def write_result(self):
        with self.mylock:
            ...

这种方法确保所有线程都使用同一个锁对象，从而避免了锁的重复创建和释放。

方法三：使用队列进行同步

最后，您还可以使用队列来同步对文件的写入。您可以创建一个单独的线程，专门负责写入文件，而其他线程则将要写入的数据放入队列。写入线程从队列中获取数据并将其写入文件。这种方法可以简化代码，并避免了锁的使用。

import queue

def main():
    q = queue.Queue()

    # Create a thread to write to the file
    writer = Thread(target=file_writer, args=(q,))
    writer.start()

    # Create 20 agents that will write to the queue
    for i in range(20):
        agent = Agent(i, q)
        agent.start()

def file_writer(q):
    while True:
        # Block until there is something in the queue
        data = q.get()

        # Write the data to the file
        with open('foo.txt', 'a') as f:
            f.write(data)

class Agent(Thread):
    def __init__(self, thread_num, q):
        Thread.__init__(self)
        self.thread_num = thread_num
        self._queue = q

    def run(self):
        while True:
            print('hello from thread %s' % self.thread_num)
            self.write_result()   

    def write_result(self):
        self._queue.put('hello from thread %s\n' % self.thread_num)

希望这些方法能帮助您解决多线程资源访问问题。