Question

我必须在Python 2.7中编写一个类，但我遇到了一些问题。我最近来自java背景和学习python

如果我必须在java中做什么，我会写这个

public class CommandSender extends Thread {
    private boolean isTimeOut;
    private boolean running;
    private ArrayList<Command> waitingList;

    public CommandSender() {
        running = false;
        waitingList = new LinkedList<Command>();
        isTimeOut = false;
    }

    public void run() {
        running = true;
        while (running) {
            synchronized (this) {
                 while (waitingList.isEmpty() && running) {
                     try {
                         wait();
                     } catch (InterruptedException ie) {
                         ie.printStackTrace();
                     }
                  }
                  while (!waitingList.isEmpty() && running) {
                      currentCmd = waitingList.remove(0);
                      // doSomething(currentCmd)
                  }
             }
        }
    }

    public synchronized void sendCommand(Command cmd) {
        waitingList.add(cmd);
        notify();
    }

    public synchronized boolean isTimeOut() {
        return isTimeOut;
    }
}

我目前做了什么

class CommandSender(threading.Thread)

     def __init__(self):
         threading.Thread.__init__(self)
         self.waiting_list = []
         self.running = False
         self.is-time_out = False
         self.my_lock = threading.Lock()

     def run(self):
         self.running = True
         with self.my_lock:
             while len(self.waiting_list) == 0 and self.running:
                 # Don't know what I have to do here
             while len(self.waiting_list) != 0 and self.running:
                 # Do my stuff

     def send_command(self, cmd):
         with self.my_lock:
             self.waiting_list.append(cmd)
             # Notify ?

     def is_time_out(self):
         with self.my_lock:
             return self.is_rime_out

我为每个实例使用一个锁，因为只有一个CommandSender实例

那么如何进行等待/通知过程？我的同步块是否很好用？

谢谢！

Answer 1

首先，您应该知道Python global interpreter lock不会允许多个线程同时运行Python代码（尽管线程可以运行，例如C代码，例如使用本机代码模块，如果他们适当地释放GIL）。如果您需要使用Python代码来使用多核CPU，请查看multiprocessing模块。

现在，直接等效的是threading.Event类。创建Event对象，然后使用wait和set。

Answer 2

这听起来像一个简单的生产者 - 消费者队列。在Java中，您应该考虑使用ConcurrentLinkedQueue。在Python中，您可以使用Queue.Queue类用于线程程序，使用multiprocessing.Queue类用于使用multiprocessing的程序。

除非这是家庭作业，否则您需要使用某种特定的锁定机制自行实现代码。我知道实现生产者 - 消费者队列的最简单方法是使用两个或三个信号量：

一个信号量，用于计算队列中元素的数量。最初为零。
一个信号量，用于计算队列中元素的限制/最大数量，以此最大数量初始化。如果您不需要有限的队列，这是可选的。
用于共享访问内部队列/链接列表的一个信号量，互斥或临界区。在Python中，这不是线程程序所必需的，因为GIL允许您向列表添加元素而无需同步线程。

Python的等效Java函数wait（），notify（），synchronized

2 个答案: