Counting Threads

Just sorted (its always the way when you post isn't it)

But the count isn't doint what I expected. I was after a increment
after every time the class was used ireespective of instance. Instead
I get a count based on the instance usage.

Idea's anyone?

#
------------------------------------------------------------------------------------
class ServerThreads:
"""
Wrapper for thread handling.
Thread ID 0 = Controller
Thread ID 1 = Plant Object 1
Thread ID 2 = Plant Object 2
"""

GlobalThreadCou nt = 0

def __init__(self):
global GlobalThreadCou nt
self.Threads = {}
GlobalThreadCou nt = 0
def launch(self, SubToLaunch, SubsArgs=(), SubsKwargs={},
AsDeamon=True):
t = Thread(target=S ubToLaunch, args = SubsArgs, kwargs =
SubsKwargs)
t.setDaemon(AsD eamon)
t.start()
self.Threads[len(self.Thread s)] = t # Stash the
thread in an instance local

global GlobalThreadCou nt
GlobalThreadCou nt += 1
print GlobalThreadCou nt

def globalusagecoun t(self):
"""
Returns a count figure for how many threads are running in
total
usnig this class.
"""
global GlobalThreadCou nt
return GlobalThreadCou nt
def stop(self,Threa dID):
t = self.Threads[ThreadID]
t.stop()
self.Threads.cl ear[ThreadID]

def count(self):
"""
Returns alist of how many threads are running in the instance
"""
return len(self.Thread s)

def runningkeys(sel f):
"""
Returns a llist of all running Keys
"""
return self.Threads.ke ys

def allOK(self):
"""
Returns a list of all threads that are down if any)
"""
ThreadsDown = []
for t in self.Threads:
if not self.Threads[t].isAlive:
ThreadsDown.app end(t)
return ThreadsDown

Just sorted (its always the way when you post isn't it)

But the count isn't doint what I expected. I was after a increment
after every time the class was used ireespective of instance. Instead
I get a count based on the instance usage.

Idea's anyone?

#
------------------------------------------------------------------------------------
class ServerThreads:
"""
Wrapper for thread handling.
Thread ID 0 = Controller
Thread ID 1 = Plant Object 1
Thread ID 2 = Plant Object 2
"""

GlobalThreadCou nt = 0

def __init__(self):
global GlobalThreadCou nt
self.Threads = {}
GlobalThreadCou nt = 0
def launch(self, SubToLaunch, SubsArgs=(), SubsKwargs={},
AsDeamon=True):
t = Thread(target=S ubToLaunch, args = SubsArgs, kwargs =
SubsKwargs)
t.setDaemon(AsD eamon)
t.start()
self.Threads[len(self.Thread s)] = t # Stash the
thread in an instance local

global GlobalThreadCou nt
GlobalThreadCou nt += 1
print GlobalThreadCou nt

def globalusagecoun t(self):
"""
Returns a count figure for how many threads are running in
total
usnig this class.
"""
global GlobalThreadCou nt
return GlobalThreadCou nt
def stop(self,Threa dID):
t = self.Threads[ThreadID]
t.stop()
self.Threads.cl ear[ThreadID]

def count(self):
"""
Returns alist of how many threads are running in the instance
"""
return len(self.Thread s)

def runningkeys(sel f):
"""
Returns a llist of all running Keys
"""
return self.Threads.ke ys

def allOK(self):
"""
Returns a list of all threads that are down if any)
"""
ThreadsDown = []
for t in self.Threads:
if not self.Threads[t].isAlive:
ThreadsDown.app end(t)
return ThreadsDown

David Poundall wrote:

Just sorted (its always the way when you post isn't it)

But the count isn't doint what I expected. I was after a increment
after every time the class was used ireespective of instance.
I have no idea what that last sentence above means...
Instead
I get a count based on the instance usage. Idea's anyone?
Several, interspersed below:
------------------------------------------------------------------------------------
class ServerThreads:
"""
Wrapper for thread handling.
Thread ID 0 = Controller
Thread ID 1 = Plant Object 1
Thread ID 2 = Plant Object 2
"""

GlobalThreadCou nt = 0
Style note: using MixedCaps for variable names doesn't fit conventional
Python style. To be conventional you would use "globalThreadCo unt"
here, or just "threadCoun t" since it's no more "global" than any other
class attribute.
def __init__(self):
global GlobalThreadCou nt
And here you definitely don't want "global" since your GlobalThreadCou nt
above is *not* a Python "global". It's a class attribute, and you
should reference it as such:
self.Threads = {}
GlobalThreadCou nt = 0 Change to:
ServerThreads.G lobalThreadCoun t = 0

and access it as such in all other places inside the class.
def launch(self, SubToLaunch, SubsArgs=(), SubsKwargs={},
AsDeamon=True):
t = Thread(target=S ubToLaunch, args = SubsArgs, kwargs =
SubsKwargs)
t.setDaemon(AsD eamon)
You appear to know there is a difference in spelling between these two
"demons"... but only "daemon" is correct. "Deamon" is a misspelling.
t.start()
self.Threads[len(self.Thread s)] = t # Stash the
thread in an instance local

global GlobalThreadCou nt
GlobalThreadCou nt += 1
print GlobalThreadCou nt
Caution: if you can't guarantee that launch() will be called from only
one thread, you have a race condition here since the count could be
increased "simultaneously " from multiple threads and you won't get
reliable results. You would want to wrap it with a threading.Lock( ) to
protect it in that case.
def globalusagecoun t(self):
"""
Returns a count figure for how many threads are running in
total
usnig this class.
"""
global GlobalThreadCou nt
return GlobalThreadCou nt

Style/usage note: although as I mentioned you don't want to use "global"
variables anyway, even if you did the above line is unnecessary. You
only need to use "global" if you are going to *rebind* the global name
(i.e. assign a new value to it), not if you are merely reading the value
and returning it, as above. What you wrote would work, it's just not
needed or usual. (But, again, using a global at all is wrong anyway.)
-Peter

>> But the count isn't doint what I expected. I was after a increment

after every time the class was used ireespective of instance.

I have no idea what that last sentence above means...
On re-reading it - neither do I. Sorry about that. What I meant to
say was that I was after an increment in the count variable (the class
attribute) not an increment only within the class instances. Because
the variable was being set to zero every time the class was
instantiated I wasn't getting the true usage count.
ServerThreads.G lobalThreadCoun t = 0
That was what the syntax I was missing.
You appear to know there is a difference in spelling between these two
"demons"... but only "daemon" is correct. "Deamon" is a misspelling.
That one certainly slipped under the radar.
You would want to wrap it with a threading.Lock( ) to
protect it in that case.
Will do.
But, again, using a global at all is wrong anyway

I posted using this sytax as it was nearly working - but I knew there
was a serious clanger in the code and you pointed it out when you
identified it was the class attribute syntax I was after.

Peter, thank you for taking the time to unpick my code. It's much
apreciated. I have only been coding with Python for the past couple of
weeks and switching my brain to work with Python classes has been a bit
of a challenge. I wil re-read the document section on style tips
before I get too far into my app, as I would really like to be able to
code in a Pythonesque fashion.

David.

First time I have used thread locking. This seems to work but is it
correct?

from threading import Thread, Event, Lock
..
..
..
def launch(self, ThreadTitle, SubToLaunch, SubsArgs=(),
SubsKwargs={}, AsDaemon=True):
my_lock = Lock()
my_lock.acquire ()
try:
# ---------------------
t = Thread(target=S ubToLaunch, args = SubsArgs, kwargs =
SubsKwargs)
t.setDaemon(AsD aemon)
t.start()
self.Threads[len(self.Thread s)] = t # Stash the
thread in an instance local
# ---------------------
ServerThreads.t hreadcount += 1
finally:
my_lock.release ()
..
..
..

On 27 Oct 2005 16:38:36 -0700, "David Poundall" <da***@jotax.co m>
declaimed the following in comp.lang.pytho n:

First time I have used thread locking. This seems to work but is it
correct?
Not quite, since you may also want to lock it around the print
option too...

Create the lock just like you did the counter (CLASS level), then
reference it using the class name prefix in all places (you should only
need the acquire/release pair in those places, but put them around all
uses of the counter).
-- =============== =============== =============== =============== == <
wl*****@ix.netc om.com | Wulfraed Dennis Lee Bieber KD6MOG <
wu******@dm.net | Bestiaria Support Staff <
=============== =============== =============== =============== == <
Home Page: <http://www.dm.net/~wulfraed/> <
Overflow Page: <http://wlfraed.home.ne tcom.com/> <

Sorry Denis - but could you give me an example. I can't for the life
of me see how the syntax for that would go.

On 28 Oct 2005 00:21:28 -0700, "David Poundall" <da***@jotax.co m>
declaimed the following in comp.lang.pytho n:

Sorry Denis - but could you give me an example. I can't for the life
of me see how the syntax for that would go.
I'm having to recreate your code from snippets posted over the past
few messages...

#
------------------------------------------------------------------------------------
class ServerThreads:
"""
Wrapper for thread handling.
Thread ID 0 = Controller
Thread ID 1 = Plant Object 1
Thread ID 2 = Plant Object 2
"""

GlobalThreadCou nt = 0
CounterLock = threading.Lock( )

def __init__(self):
self.Threads = {}
# GlobalThreadCou nt = 0 ## unneeded here
def launch(self, SubToLaunch, SubsArgs=(), SubsKwargs={},
AsDeamon=True):
t = Thread(target=S ubToLaunch, args = SubsArgs, kwargs =
SubsKwargs)
t.setDaemon(AsD eamon)
t.start()
self.Threads[len(self.Thread s)] = t # Stash the
thread in an instance local

# global GlobalThreadCou nt ## not a global
ServerThreads.C ounterLock.acqu ire()
ServerThreads.G lobalThreadCoun t += 1
print ServerThreads.G lobalThreadCoun t
ServerThreads.C ounterLock.rele ase()

def globalusagecoun t(self):
"""
Returns a count figure for how many threads are running in
total
usnig this class.
"""
# global GlobalThreadCou nt ##not global
ServerThreads.C ounterLock.acqu ire()
tmp = ServerThreads.G lobalThreadCoun t
ServerThreads.C ounterLock.rele ase()
return tmp ##GlobalThreadC ount
def stop(self,Threa dID):
t = self.Threads[ThreadID]
t.stop()
self.Threads.cl ear[ThreadID]

def count(self):
"""
Returns alist of how many threads are running in the instance
"""
return len(self.Thread s)

def runningkeys(sel f):
"""
Returns a llist of all running Keys
"""
return self.Threads.ke ys

def allOK(self):
"""
Returns a list of all threads that are down if any)
"""
ThreadsDown = []
for t in self.Threads:
if not self.Threads[t].isAlive:
ThreadsDown.app end(t)
return ThreadsDown

Hmmmm, I notice you never decrement the counter...
-- =============== =============== =============== =============== == <
wl*****@ix.netc om.com | Wulfraed Dennis Lee Bieber KD6MOG <
wu******@dm.net | Bestiaria Support Staff <
=============== =============== =============== =============== == <
Home Page: <http://www.dm.net/~wulfraed/> <
Overflow Page: <http://wlfraed.home.ne tcom.com/> <

After much optimisation it turns out the following code does the job
for me. In the end using count didn't give me the flexibility I
needed. Instead I now name each thread and track them accordingly.
It's arguable if I need the thread locking now though, however I have
left it in to remind me of the syntax.

Thank you for posting back Dennis. Much appreciated.

# --------------------------------------------------------
class ServerThreads:
"""
Wrapper for thread handling. These threads are not
dynamic, that is to say once the application is fully
loaded the number of threads running is determined
by the size of the application - and is fixed.
"""
# --------------------- Class Attributes
# Dict holds object references to all threads
# created in the server (running or not)
thr_objects = {}
# Dict holds status of all running threads
# 0 = stopped, 1 = running
thr_running = {}
# Lock object
lck = Lock()

def launch(self, ThrName, SubToLaunch,
SubsArgs=(), SubsKwargs={}, AsDaemon=True):

""" Kickoff a thread.
thr_objects : Dictionary using ThreadTitle
as the key which holds
references to the thread object
thr_running : Dictionary holding the status
of each thread
"""
s = ServerThreads
# ---------------------
s.lck.acquire()
try:
t = Thread(name = ThrName, target=SubToLau nch,
args = SubsArgs, kwargs = SubsKwargs)
t.setDaemon(AsD aemon) # Must be set before start
s.thr_objects[ThrName] = t
s.thr_running[ThrName] = 1
if ag.gb_Appdebug: print 'Thread Started ------------- ',
ThrName
t.start()
finally:
s.lck.release()
# ---------------------

def stoprequest(sel f,thr_name):
""" Thread stop request - stop is pending.
Join is not needed because the main code body
drops out of the thread loops once the
thr_running = true condition has been removed."""
s = ServerThreads
# ---------------------
s.lck.acquire()
s.thr_running[thr_name] = 0 # Flag to tell running
thread to please terminate
if ag.gb_Appdebug: print 'Thread Stopping ----------- ' +
thr_name
s.lck.release()
# ---------------------

def allOK(self):
""" Returns a list of all threads that are down
when they shouldn't be (if any) """
s = ServerThreads
ThreadsDown = []
for thr_name in s.thr_objects:
if not s.thr_objects[thr_name].isAlive() and
s.thr_running[thr_name]:
# If a thread has an unscheduled stop indicate this by
returning the
# threads name otherwise return None.
ThreadsDown.app end(thr_name)
return ThreadsDown