Sprawdź, czy proces istnieje w ruchu

Question

Jeśli mam PID procesu, czy jest os.FindProcess wystarczy, aby przetestować istniejący proces? Chodzi mi o to, że jeśli wróci err, czy mogę założyć, że zostało zakończone (lub zabite)?

Edit:

Właśnie napisałem funkcję otoki wokół kill -s 0 (proces testowania bash w starym stylu). To działa bez problemu, ale nadal jestem zadowolony, jeśli nie ma innych rozwiązań (wykonane z Go bibliotek) do tego problemu .:

func checkPid(pid int) bool { 
    out, err := exec.Command("kill", "-s", "0", strconv.Itoa(pid)).CombinedOutput() 
    if err != nil { 
     log.Println(err) 
    } 

    if string(out) == "" { 
     return true // pid exist 
    } 
    return false 
} 

Answer 1

Oto tradycyjny UNIX sposób, aby zobaczyć, czy proces jest żywy - wyślij go do nas sygnał 0 (tak jak w przypadku twojego basha).

Od kill(2):

If sig is 0, then no signal is sent, but error checking is still per‐ 
    formed; this can be used to check for the existence of a process ID or 
    process group ID. 

A języku idź

package main 

import (
    "fmt" 
    "log" 
    "os" 
    "strconv" 
    "syscall" 
) 

func main() { 
    for _, p := range os.Args[1:] { 
     pid, err := strconv.ParseInt(p, 10, 64) 
     if err != nil { 
      log.Fatal(err) 
     } 
     process, err := os.FindProcess(int(pid)) 
     if err != nil { 
      fmt.Printf("Failed to find process: %s\n", err) 
     } else { 
      err := process.Signal(syscall.Signal(0)) 
      fmt.Printf("process.Signal on pid %d returned: %v\n", pid, err) 
     } 

    } 
} 

Po uruchomieniu go można dostać to, pokazując, że proces 123 nie żyje, proces 1 jest żywy, ale nie posiadane przez ciebie i proces 12606 jest żywy i posiadany przez ciebie.

$ ./kill 1 $$ 123 
process.Signal on pid 1 returned: operation not permitted 
process.Signal on pid 12606 returned: <nil> 
process.Signal on pid 123 returned: no such process 

Answer 2

w systemie UNIX, takich jak systemy (Linux, FreeBSD, etc) os.FindProcess będzie nigdy nie zwróci błędu. Nie wiem, co dzieje się w systemie Windows. Oznacza to, że nie będziesz wiedział, czy PID jest poprawny, dopóki nie spróbujesz użyć czegoś * os.Process.

Możesz spojrzeć na kod here.

Answer 3

Jeśli poprzednio znany pid nie został znaleziony w systemie (brak pewności co do funkcji go), oznacza to, że proces został definitywnie zakończony i został dołączony (na Unix, z wait call).

Ale w inny sposób niekoniecznie musi to być prawda. Tylko dlatego, że istnieje pid, nie gwarantuje, że jest to ten sam proces, co poprzednio. Na przykład w standardowym systemie Linux istnieje tylko 65535 poprawnych identyfikatorów i można je ponownie wykorzystać, gdy jest zawijany. Jeśli jednak sprawdzisz często, z praktycznego punktu widzenia nie musisz się tym przejmować (o ile pid z błędnego nowego procesu nie jest luką w zabezpieczeniach lub czymś innym krytycznym, którą ktoś może próbować wywołać celowo dla złośliwego cele).

Powiązane linki (i inne pytania na temat ich prawych kolumnach):

• https://superuser.com/questions/135007/how-are-pids-generated
• https://unix.stackexchange.com/questions/26677/will-process-ids-be-recycled-what-if-you-reach-the-maximal-id

Answer 4

Można również po prostu użyć syscall.Kill. To mniej kodu.

killErr := syscall.Kill(pid, syscall.Signal(0)) 
procExists := killErr == nil 

Answer 5

W systemie Windows sprawdzenie wyniku os.FindProcess() wydaje się wystarczające do sprawdzenia, czy proces jest uruchomiony.

func isProcessRunning(pid int) bool { 
    _, err = os.FindProcess(pid) 
    if err != nil { 
     return false 
    } 
    if runtime.GOOS == "windows" { 
     return true 
    } 
    return false // further checking for other systems then Windows is not supported here 
}