Fork: Difference between revisions

=={{header|Ada}}==

{{libheader|POSIX}}

POSIX.Process_Identification,

POSIX.Unsafe_Process_Primitives;

when others =>

Put_Line ("Something went wrong.");

 

=={{header|Aikido}}==

var pid = fork()

switch (pid) {

break

}

 

=={{header|ALGOL 68}}==

 

{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9 - "fork" is not part of the standard's prelude.}}

(

INT pid;

print("ERROR: Something went wrong")

FI

Output:

<pre>

This is the original process

</pre>

=={{header|AutoHotkey}}==

IfMsgBox, Yes

Run, %A_AhkPath% "%A_ScriptFullPath%"

 

pid = FORK

IF pid = 0 THEN

ELSE

PRINT "Error in fork"

 

{{out}}

Waiting for child to exit

I am the child, my PID is:12733</pre>

 

=={{header|C}}==

#include <stdlib.h>

#include <unistd.h>

 

return 0;

child process: done

 

=={{header|C++}}==

 

{{libheader|POSIX}}

#include<unistd.h>

 

 

return 0;

 

=={{header|Clojure}}==

Through its Java interop capabilities, Clojure has full access to the JRE's process creation and control facilities. The ''clojure.java.shell'' API (in Clojure 1.2; there's an equivalent in 1.1 ''clojure.contrib.shell'') uses these facilities to provide a convenient way of running a shell command in a separate process, providing its arguments, input, environment, and working dir as necessary, and capturing the process's return code and its stdout and stderr output.

Though this starts a separate process, the code in ''shell/sh'' blocks until the process completes. We can get other stuff done in the meantime by running the function in a separate thread with the core function ''future''. Suppose we want to find files named "needle.*" in a large directory tree ''haystack'', and do other stuff while the search proceeds. Using the Unix-like command ''find'' the code would look something like

(while (and (other-stuff-to-do?) (not (future-done? search)))

(do-other-stuff))

(if (zero? exit)

(do-something-with out)

 

=={{header|COBOL}}==

{{works with|GnuCOBOL}}

 

program-id. forking.

 

 

goback.

 

{{out}}

{{works with|SBCL}}

 

(cond

((zerop pid) (write-line "This is the new process."))

((plusp pid) (write-line "This is the original process."))

 

=={{header|D}}==

import std.stdio;

 

}).start;

writeln("Main thread.");

 

{{out}}

In OpenVMS DCL, spawning a subprocess creates a partially independent process. The parent and child processes share certain pooled quotas, certain shared resources, and if the parent process is deleted then the child process is too automatically.

 

$ i = 10

$ loop:

$ wait 'p1

$ i = i - 1

{{out}}

<pre>$ spawn /nowait /notify @looper 0::2 ! up to 8 parameters are allowed

$</pre>

To create a more independent process requires a privilege, e.g. detach. There isn't a mechanism for passing parameters to the detached process, so we embed them in a jacket procedure (possibly created dynamically).

$ set noverify ! detached processes have verify on by default which clutters up the output log file

{{out}}

<pre>$ run /detach sys$system:loginout /input = fork /output = fork

4-JUN-2015 13:35:55

4-JUN-2015 13:35:57</pre>

 

=={{header|Elixir}}==

def start do

spawn(fn -> child end)

end

 

 

{{out}}

 

=={{header|Erlang}}==

-export([start/0]).

 

 

child() ->

 

Then you can compile your code and execute it:

 

 

=={{header|Factor}}==

This works only in the terminal, if used from the UI the child process won't print.

 

 

 

=={{header|Fexl}}==

There are many levels at which I can address this task. I'll start from the lowest possible level:

print "pid = ";print pid;nl;

{{out}}

<pre>

 

At the next level up, we can define a "spawn" function which makes it easy to fork a child process and interact with its stdin, stdout, and stderr:

# (spawn child_fn next)

# Fork the child function as a process and return its pid, stdin, stdout, and

)

)

 

Next, we define a test_pipe function to test the whole apparatus:

 

\test_pipe =

(\next

next

)

 

Finally we call the test function:

{{out}}

<pre>

Good bye from parent.

test_pipe completed successfully.

</pre>

 

The [https://golang.org/pkg/os/exec <code>os/exec</code>] package offers a higher level interface and may be simpler in some situations.

For the purpose of this task though, there is little difference.

 

import (

fmt.Println(err)

}

{{out}}

<pre>PID: 28044

 

For the subprocess this example uses Cygwin's bash shell and commands running under MS Windows.

Process p = Runtime.runtime.exec('''

C:/cygwin/bin/sh -c "

}

p.waitFor()

 

Output:

 

=={{header|Haskell}}==

 

main = do

forkProcess (putStrLn "This is the new process")

 

=={{header|HicEst}}==

 

WRITE(Messagebox='?Y', IOStat=ios) "Another Fork?"

BEEP("c e g 'c")

WRITE(Messagebox="!") "Waiting ..."

 

=={{header|Icon}} and {{header|Unicon}}==

if (fork()|runerr(500)) = 0 then

write("child")

write("parent")

}

Notes:

* Fork should not fail. If an error 500 is generated there is a problem.

=={{header|J}}==

This example works by calling fork in a shared object library of Ubuntu 14.04.1 LTS . The verb given to adverb Fork evaluates in the child process.

load'dll'

The child process explicitly exits remaining as a zombie until the parent terminates.

<pre>

=={{header|Java}}==

{{trans|NetRexx}}

import java.io.IOException;

import java.io.InputStreamReader;

}

}

{{out}}

<pre>

 

=={{header|Julia}}==

@async(begin sleep(1); println("This is the child process."); sleep(2); println("Child again.") end)

sleep(2)

sleep(2)

println("Parent again.")

Parent running.

This is the child process.

Parent again.

</pre>

 

=={{header|Kotlin}}==

{{trans|NetRexx}}

 

import java.io.InputStreamReader

iox.printStackTrace()

}

 

Sample output (Ubuntu 14.04):

Lasso is multithreaded by design.

You can fork of an independent thread at anytime using split_thread. The second thread will inherit all local variables declared before it is split.

 

split_thread => {

stdoutnl(#mydata)

#mydata = 'Aha, I am still in the original thread'

Output:

<pre>I am data one

You can run this in the REPL as-is:

 

(defun start ()

(spawn (lambda () (child))))

(defun child ()

(lfe_io:format "This is the new process~n" '()))

 

=={{header|Lua}}==

{{libheader|POSIX}}

 

local pid = posix.fork()

else

error("unable to fork")

 

This code will run a standalone Mathematica kernel, putting the result of a command in a temporary file:

->"MathKernel -noprompt -run \"Put[Factorial[20],ToFileName[$TemporaryDirectory,ToString[temp1]]];Quit[]\""

 

Run[commandstring]

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols binary

 

 

return

{{out}}

<pre>

 

=={{header|NewLISP}}==

(cond

((nil? pid) (throw-error "Unable to fork"))

 

=={{header|Nim}}==

var pid = fork()

if pid < 0:

elif pid > 0:

else:

 

=={{header|OCaml}}==

 

let pid = Unix.fork ();;

if pid > 0 then

print_endline "This is the original process"

else

 

=={{header|ooRexx}}==

===version 1 using REPLY===

sub~sub

Call syssleep 1

Say 'subroutine' time()

Call syssleep 1

{{out}}

<pre>subroutine 10:53:27

 

===version 2 using START===

sub~start('start_working')

 

Say 'subroutine' time()

Call syssleep 1

{{out}}

<pre>subroutine 14:55:10

Mozart's support for distributed programming is quite unique. We can send code accross the network and share data by lexical scoping. It doesn't matter whether we create the process on the local machine (as in this example) or on some remote computer as long as we have ssh access (or some similar method) and Mozart is installed.

 

ParentVar1 = "parent data"

ParentVar2

%% exit child process

{RM close}

 

=={{header|PARI/GP}}==

This is a PARI implementation which uses <code>fork()</code> via PARI's <code>pari_daemon</code>. Of course <code>fork()</code> could be used directly.

 

foo()

{

else

pari_printf("Fork\n");

 

=={{header|Perl}}==

In the child code, you may have to re-open database handles and such.

 

if ($pid = fork()) {

# parent code

warn '[' . localtime() . "] Unable to fork - $!";

exit(0);

 

Obviously you could do a Fork in a lot less lines, but this code covers all the bases.

Another example using [http://search.cpan.org/perldoc?Proc::Fork Proc::Fork] module:

 

run_fork {

child {

# parent code ...

}

 

Or:

# parent code ...

run_fork {

}

};

 

More complex example with retries and error handling:

run_fork {

child {

# error handling ...

}

 

=={{header|Phix}}==

Phix has create_thread which creates a separate thread, with its own call stack, but sharing common data (like most fork examples here).<br>

To run something completely independently, use system() or system_exec(), depending on whether you want a shell and/or to wait for a result.

or

 

=={{header|PHP}}==

{{trans|C}}

$pid = pcntl_fork();

if ($pid == 0)

else

echo "ERROR: Something went wrong\n";

 

=={{header|PicoLisp}}==

(println *Pid) # Print the child's PID

 

=={{header|PL/I}}==

ATTACH SOLVE (X) THREAD (T5);

 

=={{header|Pop11}}==

if sys_fork(false) ->> ress then

;;; parent

else

printf('In child\n');

{{omit from|PureBasic}}

 

=={{header|Python}}==

{{works with|Python|2.5}}

 

pid = os.fork()

# parent code

else:

 

=={{header|Racket}}==

are both. First, run some subprocess independently of Racket:

 

#lang racket

(define-values [P _out _in _err]

;; wait for process to end, print messages as long as it runs

(let loop () (unless (sync/timeout 10 P) (printf "Still running...\n") (loop)))

 

Output:

Second, using fork() in its raw form, which is doable in racket, but as unsafe as you'd expect it to be:

 

#lang racket

(require ffi/unsafe)

(define fork (get-ffi-obj 'fork #f (_fun -> _int)))

(printf ">>> fork() => ~s\n" (fork))

 

Output:

>>> fork() => 0

</pre>

 

=={{header|REXX}}==

This function &nbsp; '''only''' &nbsp; works with Regina REXX.

 

=={{header|Ruby}}==

if pid

# parent code

else

# child code

or

# child code

end

 

 

=={{header|Scala}}==

{{libheader|Scala}}

===A Linux version===

 

object Fork extends App {

case iox: IOException => iox.printStackTrace()

}

===A Windows version===

 

object Fork extends App {

case iox: IOException => iox.printStackTrace()

}

 

=={{header|Sidef}}==

{ x += 1; say x }.fork.wait; # x is 43 here

 

=={{header|Slate}}==

[| ret |

(ret := lobby cloneSystem)

first ifTrue: [p pipes addLast: ret second. ret second]

ifFalse: [[p pipes clear. p pipes addLast: ret second. b applyWith: ret second] ensure: [lobby quit]]

 

=={{header|Smalltalk}}==

 

|a|

a := [

"wait to avoid terminating first the parent;

a better way should use semaphores"

 

=={{header|Standard ML}}==

 

SOME pid => print "This is the original process\n"

 

=={{header|Tcl}}==

Example:

 

# or

package require Tclx

}

}

 

In most cases though, one is not interested in spawning a copy of the process one already has, but rather wants a different process. When using POSIX APIs, this has to be done by first forking and then having the child use the exec system call to replace itself with a different program. The Tcl <code>[http://www.tcl.tk/man/tcl8.5/TclCmd/exec.htm exec]</code> command does this fork&exec combination — in part because non-Unix OSs typicallly don't have "make a copy of parent process" as an intermediate step when spawning new processes.

 

=={{header|Toka}}==

getpid is-data PID

 

=={{header|UNIX Shell}}==

{{works with|Bourne Shell}}

(while test $i -lt 10; do

sleep 1

echo "Parent process"

i=`expr $i + 1`

 

This uses the operator <tt>&</tt> to run the child process and the parent process at the same time. The output for the next 10 seconds is "Child process" every 1 second, and "Parent process" every 2 seconds. Both processes inherit <tt>i=0</tt>, but each process has its own <tt>i</tt> variable because processes are independent.

{{works with|bash}}

 

for ((i=0;i<5;i++)); do

sleep 2

echo "Parent process"

 

=={{header|UnixPipes}}==

Demonstrating a subshell getting forked, and running concurrently with the original process

 

 

=={{header|Wart}}==

prn.1)

 

I've written a subroutine that prints out any positive value. It lives on my desktop and you can't find it on rosetta code.

I've also written a sleep subroutine and you can find that in the Sleep task on this site.

 

; x86_64 linux nasm

 

mov rdi, 0

syscall

 

=={{header|zkl}}==

{{works with|Unix}}

This just tells the Unix shell to run the process in the background

{{out}}

<pre>

{{omit from|SAS}}

{{omit from|Stata}}

{{omit from|ZX Spectrum Basic|Does not support multiple processes.}}