Shulou(Shulou.com)05/31 Report--

This article mainly introduces "what is the creation and common methods of Python threads". In daily operation, I believe many people have doubts about the creation and common methods of Python threads. The editor consulted all kinds of materials and sorted out simple and easy-to-use operation methods. I hope it will be helpful to answer the doubts about "what are the creation and common methods of Python threads?" Next, please follow the editor to study!

Creation and use of threads

There are many multithreaded modules in Python, among which the threading module is more commonly used. Let's take a look at how to create a thread using threading and its common methods.

Thread creation-threading function name introduction example Thread creation thread Thread (target, args)

Introduction to Thread's kinetic energy: instantiate a thread object by calling the Thread class of the threading module; it has two parameters: target and args (the same parameters as when the process was created). Target is the function to be executed when the thread is created, and args is the parameter to be passed in to execute this function.

Common methods of thread object

Next, let's take a look at the common methods in threading objects:

Function name introduction start starts thread start () join blocks thread until thread execution ends join (timeout=None) getName gets thread name getName () setName sets thread name setName (name) is_alive determines whether thread survives is_alive () setDaemon daemon thread setDaemon (True)

The start function: starts a thread; there are no return values or parameters.

Join function: same as the join function in the process; block the current program, and the task of the main thread needs to wait for the task of the current child thread to finish before it can continue execution; the parameter is timeout: represents the blocking timeout.

GetName function: gets the name of the current thread.

SetName function: sets the name of the current thread; the parameter is name: is a string type

Is_alive function: determines whether the status of the current thread is in stock

SetDaemon function: it is a daemon thread; if the script task is completed, the business will be forcibly terminated even if the process pool has not yet been executed. The same is true of child threads. If you want the main process or the main thread to allow the child threads to continue to work instead of forcibly closing them after the main process or the main thread has finished executing its own business, just set setDaemon () to True.

PS: from the above introduction, you will find that the functions in the thread object are almost very similar to those in the process object, and their usage and usage scenarios are almost the same.

Thread demo case single-threaded initial case

Take a look at the following case before demonstrating multithreading, and see how long it takes to run it.

1. Define a list with some content in it.

2. Define a new list, write the contents of the previous list to the new list randomly, and delete the content randomly obtained from the previous list.

3. The r andom built-in module needs to be used here.

The code example is as follows:

# coding:utf-8import timeimport randomold_lists = ['Roman Holiday', 'heartbeat', 'Love Traveler in time and Space', 'Angel loves Beauty', 'City of Angels', 'hapless Cupid','La La City'] new_lists = [] def work (): if len (old_lists) = = 0: # judge the length of old_list, if it is 0 Then the contents of the list have been deleted return'\ 'old_list\' the contents of the list have all been deleted 'old_choice_data = random.choice (old_lists) # the choice function of the random module can randomly get the element old_lists.remove (old_choice_data) # of the incoming old_list when the random element is obtained Delete the element from the old_lists new_choice_data ='% slots new'% old_choice_data # to re-assign the randomly acquired random element in a formatted manner Different from the previous element new_lists.append (new_choice_data) # add a new formatted random element to the new_lists list time.sleep (1) if _ _ name__ ='_ main__': strat_time = time.time () for i in range (len (old_lists)): work () if len (old_lists) = = 0: Print ('\ 'old_lists\' is currently: {} '.format (None)) else: print (('\ 'old_lists\' is currently: {} '.format (old_lists) if not len (new_lists) = = 0: print (('\ 'new_lists\' is currently: {} '.format (new_lists)) else: print ('\' New_lists\'is currently: {} '.format (None) end_time = time.time () print (' end of run Cumulative time: {} seconds' .format (end_time-strat_time))

The running results are as follows:

From the run output, we can see that the whole script takes a total of 7 seconds to run, and all the elements in the new_lists list are formatted and added with _ new. Not only that, because of the choice function of the random module, the content order of new_lists is also different from that of old_lists. Each run order will be different, so the order of old_lists cannot be guaranteed.

Multithreaded demo case

The code example is as follows:

# coding:utf-8import timeimport randomimport threadingold_lists = ['Roman Holiday', 'heartbeat', 'Love Traveler in time and Space', 'Angel loves Beauty', 'City of Angels', 'hapless Cupid','La La City'] new_lists = [] def work (): if len (old_lists) = = 0: # judge the length of old_list, if it is 0 Then the contents of the list have been deleted return'\ 'old_list\' the contents of the list have all been deleted 'old_choice_data = random.choice (old_lists) # the choice function of the random module can randomly get the element old_lists.remove (old_choice_data) # of the incoming old_list when the random element is obtained Delete the element from the old_lists new_choice_data ='% slots new'% old_choice_data # to re-assign the randomly acquired random element in a formatted manner Different from the previous element new_lists.append (new_choice_data) # add a new formatted random element to the new_lists list time.sleep (1) if _ _ name__ ='_ main__': strat_time = time.time () print ('\ 'old_lists\' initial length is: {} '.format (len (old_lists) # Get the initial length of old_lists and new_lists print ('\ 'new_lists\' initial length is: {} '.format (len (new_lists) thread_list = [] # define an empty thread_list object Add each thread for i in range (len (old_lists)) with thread_work = threading.Thread (target=work) # define a thread instantiation object to execute the work function Because the work function has no arguments, you do not need to pass args thread_list.append (thread_work) # add thread_work to thread_list thread_work.start () # start each thread for t in thread_list: # block each thread through the for loop t.join () If len (old_lists) = 0: print ('\ 'old_lists\' is currently: {} '.format (None) 'current length is: {}' .format (len (old_lists)) else: print (('\ 'old_lists\' is currently: {} '.format (old_lists)) if not len (new_lists) = = 0: print ('\ 'new_lists\' current length is: {} '.format (len (new_lists) print ('\ 'new_lists\' The current value is: {} '.format (new_lists) else: print ('\ 'new_lists\' is currently: {} '.format (None)) end_time = time.time () print (' end of run Cumulative time: {} seconds' .format (end_time-strat_time))

The running results are as follows:

From the running results, our initial single-threaded task takes 7 seconds, and after using multithreading, it takes only 1 second to complete, which greatly improves our running efficiency.

Problems with threads

Through the above exercise, we found that threads are used in almost the same way as processes. All of them can execute the program without interfering with each other, or the program of the main thread does not have to wait for the task of the child thread to be completed. It's just that in the demonstration just now, we used the join () function to block, so here we can remove join () and see how it works.

Like processes, threads have some problems.

The function executed by the thread also cannot get the return value.

When multiple threads modify the file at the same time, it will also cause the data confusion of the modified file (because they all operate on a file concurrently, especially when dealing with transaction scenarios).

At this point, the study on "what is the creation and common methods of Python threads" is over. I hope to be able to solve your doubts. The collocation of theory and practice can better help you learn, go and try it! If you want to continue to learn more related knowledge, please continue to follow the website, the editor will continue to work hard to bring you more practical articles!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.