Bagaimana cara memulai proses latar belakang dengan Python?

Saya mencoba untuk mem-porting skrip shell ke versi python yang lebih mudah dibaca. Skrip shell asli memulai beberapa proses (utilitas, monitor, dll.) Di latar belakang dengan "&". Bagaimana saya bisa mencapai efek yang sama dengan python? Saya ingin proses ini tidak mati ketika skrip python selesai. Saya yakin ini terkait dengan konsep daemon, tapi saya tidak bisa menemukan cara melakukan ini dengan mudah.

Catatan : Jawaban ini kurang terkini daripada saat diposting pada tahun 2009. Menggunakan subprocessmodul yang ditunjukkan dalam jawaban lain sekarang direkomendasikan dalam dokumen

(Perhatikan bahwa modul subproses menyediakan fasilitas yang lebih kuat untuk menghasilkan proses baru dan mengambil hasilnya; menggunakan modul itu lebih baik daripada menggunakan fungsi-fungsi ini.)

Jika Anda ingin proses Anda dimulai di latar belakang, Anda dapat menggunakan system()dan memanggilnya dengan cara yang sama dengan skrip shell Anda, atau Anda dapat spawnmelakukannya:

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

(Atau, sebagai alternatif, Anda dapat mencoba os.P_NOWAITbendera yang kurang portabel ).

Lihat dokumentasi di sini .

Sementara solusi jkp bekerja, cara yang lebih baru dalam melakukan sesuatu (dan cara dokumentasi merekomendasikan) adalah dengan menggunakan subprocessmodul. Untuk perintah sederhana, ini setara, tetapi menawarkan lebih banyak opsi jika Anda ingin melakukan sesuatu yang rumit.

Contoh untuk kasus Anda:

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

Ini akan berjalan rm -r some.filedi latar belakang. Perhatikan bahwa memanggil .communicate()objek yang dikembalikan dari Popenakan memblokir hingga selesai, jadi jangan lakukan itu jika Anda ingin menjalankannya di latar belakang:

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

Lihat dokumentasi di sini .

Juga, poin klarifikasi: "Latar Belakang" seperti yang Anda gunakan di sini adalah murni konsep shell; secara teknis, yang Anda maksud adalah Anda ingin menelurkan proses tanpa memblokir sementara Anda menunggu untuk menyelesaikannya. Namun, saya telah menggunakan "latar belakang" di sini untuk merujuk pada perilaku seperti latar belakang shell.

Anda mungkin menginginkan jawaban untuk "Cara memanggil perintah eksternal dengan Python" .

Pendekatan paling sederhana adalah dengan menggunakan os.systemfungsi, misalnya:

import os
os.system("some_command &")

Pada dasarnya, apa pun yang Anda berikan ke systemfungsi akan dieksekusi sama seperti jika Anda meneruskannya ke shell dalam sebuah skrip.

Saya menemukan ini di sini :

Di windows (win xp), proses induk tidak akan selesai sampai pekerjaannya longtask.pyselesai. Ini bukan yang Anda inginkan dalam skrip CGI. Masalahnya tidak spesifik untuk Python, dalam komunitas PHP masalahnya sama.

Solusinya adalah dengan melewati DETACHED_PROCESS Bendera Proses Pembuatan ke CreateProcessfungsi yang mendasari di win API. Jika Anda menginstal pywin32, Anda dapat mengimpor flag dari modul win32process, jika tidak, Anda harus mendefinisikannya sendiri:

DETACHED_PROCESS = 0x00000008

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

Gunakan subprocess.Popen()dengan close_fds=Trueparameter, yang akan memungkinkan subproses yang dihasilkan terlepas dari proses Python itu sendiri dan terus berjalan bahkan setelah Python keluar.

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'

Anda mungkin ingin mulai menyelidiki modul os untuk mencari utas yang berbeda (dengan membuka sesi interaktif dan mengeluarkan bantuan (os)). Fungsi-fungsi yang relevan adalah fork dan fungsi-fungsi eksekutif mana saja. Untuk memberi Anda ide tentang cara memulainya, letakkan sesuatu seperti ini di dalam fungsi yang melakukan fork (fungsi perlu mengambil daftar atau tuple 'args' sebagai argumen yang berisi nama program dan parameternya; Anda mungkin juga ingin untuk mendefinisikan stdin, out, dan err untuk utas baru):

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)

Keduanya menangkap keluaran dan berjalan di latar belakang dengan threading

Seperti disebutkan pada jawaban ini , jika Anda menangkap output dengan stdout=dan kemudian mencoba read(), maka proses tersebut akan terhambat.

Namun, ada kasus di mana Anda membutuhkan ini. Sebagai contoh, saya ingin meluncurkan dua proses yang berbicara melalui port di antara mereka , dan menyimpan stdout mereka ke file log dan stdout.

The threadingmodul memungkinkan kita untuk melakukan itu.

Pertama, lihat bagaimana melakukan bagian redirection output saja dalam pertanyaan ini: Python Popen: Menulis ke stdout DAN file log secara bersamaan

Kemudian:

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)

Setelah berlari:

./main.py

stdout diperbarui setiap 0,5 detik untuk setiap dua baris mengandung:

0
10
1
11
2
12
3
13

dan setiap file log berisi log masing-masing untuk proses yang diberikan.

Terinspirasi oleh: https://eli.thegreenplace.net/2017/interacting-with-a-long-running-child-process-in-python/

Diuji pada Ubuntu 18.04, Python 3.6.7.