# Submit a work item to the thread pool

[ Updated for UWP apps on Windows 10. For Windows 8.x articles, see the archive ]

Important APIs

Learn how to do work in a separate thread by submitting a work item to the thread pool. Use this to maintain a responsive UI while still completing work that takes a noticeable amount of time, and use it to complete multiple tasks in parallel.

## Create and submit the work item

Create a work item by calling RunAsync. Supply a delegate to do the work (you can use a lambda, or a delegate function). Note that RunAsync returns an IAsyncAction object; store this object for use in the next step.

Three versions of RunAsync are available so that you can optionally specify the priority of the work item, and control whether it runs concurrently with other work items.

Note

Use CoreDispatcher.RunAsync to access the UI thread and show progress from the work item.

The following example creates a work item and supplies a lambda to do the work:

``````// The nth prime number to find.
const uint n = 9999;

// A shared pointer to the result.
// We use a shared pointer to keep the result alive until the
ulong nthPrime = 0;

// Simulates work by searching for the nth prime number. Uses a
// naive algorithm and counts 2 as the first prime number.
(workItem) =>
{
uint  progress = 0; // For progress reporting.
uint  primes = 0;   // Number of primes found so far.
ulong i = 2;        // Number iterator.

if ((n >= 0) && (n <= 2))
{
nthPrime = n;
return;
}

while (primes < (n - 1))
{
if (workItem.Status == AsyncStatus.Canceled)
{
break;
}

// Go to the next number.
i++;

// Check for prime.
bool prime = true;
for (uint j = 2; j < i; ++j)
{
if ((i % j) == 0)
{
prime = false;
break;
}
};

if (prime)
{
// Found another prime number.
primes++;

// Report progress at every 10 percent.
uint temp = progress;
progress = (uint)(10.0*primes/n);

if (progress != temp)
{
updateString = "Progress to " + n + "th prime: "
+ (10 * progress) + "%\n";

// Update the UI thread with the CoreDispatcher.
CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(
CoreDispatcherPriority.High,
new DispatchedHandler(() =>
{
}));
}
}
}

// Return the nth prime number.
nthPrime = i;
});

// A reference to the work item is cached so that we can trigger a
// cancellation when the user presses the Cancel button.
m_workItem = asyncAction;
``````
``````// The nth prime number to find.
const unsigned int n{ 9999 };

unsigned long nthPrime{ 0 };

// Simulates work by searching for the nth prime number. Uses a
// naive algorithm and counts 2 as the first prime number.

// A reference to the work item is cached so that we can trigger a
// cancellation when the user presses the Cancel button.
{
unsigned int progress = 0; // For progress reporting.
unsigned int primes = 0;   // Number of primes found so far.
unsigned long int i = 2;   // Number iterator.

if ((n >= 0) && (n <= 2))
{
nthPrime = n;
return;
}

while (primes < (n - 1))
{
if (workItem.Status() == Windows::Foundation::AsyncStatus::Canceled)
{
break;
}

// Go to the next number.
i++;

// Check for prime.
bool prime = true;
for (unsigned int j = 2; j < i; ++j)
{
if ((i % j) == 0)
{
prime = false;
break;
}
};

if (prime)
{
// Found another prime number.
primes++;

// Report progress at every 10 percent.
unsigned int temp = progress;
progress = static_cast<unsigned int>(10.f*primes / n);

if (progress != temp)
{
updateString << L"Progress to " << n << L"th prime: " << (10 * progress) << std::endl;

// Update the UI thread with the CoreDispatcher.
Windows::ApplicationModel::Core::CoreApplication::MainView().CoreWindow().Dispatcher().RunAsync(
Windows::UI::Core::CoreDispatcherPriority::High,
Windows::UI::Core::DispatchedHandler([&]()
{
}));
}
}
}
// Return the nth prime number.
nthPrime = i;
});
``````
``````// The nth prime number to find.
const unsigned int n = 9999;

// A shared pointer to the result.
// We use a shared pointer to keep the result alive until the
std::shared_ptr<unsigned long> nthPrime = std::make_shared<unsigned long int>(0);

// Simulates work by searching for the nth prime number. Uses a
// naive algorithm and counts 2 as the first prime number.
auto workItem = ref new Windows::System::Threading::WorkItemHandler(
\[this, n, nthPrime](IAsyncAction^ workItem)
{
unsigned int progress = 0; // For progress reporting.
unsigned int primes = 0;   // Number of primes found so far.
unsigned long int i = 2;   // Number iterator.

if ((n >= 0) && (n <= 2))
{
*nthPrime = n;
return;
}

while (primes < (n - 1))
{
if (workItem->Status == AsyncStatus::Canceled)
{
break;
}

// Go to the next number.
i++;

// Check for prime.
bool prime = true;
for (unsigned int j = 2; j < i; ++j)
{
if ((i % j) == 0)
{
prime = false;
break;
}
};

if (prime)
{
// Found another prime number.
primes++;

// Report progress at every 10 percent.
unsigned int temp = progress;
progress = static_cast<unsigned int>(10.f*primes / n);

if (progress != temp)
{
updateString = "Progress to " + n + "th prime: "
+ (10 * progress).ToString() + "%\n";

// Update the UI thread with the CoreDispatcher.
CoreApplication::MainView->CoreWindow->Dispatcher->RunAsync(
CoreDispatcherPriority::High,
{
}));
}
}
}
// Return the nth prime number.
*nthPrime = i;
});

// A reference to the work item is cached so that we can trigger a
// cancellation when the user presses the Cancel button.
m_workItem = asyncAction;
``````

Following the call to RunAsync, the work item is queued by the thread pool and runs when a thread becomes available. Thread pool work items run asynchronously and they can run in any order, so make sure your work items function independently.

Note that the work item checks the IAsyncInfo.Status property, and exits if the work item is cancelled.

## Handle work item completion

Provide a completion handler by setting the IAsyncAction.Completed property of the work item. Supply a delegate (you can use a lambda or a delegate function) to handle work item completion. For example, use CoreDispatcher.RunAsync to access the UI thread and show the result.

The following example updates the UI with the result of the work item submitted in step 1:

``````asyncAction->Completed = ref new AsyncActionCompletedHandler(
\[this, n, nthPrime](IAsyncAction^ asyncInfo, AsyncStatus asyncStatus)
{
if (asyncStatus == AsyncStatus::Canceled)
{
return;
}

updateString = "\n" + "The " + n + "th prime number is "
+ (*nthPrime).ToString() + ".\n";

// Update the UI thread with the CoreDispatcher.
CoreApplication::MainView->CoreWindow->Dispatcher->RunAsync(
CoreDispatcherPriority::High,
{
}));
});
``````
``````m_workItem.Completed([&](Windows::Foundation::IAsyncAction const& asyncInfo, Windows::Foundation::AsyncStatus const& asyncStatus)
{
if (asyncStatus == Windows::Foundation::AsyncStatus::Canceled)
{
return;
}

updateString << std::endl << L"The " << n << L"th prime number is " << nthPrime << std::endl;

// Update the UI thread with the CoreDispatcher.
Windows::ApplicationModel::Core::CoreApplication::MainView().CoreWindow().Dispatcher().RunAsync(
Windows::UI::Core::CoreDispatcherPriority::High,
Windows::UI::Core::DispatchedHandler([&]()
{
}));
});
``````
``````asyncAction.Completed = new AsyncActionCompletedHandler(
(IAsyncAction asyncInfo, AsyncStatus asyncStatus) =>
{
if (asyncStatus == AsyncStatus.Canceled)
{
return;
}

updateString = "\n" + "The " + n + "th prime number is "
+ nthPrime + ".\n";

// Update the UI thread with the CoreDispatcher.
CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(
CoreDispatcherPriority.High,
new DispatchedHandler(()=>
{