golang close other programs

Recently, while learning golang, I encountered a requirement: During the running of the program, other programs specified in the system need to be closed to ensure the correctness of the program running. In order to achieve this requirement, I conducted some research and gave the following methods.

Method 1: exec.Command

There is the exec package in golang, through which an external command can be executed, which means that other programs can be executed through the golang program. Based on this feature, we can use the exec.Command method to close other specified programs.

Code example:

cmd := exec.Command("taskkill", "/F", "/IM", "notepad.exe")
err := cmd.Run()
if err != nil {
    fmt.Println("execute command failed: ", err)
}

The above code executes the taskkill command under the Windows system through the exec.Command method to close the notepad.exe program. Among them, /F means forcefully ending the process, and /IM is followed by the name of the process.

Next, we analyze the execution method of exec.Command based on the code:

1. First create the exec.Cmd structure object cmd.
2. Set the command and parameters to be executed (PID or process image name in Task Manager).
3. Call the cmd.Run() method to execute the command.
4. Handle the error err returned by cmd.Run(). If err is not nil, it means the command execution failed.

Method 2: syscall.Kill

In addition to using the exec package to execute external commands to shut down the process, golang also provides a native method - syscall.Kill. This function can directly kill the PID of the specified process.

Code example:

pid := 123 // 进程的PID
err := syscall.Kill(pid, syscall.SIGKILL) // 执行kill命令
if err != nil {
    fmt.Println("kill process failed: ", err)
}

The above code uses the syscall.Kill function to shut down the specified PID process. SIGKILL is the kill command in the Linux system, which can directly kill the process, which is equivalent to forcibly ending the process.

Next, we analyze the execution method of syscall.Kill based on the code:

1. It is required to run the program with administrator privileges, otherwise the specified process will not be killed because there is no permission.
2. Create the variable pid to store the PID of the process.
3. Call syscall.Kill(pid, SIGKILL) to kill the process.
4. Handle the error err returned by syscall.Kill. If err is not nil, it means the command execution failed.

Method 3: Use third-party libraries

In addition to the above two methods, we can also use third-party libraries to realize the function of closing other programs. The most commonly used one is the github.com/mitchellh/go-ps library, which can return information about all processes currently running in the system.

We can find the process with the specified name and kill it based on the process information.

Code example:

processes, err := ps.Processes()
if err != nil {
    fmt.Println("get processes failed: ", err)
    return
}
for _, p := range processes {
    if strings.Contains(p.Executable(), "notepad") {
        err := syscall.Kill(p.Pid(), syscall.SIGTERM)
        if err != nil {
            fmt.Println("kill process failed: ", err)
        }
    }
}

The above code obtains all process information in the system through the third-party library github.com/mitchellh/go-ps, and then traverses these processes to find names containing notepad process and kill it.

Next, let’s analyze how to use the go-ps library based on the code:

1. Introduce the github.com/mitchellh/go-ps library.
2. Call the ps.Processes() method to obtain all process information in the system.
3. Traverse the process information and find the process with the specified name.
4. Call the syscall.Kill(p.Pid(), SIGTERM) method to kill the process.
5. Handle the error err returned by syscall.Kill. If err is not nil, it means the command execution failed.

Among the above three methods, exec.Command and syscall.Kill are native golang methods and are relatively simple to use. The method of using third-party libraries requires the introduction of external libraries, but you can obtain more rich information, such as process startup time, etc.

Summary

Through the above three methods, we can realize the function of golang program to close other programs. When we need to ensure the correctness of program operation, we can kill unnecessary processes in the system in this way to ensure the stability of the program. It should be noted that when using these methods, pay special attention to the PID and name of the process to avoid accidentally deleting other processes.

The above is the detailed content of golang close other programs. For more information, please follow other related articles on the PHP Chinese website!