Do threads still execute using -asjob with wait-job?

Question

Hello all and good afternoon!

I had a quick question regarding -asjob running with invoke-command. If I run 2 Invoke-Command's using -asjob, does it run simultaneously when I try to receive the ouput? Does this mean wait-job waits till the first job specified is finished running to get the next results?

Write-Host "Searching for PST and OST files.  Please be patient!" -BackgroundColor White -ForegroundColor DarkBlue
$pSTlocation = Invoke-Command -ComputerName localhost -ScriptBlock {Get-Childitem "C:\" -Recurse -Filter "*.pst" -ErrorAction SilentlyContinue | % {Write-Host $_.FullName,$_.lastwritetime}} -AsJob
$OSTlocation = Invoke-Command -ComputerName localhost -ScriptBlock {Get-Childitem "C:\Users\me\APpdata"  -Recurse -Filter "*.ost" -ErrorAction SilentlyContinue | % {Write-Host $_.FullName,$_.lastwritetime} } -AsJob


$pSTlocation | Wait-Job | Receive-Job 
$OSTlocation | Wait-Job | Receive-Job 

Also, another question: can i save the output of the jobs to a variable without it showing to the console? Im trying to make it where it checks if theres any return, and if there is output it, but if theres not do something else.

I tried:

$job1 = $pSTlocation | Wait-Job | Receive-Job 
    if(!$job1){write-host "PST Found: $job1"} else{ "No PST Found"}   

$job2 = $OSTlocation | Wait-Job | Receive-Job 
    if(!$job2){write-host "OST Found: $job2"} else{ "No OST Found"}    

No luck, it outputs the following:

Answer 1

Note: This answer does not directly answer the question - see the other answer for that; instead, it shows a reusable idiom for a waiting for multiple jobs to finish in a non-blocking fashion.

---

The following sample code uses the child-process-based Start-Job cmdlet to create local jobs, but the solution equally works with local thread-based jobs created by Start-ThreadJob as well as jobs based on remotely executing Invoke-Command -ComputerName ... -AsJob commands, as used in the question.

It shows a reusable idiom for a waiting for multiple jobs to finish in a non-blocking fashion that allows for other activity while waiting, along with collecting per-job output in an array.

Here, the output is only collected after each job completes, but note that collecting it piecemeal, as it becomes available, is also an option, using (potentially multiple) Receive-Job calls even before a job finishes.

# Start two jobs, which run in parallel, and store the objects
# representing them in array $jobs.
# Replace the Start-Job calls with your 
#   Invoke-Command -ComputerName ... -AsJob
# calls.
$jobs = (Start-Job { Get-Date; sleep 1 }), 
        (Start-Job { Get-Date '1970-01-01'; sleep 2 })

# Initialize a helper array to keep track of which jobs haven't finished yet.
$remainingJobs = $jobs

# Wait iteratively *without blocking* until any job finishes and receive and 
# output its output, until all jobs have finished.
# Collect all results in $jobResults.
$jobResults = 
  while ($remainingJobs) {

    # Check if at least 1 job has terminated.
    if ($finishedJob = $remainingJobs | Where State -in Completed, Failed, Stopped, Disconnected | Select -First 1) {

      # Output the just-finished job's results as part of custom object
      # that also contains the original command and the 
      # specific termination state.
      [pscustomobject] @{
        Job    = $finishedJob.Command
        State  = $finishedJob.State
        Result = $finishedJob | Receive-Job
      }

      # Remove the just-finished job from the array of remaining ones...
      $remainingJobs = @($remainingJobs) -ne $finishedJob
      # ... and also as a job managed by PowerShell.
      Remove-Job $finishedJob

    } else {

      # Do other things...
      Write-Host . -NoNewline
      Start-Sleep -Milliseconds 500

    }

  }

# Output the jobs' results
$jobResults

Note:

• It's tempting to try $remainingJobs | Wait-Job -Any -Timeout 0 to momentarily check for termination of any one job without blocking execution, but as of PowerShell 7.1 this doesn't work as expected: even already completed jobs are never returned - this appears to be bug, discussed in GitHub issue #14675.

Answer 2

If I run 2 Invoke-Command's using -asjob, does it run simultaneously when I try to receive the output?

Yes, PowerShell jobs always run in parallel, whether they're executing remotely, as in your case (with Invoke-Command -AsJob, assuming that localhost in the question is just a placeholder for the actual name of a different computer), or locally (using Start-Job or Start-ThreadJob).

However, by using (separate) Wait-Job calls, you are synchronously waiting for each jobs to finish (in a fixed sequence, too). That is, each Wait-Job calls blocks further execution until the target job terminates.^[1]

Note, however, that both jobs continue to execute while you're waiting for the first one to finish.

If, instead of waiting in a blocking fashion, you want to perform other operations while you wait for both jobs to finish, you need a different approach, detailed in the the other answer.

can i save the output of the jobs to a variable without it showing to the console?

Yes, but the problem is that in your remotely executing script block ({ ... }) you're mistakenly using Write-Host in an attempt to output data.

Write-Host is typically the wrong tool to use, unless the intent is to write to the display only, bypassing the success output stream and with it the ability to send output to other commands, capture it in a variable, or redirect it to a file. To output a value, use it by itself; e.g., $value instead of Write-Host $value (or use Write-Output $value, though that is rarely needed); see this answer.

Therefore, your attempt to collect the job's output in a variable failed, because the Write-Host output bypassed the success output stream that variable assignments capture and went straight to the host (console):

# Because the job's script block uses Write-Host, its output goes to the *console*,
# and nothing is captured in $job1
$job1 = $pSTlocation | Wait-Job | Receive-Job 

(Incidentally, the command could be simplified to $job1 = $pSTlocation | Receive-Job -Wait).

---

^{[1] Note that Wait-Job has an optional -Timeout parameter, which allows you to limit waiting to at most a given number of seconds and return without output if the target job hasn't finished yet. However, as of PowerShell 7.1, -Timeout 0 for non-blocking polling for whether jobs have finished does not work - see GitHub issue #14675.}