How can python threads be programmed such that the user can distinguish between them using monitoring tools available in LINUX

Question

For example, I can name threads easily for reference within the python program:

#!/usr/bin/python
import time
import threading

class threadly(threading.Thread):
    def __init__(self, name):
        threading.Thread.__init__(self)
        self.name = name
    def run(self):

        while True:
            time.sleep(4)
            print "I am", self.name, "and I am barely awake."

slowthread=threadly("slowthread")
slowthread.start()

anotherthread=threadly("anotherthread")
anotherthread.start()

while True:

    time.sleep(2)

    print "I will never stop running"
    print "Threading enumerate:", threading.enumerate()
    print "Threading active_count:", threading.active_count()
    print

And the output looks like this:

I am slowthread and I am barely awake.
I am anotherthread and I am barely awake.
I will never stop running
Threading enumerate: [<_MainThread(MainThread, started 140121216169728)>, <threadly(slowthread, started 140121107244800)>, <threadly(anotherthread, started 140121026328320)>]
Threading active_count: 3

I will never stop running
Threading enumerate: [<_MainThread(MainThread, started 140121216169728)>, <threadly(slowthread, started 140121107244800)>, <threadly(anotherthread, started 140121026328320)>]
Threading active_count: 3

I can find the PID this way:

$ ps aux | grep test
    557      12519  0.0  0.0 141852  3732 pts/1    S+   03:59   0:01 vim test.py
    557      13974  0.0  0.0 275356  6240 pts/2    Sl+  05:36   0:00 /usr/bin/python ./test.py
    root     13987  0.0  0.0 103248   852 pts/3    S+   05:39   0:00 grep test

I can then invoke top:

# top -p 13974

Pressing 'H' turns on display of threads, and we see they are all displaying as the name of the command or of the main thread:

top - 05:37:08 up 5 days,  4:03,  4 users,  load average: 0.02, 0.03, 0.00
Tasks:   3 total,   0 running,   3 sleeping,   0 stopped,   0 zombie
Cpu(s):  1.8%us,  2.7%sy,  0.0%ni, 95.3%id,  0.0%wa,  0.0%hi,  0.2%si,  0.0%st
Mem:  32812280k total, 27717980k used,  5094300k free,   212884k buffers
Swap: 16474104k total,     4784k used, 16469320k free, 26008752k cached

  PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND
13974 justin.h  20   0  268m 6240 1740 S  0.3  0.0   0:00.03 test.py
13975 justin.h  20   0  268m 6240 1740 S  0.0  0.0   0:00.00 test.py
13976 justin.h  20   0  268m 6240 1740 S  0.0  0.0   0:00.00 test.py

Contrast this with software like rsyslog which does name its threads:

# ps aux | grep rsyslog
root      2763  0.0  0.0 255428  1672 ?        Sl   Mar22   6:53 /sbin/rsyslogd -i /var/run/syslogd.pid -c 5
root      2774 47.7  0.0 265424  6276 ?        Sl   Mar22 3554:26 /sbin/rsyslogd -i /var/run/syslogd-01.pid -c5 -f /etc/rsyslog-01.conf
root      2785  2.7  0.0 263408  3596 ?        Sl   Mar22 207:46 /sbin/rsyslogd -i /var/run/syslogd-02.pid -c5 -f /etc/rsyslog-02.conf
root      2797  1.7  0.0 263404  3528 ?        Sl   Mar22 131:39 /sbin/rsyslogd -i /var/run/syslogd-03.pid -c5 -f /etc/rsyslog-03.conf
root      2808 24.3  0.0 265560  3352 ?        Sl   Mar22 1812:25 /sbin/rsyslogd -i /var/run/syslogd-04.pid -c5 -f /etc/rsyslog-04.conf
root      2819  1.3  0.0 263408  1596 ?        Sl   Mar22 103:42 /sbin/rsyslogd -i /var/run/syslogd-05.pid -c5 -f /etc/rsyslog-05.conf
root      2830  0.0  0.0 263404  1408 ?        Sl   Mar22   0:17 /sbin/rsyslogd -i /var/run/syslogd-06.pid -c5 -f /etc/rsyslog-06.conf
root     13994  0.0  0.0 103248   852 pts/3    S+   05:40   0:00 grep rsyslog

Let's pick '2774' because it looks busy:

$ top -p 2774

And press 'H' and we see a descriptively named thread showing me that the thread dedicated to the 'main' ruleset and the Reg Queue is consuming 55.6 % CPU.

top - 05:50:52 up 5 days,  4:17,  4 users,  load average: 0.00, 0.00, 0.00
Tasks:   4 total,   1 running,   3 sleeping,   0 stopped,   0 zombie
Cpu(s):  1.7%us,  2.6%sy,  0.0%ni, 95.5%id,  0.0%wa,  0.0%hi,  0.2%si,  0.0%st
Mem:  32812280k total, 29833152k used,  2979128k free,   214836k buffers
Swap: 16474104k total,     4784k used, 16469320k free, 28123448k cached

  PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND
 2775 root      20   0  259m 6020 1212 R 55.6  0.0   3152:40 rs:main Q:Reg
 2776 root      20   0  259m 6020 1212 S  7.0  0.0 407:57.94 rsyslogd
 2774 root      20   0  259m 6020 1212 S  0.0  0.0   0:00.00 rsyslogd
 2777 root      20   0  259m 6020 1212 S  0.0  0.0   0:00.00 rsyslogd

Another way to see the names is:

$ grep Name /proc/2775/task/*/status
/proc/2775/task/2774/status:Name:       rsyslogd
/proc/2775/task/2775/status:Name:       rs:main Q:Reg
/proc/2775/task/2776/status:Name:       rsyslogd
/proc/2775/task/2777/status:Name:       rsyslogd

So to restate my question:

How can python threads be programmed such that the user can distinguish between them using monitoring tools available in LINUX

In my question, I've tried to accomplish this by naming the thread within Python. Perhaps there a better way to expose differently identifiable threads from the OS?

Also, preferably I am looking for a Pythonic and standard way of doing this such that it would be part of the standard python distribution (RHEL 6/Python 2.6.7 specifically but this shouldn't matter unless the support comes in a later version of python) . Contributed modules are good to know about, but for my intended application unfortunately they would not be allowed for supportability reasons due to policies.

Answer 1

http://code.google.com/p/procname/

This appears to be your solution..

class worker(Thread):
    def __init__(self, name)
        Thread.__init__(self)
        self.name = name
        self.alive = True
        self.start()
    def run(self):
        procname.setprocname('My super name')
        while self.alive is True:
            ## Do work

x = worker('Worker')