Если вы не хотите делать услугу, вы можете сделать это.
var scope = angular.element("#another ctrl scope element id.").scope();
scope.plean_assign = some_value;
При необходимости в сценарии, чтобы иметь PID программы, можно все еще получить его после ветвления.
, Когда Вы разветвитесь, сохраните PID ребенка в родительском процессе. Когда Вы выходите из родительского процесса, или производите PID к STD{OUT,ERR}
или просто имеете return pid;
оператор в конце main()
. Сценарий выполнения вызова может затем получить pid программы, хотя это требует определенного знания того, как программа работает.
Мой совет: не делают этого , по крайней мере, не в соответствии с Linux/UNIX.
программы GUI в соответствии с Linux/UNIX традиционно делают не автофон сами. В то время как это может иногда быть раздражающим новичкам, это имеет много преимуществ:
Помогает зафиксировать стандартную ошибку в случае дампов ядра / другие проблемы та отладка потребности.
Помогает сценарию оболочки запустить программу и ожидать, пока она не завершается.
Помогает сценарию оболочки запустить программу в фоновом режиме и получить ее идентификатор процесса:
gui-program &
pid=$!
# do something with $pid later, such as check if the program is still running
, Если Ваши ветвления программы самостоятельно, это поведение повредится.
"Scriptability" полезен при таком количестве неожиданных обстоятельств, даже с программами GUI, что я смущался бы явно повреждать эти поведения.
Windows является другой историей. AFAIK, Windows-программы, автоматически выполненные в фоновом режиме - даже когда вызвано от командного процессора - если они явно не запрашивают доступ к командному окну.
В Unix я учился делать то использование fork()
. Если Вы хотите поместить рабочий процесс в фон, fork
это дважды.
Самая простая форма фоновой обработки:
if (fork() != 0) exit(0);
В Unix, если бы Вы хотите к фону разъединение с tty полностью, Вы сделали бы:
0
, 1
, и 2
). if (fork() != 0) exit(0);
setpgroup(0,getpid()); /* Might be necessary to prevent a SIGHUP on shell exit. */
signal(SIGHUP,SIG_IGN); /* just in case, same as using nohup to launch program. */
fd=open("/dev/tty",O_RDWR);
ioctl(fd,TIOCNOTTY,0); /* Disassociates from the terminal */
close(fd);
if (fork() != 0) exit(0); /* just for good measure */
, Который должен полностью daemonize Ваша программа.
/**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> &) */
Так, как Вы говорите, просто ветвление (), луг не добьется цели. То, что необходимо сделать, является ветвлением () и затем передолжностное лицо (), как этот пример кода делает:
#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;
}
цикл должен проверить на - аргумент демона, и если он присутствует, удалите его прежде re-execing, таким образом, бесконечного цикла избегают.
я не думаю, что это будет работать, если двоичный файл будет помещен в путь, потому что argv [0] является не обязательно полным путем, таким образом, он должен будет быть изменен.
В соответствии с Windows, заключительная вещь Вы собираетесь добраться для разветвления (), загружает программу как службу Windows, я думаю.
Вот ссылка на вводную статью о службах Windows... CodeProject: Простой Образец службы Windows
Как другие упомянули, ветвление () состоит в том, как сделать, оно на *отклоняет. Можно получить ветвление () в Windows при помощи библиотек MingW или Cygwin. Но они потребуют, чтобы Вы переключились на использование GCC как Ваш компилятор.
В чистом мире Windows, Вы использовали бы CreateProcess (или одна из его производных CreateProcessAsUser, CreateProcessWithLogonW).
Я не уверен в Windows, но в подобных UNIX системах, Вы можете fork()
затем setsid()
разветвленный процесс для перемещения его в новую группу процесса, которая не подключена к терминалу.
Наиболее распространенный способ выполнения этого в соответствии с Linux через разветвление . То же должно работать над Mac, что касается Windows I не на 100% уверено, но я полагаю, что у них есть что-то подобное.
В основном то, что происходит, является процессом, разделяет себя на два процесса и затем исходные выходы (возвращающий управление оболочке или безотносительно), и второй процесс продолжает работать в фоновом режиме.
К продолжению по Вашему отредактированному вопросу:
я задавался вопросом, был ли способ поместить СУЩЕСТВУЮЩИЙ процесс в фон.
В подобной Unix ОС, действительно нет способа сделать это, что я знаю о. Оболочка заблокирована, потому что она выполняет один из вариантов ожидания () вызов, ожидая дочернего процесса для выхода. Нет пути к дочернему процессу, чтобы остаться работать, но так или иначе заставлять ожидание оболочки () возвращаться с, "прекратите наблюдать за мной" состояние. Причина Вы имеете дочернее ветвление и выходите, оригинал является так оболочкой, возвратится из ожидания ().
Вот некоторый псевдокод для 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("/")
И поздравления, Ваша программа продолжается как независимый процесс "daemonized" без управления TTY и без любого стандартного ввода или вывода.
Теперь, в Windows Вы просто создаете свою программу как приложение Win32 с WinMain () вместо основного (), и это работает без консоли автоматически. Если Вы хотите работать как услуга, необходимо будет искать это, потому что я никогда не писал один, и я действительно не знаю, как они работают.
Фоновая обработка процесс является функцией оболочки, не функцией ОС.
, Если Вы хотите, чтобы приложение запустилось в фоновом режиме, типичный прием должен записать сценарий оболочки для запуска его, который запускает его в фоновом режиме.
#! /bin/sh
/path/to/myGuiApplication &
Процесс не может поместить себя в фон, потому что это не одно отвечающее за фон по сравнению с передним планом. Это было бы оболочкой, которая ожидает выхода процесса. Если Вы запускаете процесс с амперсандом "&"; в конце затем оболочка делает не , ожидают выхода процесса.
, Но единственный путь процесс может выйти из оболочки, должен разветвиться от другого ребенка и затем позволить ее оригиналу сам выход назад к оболочке ожидания.
От оболочки, Вы можете фон процесс с Управлением-Z, затем вводить "bg".
На UNIX необходимо разветвиться дважды подряд и позволить родителю умереть.
Три вещи нуждаются в выполнении,
fork
setsid
redirect STDIN, STDOUT and STDERR to /dev/null
Это относится к системам POSIX (все те, Вы упоминаете требование быть POSIX (но остановки Windows при требовании укусили))
На Linux демон () - то, что Вы ищете, если я понимаю Вас правильно.
Вы отредактировали свой вопрос, но можно все еще упускать суть, что вопросом является своего рода синтаксическая ошибка - если процесс не был помещен в фоновом режиме для начала, и Вы хотите, чтобы PID остался таким же, Вы не можете проигнорировать то, что программа, которая запустила процесс, ожидает на том, что PID и это в значительной степени определение того, чтобы быть на переднем плане.
я думаю, что необходимо думать о том, почему Вы хотите и поместить что-то в фоновом режиме и сохранить PID тем же. Я предлагаю, чтобы Вам, вероятно, не были нужны оба из тех ограничений.
Путем это обычно делается на подобных Unix Ose, должен разветвиться () вначале и выход от родителя. Это не будет работать над Windows, но намного более изящно, чем запуск другого процесса, где разветвление существует.
Я пробовал решение.
От родительского процесса требуется только одна вилка.
Самым важным моментом является то, что после fork родительский процесс должен умереть, вызвав _exit (0);
, а НЕ вызвав exit (0);
When _exit (0);
, командная строка немедленно возвращается в оболочке.
Это уловка.