Concurrent programming process

Keywords: network Network Protocol p2p

First of all, what do we need to know about the process?

Narrow sense: a process is an ongoing program

Generalized: it is the basic unit of operating system allocation

Program: it is an inanimate entity waiting for the processor to give life. Once the program has life, it becomes a process.

Differences between procedures and processes:

1. Program is an ordered collection of instructions and data. It has no meaning in itself. It is a static resource.

      Process is an execution process of a program in the system.

2. Programs can exist as software for a long time, and processes have a certain life cycle.

Process 3 status:

Ready status: the running conditions have been met and are waiting for CPU execution
 Execution status: the CPU is executing the function of the actuator
 Waiting status: wait for certain conditions to be met

With a preliminary understanding of the process, how to create a process?

import time
# Guide Package
import multiprocessing
def test1():
    while True:
        print("Big fool")
def test2():
    while True:
        print("Little fat hand")
# Define a main function to execute the code of two processes respectively
def main():
    # Create test1 and test2 processes respectively, and the value of target represents the process to be executed
    p1 = multiprocessing.Process(target=test1)
    p2 = multiprocessing.Process(target=test2)
    # Start p1 and p2
# General writing method of program entry:
if __name__ == "__main__":

  Here, we introduce a concept of parallelism and concurrency

Let's take an example, for example, the two of us are having lunch. In the whole process of eating, you ate rice, vegetables and beef. Eating rice, vegetables and beef are actually executed concurrently. For you, the whole process seems to be completed at the same time. But you actually switch back and forth between eating different things.

Or the two of us for lunch. During the meal, you ate rice, vegetables and beef. I also had rice, vegetables and beef. The meal between us is parallel. Two people can eat beef together at the same time, or one can eat beef and the other can eat vegetables. There is no interaction between them.

See here, is it still a little confused? Let's look at another picture and intuitively feel the difference between the two

  As can be seen from the above,

         Parallel: multiple tasks are executed simultaneously at the same time  

         Concurrency: multiple tasks are executed at the same time  

The difference between parallelism and Concurrency:

         Microcosmic: parallelism means that multiple tasks are executed at the same time

         Macroscopically: concurrency refers to the stop and go of multiple tasks in a period of time

There are processes, of course, there are sub processes. Let's implement it in code!

# Guide Package
# import time
# from multiprocessing import Process
# Create function -- child process
def work1():
    while True:
        print("I'm a child, hee hee")
# Program entry
if __name__ == "__main__":
    # Create child process object
    p1 = Process(target=work1)
    # start-up
    while True:
        print("I am the main process, hahaha")
Learn more about process
 Parameter Description:
target: if a function reference is passed, it can be considered to execute the code of the child process
 args: pass parameters to the function specified by target. The parameters are passed in tuples. If there is only one value in the tuple, you need to add a comma
 kwargs: pass parameters to the function specified by target in the form of dictionary
 Name: name the process
 Group: Specifies the process group
import time
from multiprocessing import Process
# Create function -- child process
def work1(*args,**kwargs):
    while True:
# Program entry
if __name__ == "__main__":
    # Create child process object
    p1 = Process(target=work1,args=("Big wood",19),kwargs={"Gender":"male"})
    # start-up
    while True:
        print("Big wood second goods, ha ha ha")
Note: 1. When you right-click run, a process will be created, which is called the main process
      2. work1 created in the program is a child process
      3. You need to use the target parameter and the start() method when creating and starting a process
      4. Judge whether args and kwargs parameters need to be passed in process according to the meaning of the question
 Note: program entry must be written
Common methods for creating Process instance objects:
Start: start the child process
 Terminate: terminate the child process immediately regardless of whether it is considered complete or not
 join ([timeout]): whether to wait for the child process to finish before executing the main process, or how many seconds to wait
 is_alive: determine whether the child process is still alive

Common properties for creating Process instance objects:
Name: process name
 pid: ID of the process -- pid

multiprocessing is a module

Now that we have a basic understanding of processes, how do processes communicate?

# Data isolation between processes
# Define a list of global variables
lst = [11,22]
# Guide Package
import multiprocessing
import time
# The first process adds data to the list
def work1():
    for i in range(3):
# The second process makes no changes to the list
def work2():
# Program entry
if __name__ == '__main__':
    p1 = multiprocessing.Process(target=work1)
# join ([timeout]): whether to wait for the child process to finish before executing the main process, or how many seconds to wait
    # Let p1 execute the process and then execute p2
    p2 = multiprocessing.Process(target=work2)

# Output result: [11, 22, 0]
        # [11, 22, 0, 1]
       # [11, 22, 0, 1, 2] results after process 1 operation
        # [11, 22] results after process 2 operation
# Summary: data between processes is isolated, and global variables cannot be shared between processes
Queue: a data structure
 Features: first in first out
 When full data is stored again, blocking will occur
 When all the data has been fetched, there will be blocking when you continue to fetch data
import multiprocessing
ret = multiprocessing.Queue(3) #The queue has 3 values
#Save data put
ret.put({"Xiao Ming":"white and fat"})
# Check whether it is full
# print(ret.full())
# Check whether it is empty
# print(ret.empty())
# get data
print(ret.get())  #11
print(ret.get())  #22
print(ret.get())  #[11,22]
# print(ret.get())  #block
# get_nowait tells us that the data has been retrieved in an abnormal way

Next, let's take a look at the process pool!

Process pool: when you need to create multiple processes, such as thousands of processes, it takes a lot of time to manually create them using process

Synchronous and asynchronous: there are two ways to submit tasks

Synchronization: wait in place after submitting the task, and do not proceed to the next line of code until the return value of the task is obtained

Asynchronous: after submitting the code, do not wait in place and proceed directly to the next time

Blocking and non blocking:

Blocking: once a program is blocked, it will stop in place and immediately release CPU resources

Non blocking: even if I/O is blocked, it will not stop in place

# Define a pool. There are a fixed number of processes in the pool. There is a demand,
# Add a task to the process pool. If the task is full, you need to wait
import multiprocessing
import os
import time
# Create process
def func(data):
    print("process%s--Print incoming parameters%s" %(os.getpid(),data))
# Program entry:
if __name__ == '__main__':
    # The create process pool parameter represents the maximum number of processes
    po = multiprocessing.Pool(3)
    for i in range(10):
        # po.apply(func,args=(i,))
    print("I am the main process")
Apply and apply_ Differences between async submission methods:
apply: synchronous commit is executed sequentially
 apply_async: asynchronous submission tasks are asynchronous

Today, we learned about processes, sub processes, inter process communication and process pool. In the next section, we continue to learn threads. Bye!


Posted by lowspeed on Fri, 03 Dec 2021 18:42:24 -0800