Python Worker.start方法代码示例

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import start [as 别名]
class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.worker = None
        self.statusBar().showMessage('ready')
        self.resize(250, 150)
        self.move(300, 300)
        self.setWindowTitle('刷起来')
        self.setWindowIcon(QIcon('icon.ico'))
        self.imagesPath = "./images/tp14/"
        self.toolBar = self.addToolBar('')

        GameStatus().window = self

        yaoguaifaxian_action = QAction(QIcon('./images/ui/yaoguaifaxian.jpg'), '妖怪发现', self)
        yaoguaifaxian_action.triggered.connect(self.yaoguaifaxian)

        exit_action = QAction(QIcon('./images/ui/exit.png'), '停止', self)
        exit_action.setShortcut('Ctrl+Q')
        exit_action.triggered.connect(self.stop_loop)


        self.toolBar.addAction(yaoguaifaxian_action)
        self.toolBar.addAction(exit_action)

        txt = QTextBrowser()
        txt.setContentsMargins(5, 5, 5, 5)
        self.setCentralWidget(txt)
        self.show()

    def add_text(self, text):
        self.centralWidget().append(text)
        sb = self.centralWidget().verticalScrollBar()
        sb.setValue(sb.maximum())
        print(text)

    def closeEvent(self, *args, **kwargs):
        self.stop_loop()
        print("关闭程序")

    def status_changed(self):
        if self.worker is None:
            self.statusBar().showMessage("就绪。")
        elif self.worker.stopped():
            self.statusBar().showMessage("已停止。")
        else:
            self.statusBar().showMessage("当前次数： " + str(self.worker.cnt))

    def yaoguaifaxian(self):
        if self.worker is not None and not self.worker.stopped():
            return

        self.worker = Worker(self.imagesPath)
        GameStatus().game_stage = GameStage.Yaoguaifaxian
        self.worker.start()

    def stop_loop(self):
        if self.worker is None:
            return
        self.worker.stop()

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import start [as 别名]
    def __init__(self, node_id, data):
        """
        Constructor.

        @type node_id: Integer
        @param node_id: the unique id of this node; between 0 and N-1

        @type data: List of Integer
        @param data: a list containing this node's data
        """
        self.node_id = node_id
        self.data = data
        # temporary buffer for needed for scatter 
	self.copy = data[:]
        self.lock_copy = Lock()
        self.nodes = None
        self.lock_data = Lock()
        # list of threads (in this case 16 fo each node)
	self.thread_list = []
	# list with tasks that need to be computed
        self.thread_pool = []
        self.mutex = Lock()
        # condition used for put and get
	self.condition = Condition(self.mutex)
	# condition needed for checking if there are 
	# still tasks that need o be solved
        self.all_tasks_done = Condition(self.mutex)
	# number of unfinished tasks
        self.unfinished_tasks = 0
        # start the 16 threads
	for i in range(16):
            th = Worker(self, i)
            self.thread_list.append(th)
            th.start()

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import start [as 别名]
def main():

    context = zmq.Context()

    orderReceiver = context.socket(zmq.REP)
    orderReceiver.bind("tcp://127.0.0.1:5559")
#    orderReceiver.setsockopt(zmq.SUBSCRIBE, "")

#CalledProcessError:
    worker_ = Worker()
    while True:

        order = orderReceiver.recv_json()

        if order['command'] == 'stop':
            worker_.go = False
            orderReceiver.send_json('ack')
            worker_ = Worker()

        elif order['command'] == 'start':
            if worker_.go:
                orderReceiver.send_json('already running')
                continue
            worker_.newJob(order['interval'], order['filename'], order['batch'])
            worker_.start()
            orderReceiver.send_json('ack')

        elif order['command'] == 'status':
            choices = {True: 'on',
                       False: 'off',}

            orderReceiver.send_json(choices[worker_.go])

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import start [as 别名]
def init_workers():
    global mail
    global workers
    with app.app_context():
        mail.init_app(app)
        worker = Worker(app, mail)
        # start the thread
        worker.start()
        workers.append(worker)

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import start [as 别名]
def handleCommand(cmd, workers):
	cmd = cmd.strip().lower()
	if(cmd == '-a'):
		w = Worker()
		workers.append(w)
		w.start()
	elif(cmd == '-q'):
		exit(0)
	else:
		workerID = int(cmd.split()[1])
		w = workers.pop(workerID)
		w.stop()

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import start [as 别名]
def main(argv):
	result = Result()
	
	w1 = Worker(0.1, 100, result)
	w1.start()	
	w1.join()
	
	w2 = Worker(0.2, 200, result)
	w2.start()	
	w2.join()
	
	print result.get()
	print "Done."

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import start [as 别名]
    def serve(self):
        if self.config["server"]["tracker"] != None:
            self.proxymanager = ProxyManager(self.config["server"]["tracker"], self.config["server"]["port"])
            self.proxymanager.daemon = True
            self.proxymanager.start()

        for i in range(int(self.config["server"]["workers"])):
            w = Worker(self)
            w.daemon = True
            w.start()

        while True:
            self.clientqueue.put(self.sock.accept())

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import start [as 别名]
 def test_child_thread(self):
     from worker import Worker
     
     parent = Worker()
     child = Worker(parent=parent)
     
     parent.start()
     child.start()
     
     parent.stop().join()
     
     self.assertFalse(parent.is_running())
     self.assertFalse(child.is_running())

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import start [as 别名]
    def Run(self, cmd):
        """Sets up the Running view and starts threads"""
        self.view_running = view.Running()
        self.view_running.Bind(wx.EVT_CLOSE, self.OnCancel)
        self.view_running.Bind(wx.EVT_MENU, self.OnCancel, self.view_main.menu_exit)
        self.view_running.button_cancel.Bind(wx.EVT_BUTTON, self.OnCancel)
        self.view_main.Enable(False)
        self.view_running.Show()

        self.tracklist = getselected()

        for i in range(db.config("max_threads")):
            thread = Worker(i, self, cmd)
            self.threads.append(thread)
            thread.start()

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import start [as 别名]
	def main(self, argv):
		res1 = Resource()
		res2 = Resource()
		res1.setSecondLevel(res2)
		res2.setSecondLevel(res1)

		w1 = Worker(res1)
		w2 = Worker(res1)

		w1.start()
		w2.start()
		
		w1.join()
		w2.join()
		return 0

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import start [as 别名]
def main(argv):
	n = 5
	if len(argv) >= 2:
		n = int(argv[1])

	counter = Counter()
		
	w1 = Worker(counter, n)
	w2 = Worker(counter, n)
	
	#print "Starting threads"
	w1.start()
	w2.start()
	
	w1.join()
	w2.join()
	print counter.getValue()
	print "Done."

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import start [as 别名]
 def onAddT(self):
     ''' Add new topic.
     '''
     lang = self.lstLangs.currentItem()
     if not lang:
         return
     lang = lang.text()
     url, ok = QInputDialog.getText(self, 'add topic', 'Input url for {}'.format(lang))
     if ok and lang and url and url.strip():
         try:
             thread = Worker(lang, url, self)
             thread.update.connect(self._appendQuestion)
             thread.finish.connect(self._finishAddQuestions)
             thread.start()
         except FileExistsError:
             QMessageBox.information(self, 'Error', 'This topic exists already.')
         except ValueError:
             QMessageBox.information(self, 'Error', 'cannot access the url.')

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import start [as 别名]
	def run(self):
		self.logger.info('Focused Web Crawler launched')
		self.logger.info('Starting workers')
		for i in xrange(self.nworkers):
			worker = Worker(self.queue, self.visited_urls, self.mutex, self.collection, self.collection_mutex)
			self.workers.append(worker)
			worker.start()

		self.queue.join() # Wait until all items are consumed

		for i in xrange(self.nworkers): # send a 'None signal' to finish workers
			self.queue.put(None)

		self.queue.join() # Wait until all workers are notified

#		for worker in self.workers:
#			worker.join()

		self.logger.info('Finished workers')
		self.logger.info('Focused Web Crawler finished')

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import start [as 别名]
class StreamConsumer(object):

    def __init__(self, callback, url, auth):
        self.callback = callback
        self.url = url
        self.auth = auth

    def start(self):
        self.worker = Worker(self.url, self.auth, self.callback)
        self.worker.start()
        while not self.worker.stopped():
            try:
                time.sleep(1)
            except KeyboardInterrupt:
                print "\n"
                print "Exiting..."
                self.worker.stop()
                self.worker.join()
                raise
            except:
                raise

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import start [as 别名]
    def process(self, message):
        if message.type == "HERMES_WORKER_CREATE":
            w = Worker(Manager.instance)
            w.start()

            return "HERMES MGR: New worker has been created"

        if message.type == "HERMES_WORKER_DESTROY":
            data = json.loads(message.content)
            worker_id = data["worker"]["id"]
            w = Worker.get_worker(worker_id)
            if w:
                w.alive = False
                return "HERMES MGR: Worker {} has been destroyed.".format(worker_id)
            else:
                return "HERMES MGR: No such worker: {}".format(worker_id)

        if message.type == "HERMES_WORKER_STATUS":
            workers = Manager.instance.worker_status()
            response = {"workers": []}
            for worker in workers:
                response["workers"].append({"worker": {"id:": worker}})

            data = json.loads(response)
            print json

        if message.type == "HERMES_REGISTER_MESSAGE":
            """
            Register a new message type
            """
            data = json.loads(message.content)
            try:
                MessageType(data["name"])
            except ValueError as e:
                return "HERMES MGR: {}".format(e.message)

            return "HERMES MGR: Message type '{}' has been registered.".format(data["name"])