Multithreading et mise en veille
Bonjour,
Je développe actuellement un programme utilisant le multithreading et je me heurte a un gros problème.
Lors de la veille de la machine il semble qu'une partie du programme continue, tandis que l'autre ne s'exécute plus.
Cependant ca n'arrive pas a chaque mise en veille, donc j'ai beaucoup de mal a comprendre d'ou ca vient.
Le main est les suivant :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
|
#!/usr/bin/env python
# encoding: utf-8
from DB_Reader_Writer import *
from WL_threading import *
from UsefullFuction import *
from Downloader import *
import threading, Queue
import events_db
import sys, os
import WL_threading
from WL_web_services import INGV_requestor
from events_db import DBEventList
from WL_DB_stuff import *
from velmod import VelocityModel
#writer
Writer=DB_Writer("waveloc")
#Writer.Create_All_Tables()
#################### create workers ###########################################
#download
requestsQueue_Download = Queue.Queue()
resultsQueue_Download = Queue.Queue()
workRequests_Download={}
for i in range(1):
worker_Download = Worker(requestsQueue_Download, resultsQueue_Download)
#untar
requestsQueue_Untar = Queue.Queue()
resultsQueue_Untar = Queue.Queue()
workRequests_Untar={}
for i in range(1):
worker_Untar = Worker(requestsQueue_Untar, resultsQueue_Untar)
#reader
Reader=DB_Reader("waveloc")
Writer.Create_All_Tables()
#################### create work list ################################
Liste_Download_data=Reader.Extract_Waveloc_for_Download(1000)
print "Dowload list : ",Liste_Download_data
liste_ID_and_number=[]
liste_fseed_name=[]
################### work ###############################
#dowload data
Requestor=Downloader('user@domain.com', 'passeword', data_dir,"waveloc")
#launch the download request
for Waveloc_ID in Liste_Download_data :
id = worker_Download.performWork( Requestor.run_circular_query_and_return_path, Waveloc_ID)
workRequests_Download[id] = str(Waveloc_ID)
#wait resultats about download request to untar data and complet the waveloc_data table and station_data table
while workRequests_Download:
time.sleep(1)
showResults(resultsQueue_Download,workRequests_Download,liste_ID_and_number)
###untar data
for ID_and_number in liste_ID_and_number :
if ID_and_number[1] !='False' :
id = worker_Untar.performWork(Untar_data,data_dir,ID_and_number[1],ID_and_number[0],'True')
workRequests_Untar[id] = ID_and_number
liste_ID_and_number.remove(ID_and_number)
while workRequests_Untar:
time.sleep(1)
showResults(resultsQueue_Untar,workRequests_Untar,liste_fseed_name)
for ID_Fseed in liste_fseed_name :
#complet waveloc_data table
fseed_full_filename= ID_Fseed[1][0]
fseed_filename="%s%s%s"%(fseed_full_filename.split(os.sep)[-2], os.sep, fseed_full_filename.split(os.sep)[-1])
Writer.put_fseed_data_into_waveloc_db(fseed_filename,ID_Fseed[0][0])
#complet station_data table
station_data_list=read_stations_file(ID_Fseed[1][1])
for station_data in station_data_list:
Writer.put_station_data_into_waveloc_db(station_data)
#complet station and waveloc table (table obsolete)
#station_name_and_net=[(station_data[0],station_data[1])]
#Writer.populate_waveloc_and_stations_db(ID_Fseed[0][0],station_name_and_net)
#remove ID_Fseed from the list
liste_fseed_name.remove(ID_Fseed) |
et les travailleur en parallèles suivent ce code (trouvé dans le manuel "python in a nutshell"
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| class Worker(threading.Thread):
requestID=0
def __init__(self,requestsQueue,resultsQueue,**kwds):
threading.Thread.__init__(self, **kwds)
self.setDaemon(1)
self.workRequestQueue = requestsQueue
self.resultQueue = resultsQueue
self.start()
def performWork(self,callable,*args,**kwds):
# called by the main thread as callable would be, but w/o return
Worker.requestID += 1
self.workRequestQueue.put((Worker.requestID, callable, args, kwds))
return Worker.requestID
def run(self):
while 1:
(requestID, callable, args, kwds) = self.workRequestQueue.get()
self.resultQueue.put((requestID,callable(*args, **kwds))) |
Le main va télécharger des données puis en parallèle du prochain téléchargement vas les extraire et les insérer dans une base de donnée.
Cependant il arrive, après une mise en veille, que le téléchargement se poursuive sans que le reste du travail soit effectué. (il n'y a cependant plus de messages envoyés sur la sortie standard)
Ce problème a eut lieu sur une machine sous debian, tout comme sur une machine sous MacOs
