Как программа на C / C++ может переключиться на задний план?

Обычно в Unix-подобных ОС это делается с помощью fork () в начале и выхода из родительского. Это не будет работать в Windows, но намного элегантнее, чем запуск другого процесса, в котором существует разветвление.

Наиболее распространенный способ сделать это в Linux - через разветвление. То же самое должно работать на Mac, что касается Windows, я не уверен на 100%, но я считаю, что у них есть что-то похожее.

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

Как уже упоминалось, fork () - это то, как это сделать на * nix. Вы можете получить fork () в Windows с помощью библиотек MingW или Cygwin. Но для этого вам потребуется переключиться на использование GCC в качестве компилятора.

В чистом мире Windows вы должны использовать CreateProcess (или одну из его производных CreateProcessAsUser, CreateProcessWithLogonW).

В UNIX вам нужно дважды подряд выполнить форк и позволить родителю умереть.

Я не уверен насчет Windows, но в UNIX-подобных системах вы можете fork(), а затем setsid() - разветвленный процесс, чтобы переместить его в новую группу процессов, не подключенную к терминалу.

Три вещи нужно сделать,

fork
setsid
redirect STDIN, STDOUT and STDERR to /dev/null

Это относится к системам POSIX (все те, которые вы упомянули, утверждают, что они POSIX (но Windows останавливается на бите требования))

Если вам нужен скрипт с PID программы, вы все равно можете получить его после форка.

При форке сохраните PID дочернего процесса в родительском процессе. Когда вы выходите из родительского процесса, либо выведите PID в STD{OUT,ERR}, либо просто добавьте оператор return pid; в конец main(). Затем вызывающий скрипт может получить идентификатор программы, хотя для этого требуются определенные знания о том, как работает программа.

Самый простой вид фона:

if (fork() != 0) exit(0);

В Unix, если вы хотите полностью отделиться от tty в фоновом режиме, вы должны:

1. Закройте все дескрипторы, которые могут обращаться к tty (обычно 0, 1 и 2).
2. if (fork() != 0) exit(0);
3. setpgroup(0,getpid()); /* Might be necessary to prevent a SIGHUP on shell exit. */
4. signal(SIGHUP,SIG_IGN); /* just in case, same as using nohup to launch program. */
5. fd=open("/dev/tty",O_RDWR);
6. ioctl(fd,TIOCNOTTY,0); /* Disassociates from the terminal */
7. close(fd);
8. if (fork() != 0) exit(0); /* just for good measure */

Это должно полностью демонизировать вашу программу.

Чтобы ответить на ваш отредактированный вопрос:

I was wondering if there was a way to put the EXISTING process into the background.

В Unix-подобных ОС я действительно не знаю способа сделать это. Оболочка заблокирована, потому что она выполняет один из вариантов вызова wait (), ожидая завершения дочернего процесса. Дочерний процесс не может оставаться запущенным, но каким-то образом заставляет оболочку wait () возвращаться со статусом «пожалуйста, перестань следить за мной». Причина, по которой у вас есть дочерняя вилка и выход из оригинала, заключается в том, что оболочка вернется из wait ().

Вот какой-то псевдокод для Linux / UNIX:

initialization_code()
if (failure) exit(1)
if ( fork() > 0 ) exit(0)
setsid()
setup_signal_handlers()
for(fd=0; fd<NOFILE; fd++) close(fd)
open("/dev/null", O_RDONLY)
open("/dev/null", O_WRONLY)
open("/dev/null", o_WRONLY)
chdir("/")

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

Теперь в Windows вы просто создаете свою программу как приложение Win32 с WinMain () вместо main (), и она автоматически запускается без консоли. Если вы хотите работать в качестве службы, вам придется поискать это, потому что я никогда не писал ни одной и не знаю, как они работают.

Процесс не может перейти в фоновый режим, потому что он не отвечает за задний план или передний план. Это будет оболочка, ожидающая выхода из процесса. Если вы запускаете процесс с амперсандом «&» в конце, то оболочка нет ожидает завершения процесса.

Но единственный способ, которым процесс может выйти из оболочки, - это отключить другого потомка, а затем позволить своему исходному «я» вернуться в ожидающую оболочку.

Из оболочки вы можете фоновый процесс с помощью Control-Z, затем введите «bg».

Фон процесса - это функция оболочки, а не функция ОС.

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

#! /bin/sh
/path/to/myGuiApplication &

Я думаю, что под Windows последнее, что вы получите от fork (), - это загрузка вашей программы как службы Windows.

Вот ссылка на вводную статью о службах Windows ... CodeProject: простой пример службы Windows

В Linux демон () - это то, что вы ищете, если я правильно вас понял.

Итак, как вы говорите, просто fork () ing не поможет. Что вы должны сделать, это fork (), а затем повторно выполнить exec (), как это делает этот пример кода:

#include stdio.h>
#include <unistd.h>
#include <string.h>

#include <CoreFoundation/CoreFoundation.h>

int main(int argc, char **argv)
{
    int i, j;

    for (i=1; i<argc; i++)
        if (strcmp(argv[i], "--daemon") == 0)
        {
            for (j = i+1; j<argc; j++)
                argv[j-1] = argv[j];

            argv[argc - 1] = NULL;

            if (fork()) return 0;

            execv(argv[0], argv);

            return 0;
        }


    sleep(1);

    CFRunLoopRun();

    CFStringRef hello = CFSTR("Hello, world!");

    printf("str: %s\n", CFStringGetCStringPtr(hello, CFStringGetFastestEncoding(hello)));

    return 0;
}

Цикл предназначен для проверки аргумента --daemon, и, если он присутствует, удалите его перед повторным запуском, чтобы избежать бесконечного цикла.

Я не думаю, что это сработает, если двоичный файл будет помещен в путь, потому что argv [0] не обязательно является полным путем, поэтому его нужно будет изменить.

Мой совет: не делай этого, по крайней мере, не под Linux / UNIX.

Программы с графическим пользовательским интерфейсом под Linux / UNIX традиционно сами выполняют авто-фон нет. Хотя иногда это может раздражать новичков, у этого есть ряд преимуществ:

• Упрощает регистрацию стандартной ошибки в случае дампов ядра / других проблем, требующих отладки.

• Упрощает сценарий оболочки для запуска программы и ожидания ее завершения.

• Упрощает сценарий оболочки для запуска программы в фоновом режиме и получения идентификатора процесса:

  gui-program &
  pid=$!
  # do something with $pid later, such as check if the program is still running
  

  Если ваша программа разветвляется, это поведение нарушится.

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

Окна - это отдельная история. AFAIK, программы Windows автоматически запускаются в фоновом режиме - даже при вызове из командной оболочки - если они явно не запрашивают доступ к командному окну.

Вы отредактировали свой вопрос, но вам все еще может не хватать того факта, что ваш вопрос является своего рода синтаксической ошибкой - если процесс не был переведен в фоновый режим для начала, и вы хотите, чтобы PID остался прежним, вы можете ' Игнорировать тот факт, что программа, запустившая процесс, ожидает этого PID, и это в значительной степени определение нахождения на переднем плане.

Я думаю, вам нужно подумать, почему вы хотите поместить что-то в фоновый режим и сохранить PID одинаковым. Я предполагаю, что вам, вероятно, не нужны оба этих ограничения.

/**Deamonize*/

pid_t pid;
pid = fork(); /**father makes a little deamon(son)*/
if (pid>0)
exit(0); /**father dies*/
while(1){
printf("Hello I'm your little deamon %d\n",pid); /**The child deamon goes on*/
sleep(1)
}

/** try 'nohup' in linux(usage: nohup <command> &) */

В Unix я научился делать это с помощью fork(). Если вы хотите перевести запущенный процесс в фоновый режим, fork дважды.

Я пробовал решение.

От родительского процесса требуется только одна вилка.

Самым важным моментом является то, что после fork родительский процесс должен умереть, вызвав _exit(0);, а НЕ вызвав exit(0);.

При использовании _exit(0); командная строка немедленно возвращается в оболочку.

Это уловка.