By means of threading module definition and the calling thread in Python

Due to the presence of the famous GIL, Python, although able to create multiple threads, but can not be executed at the same time ... anyway, here we come to learn about the method by threading module definition and the calling thread in Python
custom thread

The easiest way: using an objective function specified thread to execute target, then use start () start.

grammar:

class threading.Thread(group=None, target=None, name=None, args=(), kwargs={})

Constant group to None, reserved for future use. target is the name of the function to be performed. name for the thread name, the default is Thread-N, usually the default. However, the server thread function is not the same, the proposed name.

#!/usr/bin/env python3
# coding=utf-8
import threading
 
def function(i):
  print ("function called by thread {0}".format(i))
threads = []
 
for i in range(5):
  t = threading.Thread(target=function , args=(i,))
  threads.append(t)
  t.start()
  t.join()

Results of the

$ ./threading_define.py 

function called by thread 0
function called by thread 1
function called by thread 2
function called by thread 3
function called by thread 4

Determine the current thread

#!/usr/bin/env python3
# coding=utf-8
 
import threading
import time
 
def first_function():
  print (threading.currentThread().getName()+ str(' is Starting \n'))
  time.sleep(3)
  print (threading.currentThread().getName()+ str( ' is Exiting \n'))
   
def second_function():
  print (threading.currentThread().getName()+ str(' is Starting \n'))
  time.sleep(2)
  print (threading.currentThread().getName()+ str( ' is Exiting \n'))
   
def third_function():
  print (threading.currentThread().getName()+\
  str(' is Starting \n'))
  time.sleep(1)
  print (threading.currentThread().getName()+ str( ' is Exiting \n'))
   
if __name__ == "__main__":
  t1 = threading.Thread(name='first_function', target=first_function)
  t2 = threading.Thread(name='second_function', target=second_function)
  t3 = threading.Thread(name='third_function',target=third_function)
  t1.start()
  t2.start()
  t3.start()

Results of the:

$ ./threading_name.py 

first_function is Starting 
second_function is Starting 
third_function is Starting 
third_function is Exiting 
second_function is Exiting 
first_function is Exiting

With the logging module with:

#!/usr/bin/env python3
# coding=utf-8
 
import logging
import threading
import time
 
logging.basicConfig(
  level=logging.DEBUG,
  format='[%(levelname)s] (%(threadName)-10s) %(message)s',
  )
   
def worker():
  logging.debug('Starting')
  time.sleep(2)
  logging.debug('Exiting')
   
def my_service():
  logging.debug('Starting')
  time.sleep(3)
  logging.debug('Exiting')
   
t = threading.Thread(name='my_service', target=my_service)
w = threading.Thread(name='worker', target=worker)
w2 = threading.Thread(target=worker) # use default name
w.start()
w2.start()
t.start()

Results of the:

$ ./threading_names_log.py[DEBUG] (worker  ) Starting

[DEBUG] (Thread-1 ) Starting
[DEBUG] (my_service) Starting
[DEBUG] (worker  ) Exiting
[DEBUG] (Thread-1 ) Exiting
[DEBUG] (my_service) Exiting

Using threads in a subclass

In front of our threads are in the form of structured programming to create. You can also create a thread through integrated threading.Thread class. Thread class First essentially complete some initialization, and then call its run (). run () method calls will be passed to the constructor of the objective function.

#!/usr/bin/env python3
# coding=utf-8
 
import logging
import threading
import time
 
exitFlag = 0
 
class myThread (threading.Thread):
  def __init__(self, threadID, name, counter):
    threading.Thread.__init__(self)
    self.threadID = threadID
    self.name = name
    self.counter = counter
     
  def run(self):
    print ("Starting " + self.name)
    print_time(self.name, self.counter, 5)
    print ("Exiting " + self.name)
     
def print_time(threadName, delay, counter):
  while counter:
    if exitFlag:
      thread.exit()
    time.sleep(delay)
    print ("%s: %s" %(threadName, time.ctime(time.time())))
    counter -= 1
     
# Create new threads
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)
# Start new Threads
thread1.start()
thread2.start()
print ("Exiting Main Thread")

Results of the:

$ ./threading_subclass.py 

Starting Thread-1
Starting Thread-2
Exiting Main Thread
Thread-1: Tue Sep 15 11:03:21 2015
Thread-2: Tue Sep 15 11:03:22 2015
Thread-1: Tue Sep 15 11:03:22 2015
Thread-1: Tue Sep 15 11:03:23 2015
Thread-2: Tue Sep 15 11:03:24 2015
Thread-1: Tue Sep 15 11:03:24 2015
Thread-1: Tue Sep 15 11:03:25 2015
Exiting Thread-1
Thread-2: Tue Sep 15 11:03:26 2015
Thread-2: Tue Sep 15 11:03:28 2015
Thread-2: Tue Sep 15 11:03:30 2015
Exiting Thread-2

We recommend learning Python buckle qun: 774711191, look at how seniors are learning! From basic web development python script to, reptiles, django, data mining, etc. [PDF, actual source code], zero-based projects to combat data are finishing. Given to every little python partner! Every day, Daniel explain the timing Python technology, to share some of the ways to learn and need to pay attention to small details, click on Join us python learner gathering