declares the symbols fi as shared functions whose downvalues are synchronized among all parallel kernels.


  • Downvalues for a shared function defined on any kernel are maintained by the master kernel and every access on a parallel subkernel is synchronized through the master kernel.
  • Expressions of the form f[] that would remain unevaluated give Null.


open allclose all

Basic Examples  (1)

Make fs be a (global) shared function:

Each subkernel makes a definition for the same shared variable:

Without sharing, each subkernel has its own (local) copy of the function:

Scope  (4)

Define and share a function:

When called from each subkernel, the function updates next on the master kernel:

Set up a shared function with a default rule:

Make additional definitions on the subkernels:

Since the function is shared, the master kernel knows about the additional rules:

Maintain indexed shared variables with a default value:

Define a shared function to manipulate the local variable results on the master kernel:

Call the function from the subkernels:

The variable on the master has been modified:

Generalizations & Extensions  (1)

A delayed definition for a shared function made on the master kernel:

Such definitions are always evaluated on the master kernel, whichever kernel evaluates it:

A definition for a shared function made on one of the parallel kernels:

Such definitions are always evaluated on the kernel that asks for the value:

Applications  (3)

Shared functions can be used for synchronization:

Less efficient is the use of a shared variable and critical section:

A constructor for a simple queue data type:

Create two shared queues:

Fill the input queue:

Work on the elements of the input queue in parallel and put results into the output queue:

Use a single shared function to communicate both input and result:

Set up a search and display its progress until it is manually aborted:

The results found so fara list of the number of factors of :

Properties & Relations  (1)

Use a shared append function for a local variable to collect results:

Using AppendTo on a shared variable has the same effect:

Possible Issues  (3)

A shared function is inefficient for mere code distribution and leads to sequential evaluation:

Simply distribute the definitions of any function needed on the parallel kernels:

Separate read and write operations on a shared variable are not thread-safe:

Use a shared function to synchronize access to an (unshared) variable:

Alternatively, use CriticalSection to make a whole code section atomic:

Parallel dynamic programming:

Neat Examples  (1)

A parallel version of Sow:

Wolfram Research (2008), SetSharedFunction, Wolfram Language function,


Wolfram Research (2008), SetSharedFunction, Wolfram Language function,


Wolfram Language. 2008. "SetSharedFunction." Wolfram Language & System Documentation Center. Wolfram Research.


Wolfram Language. (2008). SetSharedFunction. Wolfram Language & System Documentation Center. Retrieved from


@misc{reference.wolfram_2023_setsharedfunction, author="Wolfram Research", title="{SetSharedFunction}", year="2008", howpublished="\url{}", note=[Accessed: 28-September-2023 ]}


@online{reference.wolfram_2023_setsharedfunction, organization={Wolfram Research}, title={SetSharedFunction}, year={2008}, url={}, note=[Accessed: 28-September-2023 ]}