{"id":50983,"date":"2010-03-15T00:01:00","date_gmt":"2010-03-15T00:01:00","guid":{"rendered":"https:\/\/blogs.technet.microsoft.com\/heyscriptingguy\/2010\/03\/15\/hey-scripting-guy-how-can-i-start-receive-and-manage-jobs-in-windows-powershell-2-0\/"},"modified":"2010-03-15T00:01:00","modified_gmt":"2010-03-15T00:01:00","slug":"hey-scripting-guy-how-can-i-start-receive-and-manage-jobs-in-windows-powershell-2-0","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/scripting\/hey-scripting-guy-how-can-i-start-receive-and-manage-jobs-in-windows-powershell-2-0\/","title":{"rendered":"Hey, Scripting Guy! How Can I Start, Receive, and Manage Jobs in Windows PowerShell 2.0?"},"content":{"rendered":"

\"Bookmark<\/a> <\/p>\n

 <\/p>\n

\"Hey,<\/p>\n

Hey, Scripting Guy! I have been thinking about writing a script and using the .NET Framework class system.thread<\/b> to give me the ability to do multiple things at once. I need to perform a query of Active Directory Domain Services (AD DS) that will consume a decent amount of time. While waiting for that query to complete, I could be doing other things in my script. Therefore, I am thinking about implementing the system.thread<\/b> class. If I do it as a function, I can easily re-use the code. What do you think? Is it doable? Have you written such a script yourself? <\/p>\n

— FS<\/p>\n

\n

 <\/p>\n<\/p>\n

\"Hey,Hello FS, <\/p>\n

Microsoft Scripting Guy Ed Wilson here. I am drinking a cup of English Breakfast<\/font><\/a> tea this morning with a stick of cinnamon in it, while listening to Mariza<\/font><\/a> sing Fado<\/font><\/a>. It is a cool, but damp morning in Charlotte, North Carolina, and if I close my eyes, I can almost feel the gentle breezes of the Mediterranean Sea, and smell the pastel de nata<\/font><\/a>. I spent a month in Lisbon<\/font><\/a> a couple years ago while I was there teaching a series of Windows PowerShell classes, and it was a wonderful time. Here is a photograph of an old lighthouse that I snapped during a coastal drive with Luis, my friend and contact in Portugal.<\/p>\n

\"Photograph<\/p>\n

In fact, my trick of putting cinnamon sticks in my tea is something I picked up in Lisbon. Of course, they put the cinnamon stick in their coffee, but I absconded with one of the cinnamon sticks and put it in my tea—<\/span>and it worked out really well. What is cool is that by the end of the week, several of the students switched to the joys of tea, and they were using the cinnamon trick I learned from them that they learned from me. <\/p>\n

FS, to answer directly your threading question: I have not written a script using the system.thread<\/b> class, but I have thought about it. The reason I never got around to it is Windows PowerShell 2.0 introduces the concept of jobs. Using a job, either from the Windows PowerShell console or from within a script, allows you to start a long running procedure and return immediately to doing something else. <\/p>\n

To start a job, you must first enable remoting. This may sound a little strange, but Windows PowerShell uses the remoting infrastructure to run the jobs. To enable remoting use the Enable-PSRemoting<\/b> cmdlet. Keep in mind this command must be run as an administrator, and you will need to right-click the Windows PowerShell icon and choose Run as administrator<\/b>. You will, more than likely, (depending on your User Account Control settings), see a prompt that asks you, “Do you want to allow the following program to make changes to this computer?” The prompt is a little misleading because you have not done anything yet; therefore, Windows PowerShell makes no changes to the system. After Windows PowerShell is running with Administrator rights, use the Enable-PSRemoting<\/b> cmdlet to configure Windows PowerShell for remoting. A prompt will appear, unless you use the –Force<\/b> parameter.<\/p>\n

\"Image<\/p>\n

If you run the Enable-PSRemoting<\/b> cmdlet with the –Force<\/b> parameter, Windows PowerShell displays the output seen in the following image.<\/p>\n

\"Image<\/p>\n

After remoting is configured, you can begin a new Windows PowerShell job by using the Start-Job<\/b> cmdlet. The command is run as a job is placed in a script block, and the jobs are sequentially named Job1<\/b>, Job2<\/b>, and so on. This is shown here:<\/p>\n

PS C:> Start-Job -ScriptBlock { get-process }<\/p>\n

Id              <\/span>Name            <\/span>State      <\/span>HasMoreData     <\/span>Location             <\/span>Command
—   <\/span>           <\/span>—-            <\/span>—–      <\/span>———–     <\/span>——–             <\/span>——-
1               <\/span>Job1            <\/span>Running    <\/span>True            <\/span>localhost             <\/span>get-process<\/p>\n

PS C:><\/p>\n

<\/font><\/span><\/p>\n

The jobs receive job IDs that are also sequentially numbered. The first job created in a Windows PowerShell console is always job ID 1. You can use either the job ID or the job name to obtain information about the job. This is shown here:<\/p>\n

PS C:> Get-Job -Name job1<\/p>\n

Id              <\/span>Name            <\/span>State      <\/span>HasMoreData     <\/span>Location             <\/span>Command
—              <\/span>—-            <\/span>—–      <\/span>———–     <\/span>——–             <\/span>——-
1               <\/span>Job1            <\/span>Completed  <\/span>True            <\/span>localhost             <\/span>get-process<\/p>\n

PS C:> Get-Job -Id 1<\/p>\n

Id              <\/span>Name            <\/span>State      <\/span>HasMoreData     <\/span>Location             <\/span>Command
—              <\/span>—-            <\/span>—–      <\/span>———–     <\/span>——–             <\/span>——-
1               <\/span>Job1            <\/span>Completed  <\/span>True            <\/span>localhost             <\/span>get-process<\/p>\n

PS C:><\/p>\n

<\/font><\/span><\/p>\n

After you see that the job has completed, you can receive the job. The Receive-Job<\/b> cmdlet returns the same information that is returned if a job is not used. The Job1<\/b> output seen here (truncated to save space):<\/p>\n

PS C:> Receive-Job -Name job1<\/p>\n

Handles  <\/span>NPM(K)    <\/span>PM(K)      <\/span>WS(K) VM(M)   <\/span>CPU(s)     <\/span>Id ProcessName
——-  <\/span>——    <\/span>—–      <\/span>—– —–   <\/span>——     <\/span>— ———–
     <\/span>62       <\/span>9     <\/span>1672       <\/span>6032    <\/span>80     <\/span>0.00   <\/span>1408 apdproxy
    <\/span>132       <\/span>9     <\/span>2316       <\/span>5632    <\/span>62            <\/span>1364 atieclxx
    <\/span>122       <\/span>7     <\/span>1716       <\/span>4232    <\/span>32             <\/span>948 atiesrxx
    <\/span>114       <\/span>9    <\/span>14664      <\/span>15372    <\/span>48            <\/span>1492 audiodg
    <\/span>556      <\/span>62    <\/span>53928       <\/span>5368   <\/span>616     <\/span>3.17   <\/span>3408 CCC
     <\/span>58       <\/span>8     <\/span>2960       <\/span>7068    <\/span>70     <\/span>0.19    <\/span>928 conhost
     <\/span>32       <\/span>5     <\/span>1468       <\/span>3468    <\/span>52     <\/span>0.00   <\/span>5068 conhost
    <\/span>784      <\/span>14     <\/span>3284       <\/span>5092    <\/span>56             <\/span>416 csrss
    <\/span>529      <\/span>27     <\/span>2928      <\/span>17260   <\/span>145             <\/span>496 csrss
    <\/span>182      <\/span>13     <\/span>8184      <\/span>11152    <\/span>96     <\/span>0.50   <\/span>2956 DCPSysMgr
    <\/span>135      <\/span>11     <\/span>2880       <\/span>7552    <\/span>56            <\/span>2056 DCPSysMgrSvc
 <\/span>… (truncated output)<\/p>\n

<\/font><\/span><\/p>\n

After a job has been received, that is it—<\/span>the data is gone, unless you save it to a variable. The following code illustrates this concept:<\/p>\n

PS C:> Receive-Job -Name job1
PS C:><\/p>\n

<\/font><\/span><\/p>\n

What can be confusing about this is that the job still exists, and the Get-Job<\/b> cmdlet continues to retrieve information about the job. This is shown here:<\/p>\n

PS C:> Get-Job -Name job1<\/p>\n

Id              <\/span>Name            <\/span>State      <\/span>HasMoreData     <\/span>Location             <\/span>Command
—              <\/span>—-            <\/span>—–      <\/span>———–     <\/span>——–             <\/span>——-
1               <\/span>Job1            <\/span>Completed  <\/span>False           <\/span>localhost             <\/span>get-process<\/p>\n

PS C:><\/p>\n

<\/font><\/span><\/p>\n

As a best practice, use the Remove-Job<\/b> cmdlet to delete remnants of completed jobs when you are finished using the job<\/b> object. This will avoid confusion regarding active jobs, completed jobs, and jobs waiting to be processed. After a job has been removed, the Get-Job<\/b> cmdlet returns an error if you attempt to retrieve information about the job—<\/span>because it no longer exists. This is illustrated here:<\/p>\n

PS C:> Remove-Job -Name job1
PS C:> Get-Job -Name job1
Get-Job : The command cannot find the job because the job1 name was not found. Verify the value of the Name parameter,
and then try the command again.
At line:1 char:8
+ Get-Job <<<<  <\/span>-Name job1
    <\/span>+ CategoryInfo          <\/span>: ObjectNotFound: (job1:String) [Get-Job], PSArgumentException
    <\/span>+ FullyQualifiedErrorId : JobWithSpecifiedNameNotFound,Microsoft.PowerShell.Commands.GetJobCommand<\/p>\n

PS C:><\/p>\n

<\/font><\/span><\/p>\n

When working with the job cmdlets, I like to give the jobs their own name. A job that returns process objects via the Get-Process<\/b> cmdlet might be called getProc<\/b>. A contextual naming scheme works better than trying to keep track of names such as Job1<\/b> or Job2<\/b>. Do not worry about making your job names too long, because you can use wildcard characters to simplify the typing requirement. When you receive the job, make sure you store the returned objects in a variable. This is shown here:<\/p>\n

PS C:> S\ntart-Job -Name getProc -ScriptBlock {get-process}<\/p>\n

Id              <\/span>Name            <\/span>State      <\/span>HasMoreData     <\/span>Location             <\/span>Command
—              <\/span>—-            <\/span>—–      <\/span>———–     <\/span>——–             <\/span>——-
3               <\/span>getProc         <\/span>Running    <\/span>True            <\/span>localhost            <\/span>get-process<\/p>\n

PS C:> Get-Job -Name get*<\/p>\n

Id              <\/span>Name            <\/span>State      <\/span>HasMoreData     <\/span>Location             <\/span>Command
—              <\/span>—-            <\/span>—–      <\/span>———–     <\/span>——–             <\/span>——-
3               <\/span>getProc         <\/span>Completed  <\/span>True            <\/span>localhost            <\/span>get-process<\/p>\n

PS C:> $procObj = Receive-Job -Name get*
PS C:><\/p>\n

<\/font><\/span><\/p>\n

After you have the returned object in a variable, you can use the object with other Windows PowerShell cmdlets. One thing to keep in mind is that the object is deserialized<\/font><\/a>. This is shown here where I use gm<\/b> as an alias for the Get-Member<\/b> cmdlet:<\/p>\n

PS C:> $procObj | gm<\/p>\n

   <\/span>TypeName: Deserialized.System.Diagnostics.Process<\/p>\n

<\/font><\/span><\/p>\n

This means that not all the normal members from the System.Diagnostics.Process<\/b> .NET Framework object are available. The normal methods are shown here (gps<\/b> is an alias for the Get-Process<\/b> cmdlet, gm<\/b> is an alias for Get-Member<\/b>, and –m<\/b> is enough of the –membertype<\/b> parameter to distinguish it on the Windows PowerShell console line):<\/p>\n

PS C:> gps | gm -m method<\/p>\n

   <\/span>TypeName: System.Diagnostics.Process<\/p>\n

Name                     <\/span> <\/span>MemberType Definition
—-                      <\/span>———- ———-
BeginErrorReadLine        <\/span>Method     <\/span>System.Void BeginErrorReadLine()
BeginOutputReadLine       <\/span>Method     <\/span>System.Void BeginOutputReadLine()
CancelErrorRead           <\/span>Method     <\/span>System.Void CancelErrorRead()
CancelOutputRead          <\/span>Method     <\/span>System.Void CancelOutputRead()
Close                     <\/span>Method     <\/span>System.Void Close()
CloseMainWindow           <\/span>Method     <\/span>bool CloseMainWindow()
CreateObjRef              <\/span>Method     <\/span>System.Runtime.Remoting.ObjRef CreateObjRef(type requestedType)
Dispose&<\/span><\/font><\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

    Hey, Scripting Guy! I have been thinking about writing a script and using the .NET Framework class system.thread to give me the ability to do multiple things at once. I need to perform a query of Active Directory Domain Services (AD DS) that will consume a decent amount of time. While waiting for […]<\/p>\n","protected":false},"author":595,"featured_media":87096,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[51,85,3,4,45],"class_list":["post-50983","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-scripting","tag-getting-started","tag-jobs","tag-scripting-guy","tag-scripting-techniques","tag-windows-powershell"],"acf":[],"blog_post_summary":"

    Hey, Scripting Guy! I have been thinking about writing a script and using the .NET Framework class system.thread to give me the ability to do multiple things at once. I need to perform a query of Active Directory Domain Services (AD DS) that will consume a decent amount of time. While waiting for […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/50983","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/users\/595"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/comments?post=50983"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/50983\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/media\/87096"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/media?parent=50983"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/categories?post=50983"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/tags?post=50983"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}