Что такое системный вызов Fork () и как вилить с помощью Python

Перед вступлением в вилку, давайте понять, что такое процесс. А процесс В компьютерном сроке – это программа, выполняемая в настоящее время компьютер. Каждый процесс уникален и может быть идентифицирован своим ID PID или процессы.

Примечание. Все примеры и демонстрационные коды, показанные ниже, были опробованы на Ubuntu 20.04 LTS и Python V3.8.5.

Посетите мою страницу GitHub для всех фрагментов демо-кода https://github.com/jaqsparow/fork-demos

Что мы узнаем в этом посте?

Что такое вилка 💡
Как назвать вилкой в Python 📗
Как получить идентификатор процесса или PID в Python 📙
Как определить родительский и детский процесс 📕
Примеры с фрагментами кода 💻

Введение: Что такое вызов системы Fork?

Вилка – одна из самых важных концепций в операционной системе Unix и Linux. В коротким примечании вилка – это не что иное, как клонирование процесса. Это означает, что вилка создаст новый процесс с точной копией процесса вызова. Поэтому, когда программа сталкивается с системным вызовом вилкой (), он создаст еще один процесс с той же копией памяти. Итак, вот приходит концепция родительского и дочернего процесса.

Основной или первый процесс, который называет вилкой и создает новый процесс, называется родительский процесс Отказ Новый процесс, созданный FORK, известен как Детский процесс Отказ

Как определить родительский и детский процесс?

Поскольку оба обрабатываются, чтобы ребенок и родитель имеют одинаковую копию памяти, то наступает вопрос, как мы можем определить, кто из них является родителем, и какой ребенок является ребенком. Как я уже упоминал выше, каждый процесс имеет уникальный идентификатор, известный как идентификатор процесса или PID, который можно использовать для дифференцирования среди процессов.

Чтобы определить родительский и дочерний процесс, нам нужно проверить код возврата Volk System Call.

Обратный код вилки ()

Обратный код вилкой системы вызова определяет родитель или детский процесс. Когда родительские процессы вызовы вил, вилка возвращается ** PID детского процесса только что создано ** к родительскому процессу и ** 0 ** к дочернему процессу. Таким образом, если код возврата из вызова вилков равен нулю, то его дочерний процесс и если его положительное значение, то он должен быть родительским процессом.

Ноль Если код возврата 0, то он должен быть дочерним процессом
Положительное значение , Если код возврата является положительным значением (или детский PID), то его родительский процесс
* Отрицательный * , Если код возврата отрицательный, то создание дочернего процесса не удалось и неудачно

Как вилочную вилку с помощью Python?

Питона ОС Модуль предоставляет функцию вилка () создать детский процесс. Чтобы узнать PID любого процесса, используйте функцию getpid () от ОС модуль

import os
os.fork()

Теперь давайте сделаем некоторые демоны, чтобы понять, что происходит

Демо 1: чтобы проверить идентификатор процесса любого процесса

В нижеприведении мы просто проверяем, как GetPid () можно использовать для получения PID текущего процесса.

import os

def demo1():
    print('I am the only process, My PID:',os.getpid())
demo1()

Вот выход:

DEMO 2: создать один ребенок, используя вилку ()

В приведении ниже примера мы являемся идентификатором процесса печати до и после вызова вилки (). Это означает перед вилкой, у нас есть один процесс, а после звонка мы получили еще один новый процесс со всего 2 процессов.

Давайте проверим вывод ниже фрагментов

import os

def demo2():
    print('Before calling fork(),PID: ', os.getpid())
    os.fork()
    print('After calling fork(), PID: ', os.getpid())

demo2()

Вот выходит: –

shaikh@ubuntu:~/Jupyter/fork demos$ python3 demo2.py
Before calling fork(),PID:  6837
After calling fork(), PID:  6837
After calling fork(), PID:  6838
shaikh@ubuntu:~/Jupyter/fork demos$

Как показано выше, перед Fork () у нас был только один процесс с PID 6837, а после формы у нас новый процесс с PID 6838.

Демо 3: идентифицировать родителей и ребенка

Давайте посмотрим, как мы можем определить родителя и ребенка программно. Как уже упоминалось в последнем разделе, что если код возврата из вилки равен нулю, то его дочерний процесс и если его положительное значение, то его родительский процесс. Давайте проверим то же самое здесь

import os

def demo3():
    print('Before calling fork(),PID: ', os.getpid())
    rc = os.fork()
    if rc == 0:
        print('I am child, PID: ', os.getpid())
        os._exit(0)
    elif rc > 0:
        print('I am parent,PID:',os.getpid())
    else:
        print('Child process creation failed!!')

demo3()

Выход

shaikh@ubuntu:~/Jupyter/fork demos$ python3 demo3.py
Before calling fork(),PID:  7316
I am parent,PID: 7316
I am child, PID:  7317

Давайте понять, что произошло выше. Перед вилкой у нас был только один процесс с PID 7316 и в тот момент, когда он называл вилкой (), мы получили другой процесс. Каждый из этих процессов имеет разную копию обратного кода RC Отказ Родитель имеет RC с положительным значением (PID детского процесса), и ребенок имеет RC равняться нуль

Демо 4: давайте создадим два дочерних процесса

Ниже приведен пример, мы называем вилкой () дважды.

import os

def demo4():
    #No fork, only one process
    print('Before any fork,  PID:',os.getpid())
    #First fork
    os.fork()
    print('After first fork, PID:',os.getpid())
    #Second fork
    os.fork()
    print('After second fork,PID:',os.getpid())

demo4()

Здесь выходит выход:

shaikh@ubuntu:~/Jupyter/fork demos$ python3 demo4.py
Before any fork,  PID: 7471
After first fork, PID: 7471
After first fork, PID: 7472
After second fork,PID: 7471
After second fork,PID: 7473
After second fork,PID: 7472
After second fork,PID: 7474

Перед первым вилкой был только один процесс
После первой вилки общие процессы два
После второго вызова общие процессы четыре

Если мы позвоним FORK 3 раза, угадайте количество процессов, которые будут созданы в разделе комментариев 🙂

Демо 5: давайте сделаем это для удовольствия

Ниже приведен пример покажет, что после формования позвоните как родитель, и ребенок будет иметь разные копии переменной оставлять

import os

def demo5():
    num = 0
    rc = os.fork()
    if rc > 0:
        num = os.getpid()
    print ('num: ',num)    
demo5()

И угадать вывод 🙂

shaikh@ubuntu:~/Jupyter/fork demos$ python3 demo5.py
num:  7825
num:  0

Так что в вышеуказанном коде только родительский процесс может зайти внутрь Если Заявление, потому что он имеет положительный код ответа, который является PID дочернего процесса. С RC Для ребенка – НУЛЬ у него все еще будет оригинальная копия Num

Заключение

Надеюсь, это было весело и интересно обучение 🙂. Вилка – это очень распространенный способ создания дочернего процесса в любой операционной системе Linux. Он используется для создания нескольких процессов и наиболее распространенным корпусом использования – это веб-сервер, который вил новый процесс на каждом HTTP-запросе.

Будьте осторожны, когда вы используете вилку и убедитесь, что вы успешно вывезли процесс после завершения задачи, останутся высокое использование памяти и процессора и может создать ситуацию с утечкой памяти, которая называется «+». вилочная бомба

Все демонстрационные демонстрации находятся на моей странице GitHub. Нажмите здесь, чтобы посетить