Problem solving scenarios:Suppose there are 1000 movie tickets left to be sold and there are 10 movie apps to sell these 1000 movie tickets at the same time. What is the main logical implementation process that requires a python technology stack for solving the problem?
1. Analyzing the process
Analysis:The main information point is that 10 App platforms are selling 1000 movie tickets at the same time. At this point, you can use 10 python threads as 10 App platforms, selling at the same time must ensure that the number of movie tickets are synchronized, for example, platform A sold a ticket that the total number of tickets remaining is 999, platform B if you want to sell another ticket should be 999-1 = 998 tickets.
Technology Stack Analysis:The python multithreading module provides the threading module, and the threading module provides the synchronization lock Lock to control the effect of making the number of votes reach unity.
2. Preparation process
Import the relevant standard libraries into the code block without having to install additional non-standard libraries.
import threading # Multi-threading related operations import os # Application exit operations import time # Control of time blocking in threads
Initialize some global parameters for use later in the calling process.
tickets = 1000 # Initialize the total number of movie tickets to 1000 lock_ = () # Getting a Synchronized Lock Object，For implementing lock control in multi-threaded logic
3. Realization process
Write a function sell_tickets as a ticketed function to implement the procedure.
def sell_tickets(app_name='App platform that undertakes the task of selling movie tickets'):
global tickets # Make those movie tickets a global variable #
global lock_ # Use the acquired lock object as a global variable
# Use a dead loop to simulate that the current ticketing platform is always ticketing
while True:
lock_.acquire() # Each ticketing platform locks up after accessing tickets
if tickets > 0: # Determine if the number of movie tickets is sold out before starting to sell them.
tickets = tickets - 1
print('Current Ticketing Platform：{}，Sell a movie ticket，Remaining Movie Tickets：{}sheet of paper！'.format(app_name, tickets))
(0.1)
else:
print('The movie tickets are all sold out!')
os._exit(0)
lock_.release() # Release the lock after the ticket transaction is completed
(0.2)
At this point, the business logic of movie ticket sales is finished. The following multi-threaded realization of multiple movie ticket sales platforms at the same time on the ticket is OK.
app_thread_1 = (target=sell_tickets, args=('Ticketing App Platform 01',))
app_thread_1.start()
app_thread_2 = (target=sell_tickets, args=('Ticketing App Platform 02',))
app_thread_2.start()
app_thread_3 = (target=sell_tickets, args=('Ticketing App Platform 03',))
app_thread_3.start()
app_thread_4 = (target=sell_tickets, args=('Ticketing App Platform 04',))
app_thread_4.start()
app_thread_5 = (target=sell_tickets, args=('Ticketing App Platform 05',))
app_thread_5.start()
app_thread_6 = (target=sell_tickets, args=('Ticketing App Platform 06',))
app_thread_6.start()
app_thread_7 = (target=sell_tickets, args=('Ticketing App Platform 07',))
app_thread_7.start()
app_thread_8 = (target=sell_tickets, args=('Ticketing App Platform 08',))
app_thread_8.start()
app_thread_9 = (target=sell_tickets, args=('Ticketing App Platform 09',))
app_thread_9.start()
app_thread_10 = (target=sell_tickets, args=('Ticketing App Platform 10',))
app_thread_10.start()to this article on the python multi-threaded synchronous ticketing system is introduced to this article, more related python ticketing system content, please search for my previous posts or continue to browse the following related articles I hope you will support me in the future!