Question

我无法找到一种方法让我的线程在我的脚本的第一次和第二次调用之间保持不变。

到目前为止，当我运行python script_1.py A时，脚本运行if option == 'A'块并启动线程。然后，脚本退出并清除线程。因此，当我运行python script_1.py B时，isAlive属性无法使用。

有没有办法保持持久性？

script_1.py的代码是：

from script_2 import imp

script_2 = imp()
if option == 'A':
  script_2.start()
elif option == 'B':
  script_2.stop()

并且对于script_2.py是：

from threading import Thread

class workerThread(Thread):
  def __init__(self, _parent):
    Thread.__init__(self)
    self.parent = _parent
    self.active = False

  def run(self):
    while(self.active == False):
      print 'I am here'
    print 'and now I am here'

class imp():
  def __init__(self):
    self.threadObj = None

  def start(self):
    self.threadObj = workerThread(self)
    self.threadObj.start()

  def stop(self):
    if self.threadObj.isAlive() == True:
      print 'it is alive'

Answer 1

解决方案是：

from threading import Thread
from socket import *
from time import sleep
class workerThread(Thread):
  def __init__(self):
    Thread.__init__(self)
    self.sock = socket()
    self.sock.bind(('', 9866))
    self.sock.listen(4)
    self.start()

  def run(self):
    while 1:
      ns, na = self.sock.accept()
      if ns.recv(8192) in (b'quit', 'quit'):
        ns.close()
        break
    self.sock.close()
    print('Worker died')

imp = workerThread()

第一个脚本：

if option == 'A':
  from time import sleep
  from script_2 import imp
  while 1:
    sleep(0.1)
elif option == 'B':
  from socket import *
  s = socket()
  s.connect(('127.0.0.1', 9866))
  s.send('quit') # b'quit' if you're using Python3
  s.close()

它甚至没有接近优雅，但它是你可以做的5分钟模型。
为了使其更接近可用代码，我选择：

self.sock = fromfd('/path/to/socket', AF_UNIX, SOCK_DGRAM)

并将其注册到工作线程中的ePoll对象。

import select
self.watch = select.epoll()
self.watch.register(self.sock.fileno(), select.EPOLLIN)

while 1:
    for fd, event in self.watch.poll(0.1):
        if fd == self.sock.fileno() and event == select.EPOLLIN:
            ns, na = self.sock.accept()
            # store socket and register it
        elif event == select.EPOLLIN:
            data = storedSockets[fd].recv(8192)
            # and do work on it

无论如何，但你需要保持你的第一个执行实例运行并为你启动的第二个实例创建某种形式的通信方法，我使用套接字作为一个例子，我认为这是相当不错的，特别是与unix套接字和epoll，因为速度是fantastisc。您也可以使用memcache

调用之间的线程持久性

1 个答案: