How does threading in powershell work?

You can't use threads directly like this, but you can't be blamed for trying since once the whole BCL is lying in front of you it's not entirely silly to expect most of it to work :)

PowerShell runs scriptblocks in pipelines which in turn require runspaces to execute them. I blogged about how to roll your own MT scripts some time ago for v2 ctp3, but the technique (and API) is still the same. The main tools are the [runspacefactory] and [powershell] types. Take a look here:

http://www.nivot.org/2009/01/22/CTP3TheRunspaceFactoryAndPowerShellAccelerators.aspx

The above is the most lightweight way to approach MT scripting. There is background job support in v2 by way of start-job, get-job but I figured you already spotted that and saw that they are fairly heavyweight.

The thing that comes closest to threads and is way more performant than jobs is PowerShell runspaces.

Here is a very basic example:

# the number of threads
$count = 10

# the pool will manage the parallel execution
$pool = [RunspaceFactory]::CreateRunspacePool(1, $count)
$pool.Open()

try {        
    # create and run the jobs to be run in parallel
    $jobs = New-Object object[] $count
    for ($i = 0; $i -lt $count; $i++) {
        $ps = [PowerShell]::Create()
        $ps.RunspacePool = $pool

        # add the script block to run
        [void]$ps.AddScript({
            param($Index)
            Write-Output "Index: $index"
        })

        # optional: add parameters
        [void]$ps.AddParameter("Index", $i)

        # start async execution
        $jobs[$i] = [PSCustomObject]@{
            PowerShell = $ps
            AsyncResult = $ps.BeginInvoke()
        }
    }
    foreach ($job in $jobs) {
        try {
            # wait for completion
            [void]$job.AsyncResult.AsyncWaitHandle.WaitOne()

            # get results
            $job.PowerShell.EndInvoke($job.AsyncResult)
        }
        catch {
            Write-Error $_
        }
        finally {
            $job.AsyncResult.AsyncWaitHandle.Dispose()
            $job.PowerShell.Dispose()
        }
    }
}
finally {
    $pool.Dispose()
}

It also allows you to do more advanced things like

• Throttle the number of parallel runspaces on the pool
• Import functions and variables from the current session

etc.

The answer, now, is quite simple with the ThreadJob module according to Microsoft Docs.

Install-Module -Name ThreadJob -Confirm:$true

$Job1 = Start-ThreadJob `
                -FilePath $YourThreadJob `
                -ArgumentList @("A", "B")
$Job1 | Get-Job
$Job1 | Receive-Job

This is a working code to use System.Threading.Thread in Powershell. I think you can replace [ScriptBlock] by any [System.Object] that has a at least one method, and invoke the method you want in the new ThreadStart. You can also create a custom class with a method and use this class as object.

using assembly System;

$MainThread = [System.Threading.Thread]::CurrentThread | Out-String;
[Console]::Write($MainThread);

#Create a ScriptBlock for the second Thread.

[ScriptBlock]$Scr = {
    [System.Threading.Thread]::Sleep(4000);
    $SecondThread = [System.Threading.Thread]::CurrentThread | Out-String;
    [Console]::Write($SecondThread);
    [Console]::Write($s);
}

#Create the Thread and start it.

[IntPtr]$IntPtr = $Scr.GetType().GetMethod("Invoke").MethodHandle.GetFunctionPointer();

$ThreadStart = New-Object System.Threading.ThreadStart($Scr, $IntPtr);

$Thread = [System.Threading.Thread]::new($ThreadStart);

$Thread.Start();

#Return to the MainThread.

[System.Threading.Thread]::Sleep(500);
Write-Host 1;
[System.Threading.Thread]::Sleep(500);
Write-Host 2;
[System.Threading.Thread]::Sleep(500);
Write-Host 3;
[System.Threading.Thread]::Sleep(500);
Write-Host 4;
Read-Host;