Python'da arka plan işlemi nasıl başlatılır?

Çok daha okunabilir python sürümüne bir kabuk komut dosyası için çalışıyorum. Orijinal kabuk betiği arka planda "&" ile birkaç işlem (yardımcı programlar, monitörler vb.) Başlatır. Python'da aynı etkiyi nasıl elde edebilirim? Python komut dosyaları tamamlandığında bu işlemlerin ölmemesini istiyorum. Bir şekilde bir daemon kavramıyla ilgili olduğundan eminim, ancak bunu nasıl kolayca yapabileceğimi bulamadım.

Not : Bu yanıt 2009'da yayınlandığından daha az günceldir subprocess. Diğer yanıtlarda gösterilen modülü kullanmanız artık dokümanlarda önerilmektedir .

(Alt işlem modülünün yeni süreçleri oluşturmak ve sonuçlarını almak için daha güçlü özellikler sunduğunu unutmayın; bu modülü kullanmak bu işlevleri kullanmak için tercih edilir.)

İşleminizin arka planda başlamasını istiyorsanız, system()kabuk komut dosyanızla aynı şekilde kullanabilir ve çağırabilirsiniz veya şunları yapabilirsiniz spawn:

import os
os.spawnl(os.P_DETACH, 'some_long_running_command')

(veya alternatif olarak, daha az taşınabilir os.P_NOWAITbayrağı deneyebilirsiniz ).

Buradaki belgelere bakın .

Jkp'nin çözümü çalışırken , işleri yapmanın daha yeni yolu (ve belgelerin önerdiği yol) subprocessmodülü kullanmaktır . Basit komutlar için eşdeğerdir, ancak karmaşık bir şey yapmak istiyorsanız daha fazla seçenek sunar.

Davanız için örnek:

import subprocess
subprocess.Popen(["rm","-r","some.file"])

Bu rm -r some.filearka planda çalışacaktır . .communicate()Döndürülen nesneyi çağırmanın Popentamamlanıncaya kadar engelleneceğini unutmayın, bu nedenle arka planda çalışmasını istiyorsanız bunu yapmayın:

import subprocess
ls_output=subprocess.Popen(["sleep", "30"])
ls_output.communicate()  # Will block for 30 seconds

Buradaki belgelere bakın .

Ayrıca, bir açıklama noktası: Burada kullandığınız gibi "Arkaplan" tamamen bir kabuk konseptidir; teknik olarak, demek istediğin, bir işlemi tamamlamasını beklerken engellemeden yumurtlamak istiyorsun. Ancak, burada kabuk arka planı benzeri davranışı ifade etmek için "arka plan" kullandım.

Muhtemelen "Python'da harici bir komut nasıl çağrılır" cevabını istiyorsunuz .

En basit yaklaşım os.systemişlevi kullanmaktır , örneğin:

import os
os.system("some_command &")

Temel olarak, systemişleve ilettiğiniz her şey, bir komut dosyasında kabuğa geçirmiş olduğunuz gibi yürütülür.

Bunu burada buldum :

Pencerelerde (win xp), ana işlem tamamlanıncaya kadar longtask.pytamamlanmaz. CGI komut dosyasında istediğiniz gibi değil. Sorun Python'a özgü değildir, PHP topluluğunda problemler aynıdır.

Çözüm, DETACHED_PROCESS Proses Oluşturma BayrağınıCreateProcess win API'deki temel işleve geçirmektir . Pywin32'yi yüklediyseniz, bayrağı win32process modülünden içe aktarabilirsiniz, aksi takdirde kendiniz tanımlamanız gerekir:

DETACHED_PROCESS = 0x00000008

pid = subprocess.Popen([sys.executable, "longtask.py"],
                       creationflags=DETACHED_PROCESS).pid

Kullanım subprocess.Popen()ile close_fds=Trueestiren altişlem Python kopmamak sağlayacak parametre, kendisini işlemek ve hatta Python çıkar sonra yayınlanmaya devam eder.

https://gist.github.com/yinjimmy/d6ad0742d03d54518e9f

import os, time, sys, subprocess

if len(sys.argv) == 2:
    time.sleep(5)
    print 'track end'
    if sys.platform == 'darwin':
        subprocess.Popen(['say', 'hello'])
else:
    print 'main begin'
    subprocess.Popen(['python', os.path.realpath(__file__), '0'], close_fds=True)
    print 'main end'

Muhtemelen farklı iş parçacıkları çatallamak için os modülünü araştırmaya başlamak istiyorsunuz (etkileşimli bir oturum açıp yardım (os) vererek). İlgili fonksiyonlar çatal ve exec fonksiyonlarından herhangi birisidir. Nasıl başlayacağınıza dair bir fikir vermek için, çatalı gerçekleştiren bir işleve böyle bir şey koyun (işlevin, programın adını ve parametrelerini içeren bir argüman olarak bir liste alması veya 'args' ifadesini alması gerekir; ayrıca yeni iş parçacığı için stdin, out ve err tanımlamak için):

try:
    pid = os.fork()
except OSError, e:
    ## some debug output
    sys.exit(1)
if pid == 0:
    ## eventually use os.putenv(..) to set environment variables
    ## os.execv strips of args[0] for the arguments
    os.execv(args[0], args)

Hem çıktıyı yakalayın hem de threading

Bu cevapta belirtildiği gibi , çıktıyı yakalar stdout=ve sonra denerseniz read(), işlem engeller.

Bununla birlikte, buna ihtiyacınız olan durumlar vardır. Örneğin, aralarındaki bir bağlantı noktası üzerinden konuşan iki işlemi başlatmak ve stdout'larını bir günlük dosyasına ve stdout'a kaydetmek istedim .

threadingModül bunları yapmamıza olanak verir.

İlk olarak, bu soruda çıkış yeniden yönlendirme kısmının nasıl tek başına yapılacağına bir göz atın: Python Popen: Aynı anda stdout AND log dosyasına yaz

Sonra:

main.py

#!/usr/bin/env python3

import os
import subprocess
import sys
import threading

def output_reader(proc, file):
    while True:
        byte = proc.stdout.read(1)
        if byte:
            sys.stdout.buffer.write(byte)
            sys.stdout.flush()
            file.buffer.write(byte)
        else:
            break

with subprocess.Popen(['./sleep.py', '0'], stdout=subprocess.PIPE, stderr=subprocess.PIPE) as proc1, \
     subprocess.Popen(['./sleep.py', '10'], stdout=subprocess.PIPE, stderr=subprocess.PIPE) as proc2, \
     open('log1.log', 'w') as file1, \
     open('log2.log', 'w') as file2:
    t1 = threading.Thread(target=output_reader, args=(proc1, file1))
    t2 = threading.Thread(target=output_reader, args=(proc2, file2))
    t1.start()
    t2.start()
    t1.join()
    t2.join()

sleep.py

#!/usr/bin/env python3

import sys
import time

for i in range(4):
    print(i + int(sys.argv[1]))
    sys.stdout.flush()
    time.sleep(0.5)

Koşu sonrası:

./main.py

stdout, her iki satır için 0.5 saniyede bir güncellenir:

0
10
1
11
2
12
3
13

ve her günlük dosyası belirli bir işlem için ilgili günlüğü içerir.

İlham kaynağı: https://eli.thegreenplace.net/2017/interacting-with-a-long-running-child-process-in-python/

Ubuntu 18.04, Python 3.6.7 üzerinde test edilmiştir.