Bina saluran paip dengan PowerShell 7 dan ForEach-Object -Parallel

Apabila anda mula menggunakan PowerShell, lambat laun anda akan menghadapi masalah yang sama: anda ada banyak objek untuk diproses dalam satu gelung dan prestasi merosot. Pertukaran peti mel, fail pada pelayan, proses merentasi berbilang mesin, contohnya, untuk uruskan berbilang PC dan pelayan...semuanya melalui perancangan dan klasik ForEach-ObjectTetapi, sudah tentu, gelung itu berjalan elemen demi elemen, secara berurutan, dan akan tiba satu titik di mana ia gagal.

Dengan ketibaan PowerShell 7, landskap telah berubah dengan ketara. Kini kita mempunyai saluran paip selari yang boleh digunakan dengan `ForEach-Object -Parallel` dan pendekatan serentak lain yang membolehkan kita menggunakan teras CPU dengan lebih baik dan mengurangkan masa menunggu operasi rangkaian atau cakera. Caranya adalah untuk memahami sepenuhnya apa yang dilakukan oleh setiap pilihan, bila ia sesuai untuk digunakan, dan cara mengehadkan serentak supaya tidak menjejaskan prestasi dan bukannya meningkatkannya.

Gelung dalam PowerShell: titik permulaan

Sebelum mendalami saluran paip selari, adalah berguna untuk memahami apa itu gelung dan bagaimana konstruk PowerShell yang berbeza bertindak. Pada asasnya, gelung ialah cara untuk mengulang satu atau lebih arahan berbilang kali , sama ada untuk bilangan lelaran yang diketahui atau semasa sesuatu syarat dipenuhi. Dalam pentadbiran sistem, ini adalah perkara biasa: daripada menggunakan kebenaran kepada semua pengguna dalam kumpulan kepada merentasi beribu-ribu fail dalam direktori atau memproses peristiwa dengan Get-WinEvent.

PowerShell menawarkan beberapa struktur kawalan klasik seperti for, foreach, while, do-while y do-until, sebagai tambahan kepada cmdlet dan kaedah yang turut membenarkan lelaran, seperti ForEach-Object atau kaedah .ForEach() dalam koleksi. Kesemuanya membentuk asas di mana kita kemudiannya boleh membina logik yang lebih maju, termasuk pelaksanaan selari.

kaedah foreach vs ForEach-Object vs ForEach

Dalam PowerShell, terdapat sedikit kekeliruan kerana kita mempunyai tiga cara berbeza untuk melakukan "foreach", dan ia tidak berfungsi sama. Secara sintaksis, ia serupa, tetapi secara dalaman perkara berubah sedikit, terutamanya mengenai penggunaan memori dan saluran paip.

kata kunci foreach (pernyataan foreach)

Kata kuncinya foreach Ia merupakan binaan gelung "klasik" bagi bahasa tersebut. Muatkan Keseluruhan koleksi disimpan dalam memori dan setiap elemen dilalui secara berurutan.Ia mudah dan sangat pantas apabila anda sudah mempunyai tatasusunan atau koleksi lain dalam memori dan saiznya munasabah. Pemprosesan mengikuti langkah-langkah berikut: pertama, PowerShell menentukan berapa banyak elemen yang ada, kemudian ia menugaskan setiap elemen, satu demi satu, kepada pembolehubah (contohnya, $item) dan melaksanakan blok kod untuk setiap lelaran.

Pendekatan ini sesuai apabila bekerja dengan koleksi dalam memori yang ditakrifkan dengan baik , seperti senarai proses, satu set laluan atau julat nombor. Walau bagaimanapun, ia tidak direka untuk membaca terus daripada saluran paip, dan jika koleksi itu sangat besar, ia boleh menggunakan sejumlah besar memori.

Cmdlet ForEach-Object dalam perancangan

cmdlet itu ForEach-Object Ia berfungsi secara berbeza: ia direka untuk memproses satu objek pada satu masa apabila ia tiba melalui saluran paipDalam erti kata lain, ia tidak perlu memuatkan keseluruhan koleksi dari awal. Ini menjadikannya sangat cekap untuk senario di mana sumber data boleh menjana banyak item (contohnya, Get-ChildItem (pada pokok folder yang besar) atau apabila anda tidak mahu atau tidak boleh menyimpan keseluruhan koleksi dalam memori, atau apabila menggunakan alat luaran seperti Git daripada PowerShell.

Sebagai balasan, Ia mempunyai sedikit beban lampau disebabkan oleh mekanisme saluran paip itu sendiri dan biasanya agak lebih perlahan daripada kata kunci foreach apabila kedua-duanya berfungsi pada koleksi yang sama dalam memori. Walau bagaimanapun, ia memperoleh mata dalam skalabiliti dan kecekapan memori, yang dalam persekitaran pengeluaran biasanya lebih penting daripada memecut beberapa milisaat kelajuan setiap objek.

Kaedah ForEach() dalam koleksi

Sejak PowerShell 5, banyak koleksi seperti tatasusunan dan senarai mendedahkan kaedah tersebut .ForEach()Yang membolehkan Gunakan blok skrip pada setiap elemen dengan cara yang sangat ringkas. Contohnya $array.ForEach({ ... })Kaedah ini berorientasikan objek dan sangat berguna apabila anda ingin merangkai operasi dan berfungsi dengan lancar pada koleksi sedia ada.

Dari segi prestasi, kaedah .ForEach() biasanya lebih cekap daripada cmdlet ForEach-Object Apabila semuanya sudah ada dalam ingatan, kerana anda mengelakkan sebahagian daripada mekanik saluran paip. Walaupun begitu, ia berkongsi batasan asas yang sama: ia berfungsi pada koleksi yang telah diwujudkan, jadi ia bukan alat yang tepat untuk penstriman jumlah data yang besar.

Perbezaan praktikal antara foreach dan ForEach-Object

Dalam amalan seharian, timbul persoalan seperti: “Mengapakah ini skrip kegunaan Get-Mailbox ... | ForEach-Object { ... } dan seorang lagi melakukannya dahulu $Mailboxes = Get-Mailbox ... dan kemudian a foreach ($Mailbox in $Mailboxes)Perbezaan utama ialah dalam kes pertama Semuanya melalui saluran paip, memproses setiap peti mel sebaik sahaja ia tiba, manakala dalam koleksi kedua, keseluruhan koleksi disimpan dalam pembolehubah $Mailboxes dan kemudian anda mengembara.

Pilihannya bukan sekadar soal gaya: jika anda mengendalikan beribu-ribu elemen, penggunaan memori dan pengendalian ralat boleh berbeza-beza dengan ketara, dan dalam kes ini, saluran paip biasanya lebih mesra penggunaan, dengan kos kehilangan prestasi yang sedikit bagi setiap objek.

Jenis gelung lain: for, while, do-while, do-until

Selain ekosistem foreach, PowerShell merangkumi gelung tradisional lain yang masih sangat berguna. Gelung foreach for membolehkan iterasi pada julat nomborMenambah atau mengurangkan indeks sehingga sesuatu syarat tidak lagi dipenuhi adalah idea yang baik. Ia sesuai untuk merentasi tatasusunan mengikut kedudukan, melangkau elemen atau mengaksesnya secara terbalik.

gelung do-while y do-until Mereka menghukum mati mayat sekurang-kurangnya sekali dan kemudian mereka menyemak keadaan: dalam do-while ia diulang selagi ia dipenuhi, dan dalam do-until Ia berulang sehingga syarat dipenuhi. Ini sangat berguna apabila anda memerlukan blok untuk dilaksanakan sekurang-kurangnya sekali, contohnya, apabila meminta data daripada pengguna atau menguji sumber sehingga ia bertindak balas dengan betul.

gelung while menilai keadaan pada mulanyaJika syarat tersebut tidak dipenuhi, ia tidak akan memasuki sistem. Ia adalah pepatah klasik "selagi ini kekal benar" yang kita semua tahu daripada bahasa lain. Dalam tugasan automasi, ia boleh digunakan untuk memantau perkhidmatan, nilai berangka atau keadaan sumber sehingga matlamat dicapai.

Kawalan aliran halus: putus, terus dan kembali

Untuk mengawal dengan lebih baik apa yang berlaku di dalam gelung, kami mempunyai tiga kata kunci utama: break, continue y returnWalaupun kadangkala diabaikan, ia membuat perbezaan yang agak ketara dalam skrip yang kompleks.

Arahan itu break Ia membolehkan anda keluar dari gelung dengan segera. semasa. Ia sangat berguna apabila anda merentasi tatasusunan atau senarai untuk mencari sesuatu yang khusus: sebaik sahaja anda menemuinya, anda akan break dan anda menyelamatkan diri daripada berulang-ulang tanpa perlu.

Perkataan itu continue lompat ke lelaran gelung seterusnyamengabaikan arahan lain dalam lelaran semasa. Ia sering digunakan untuk "menapis" elemen: jika sesuatu tidak memenuhi syarat, anda perlu melakukannya continue dan anda hanya benar-benar memproses apa yang menarik minat anda.

Akhirnya, return bukan sahaja memutuskan gelungIa bukan sahaja mengembalikan nilai daripada fungsi atau skrip, tetapi ia juga mengembalikan nilai. Ia seperti berkata, "Saya telah mendapat apa yang saya cari, inilah dia, dan saya akan pergi." Jika digunakan dengan bijak, ia akan memudahkan logik skrip dengan ketara.

ForEach-Object -Selari dalam PowerShell 7

PowerShell 7 memperkenalkan ciri baharu yang sangat berkuasa: parameter -Parallel cmdlet tersebut ForEach-ObjectFungsi ini, yang pada mulanya ditambah dalam beta 3 versi 7.0, membolehkan pemprosesan beberapa elemen saluran paip sekaligus, tanpa perlu menggunakan modul luaran atau kod kompleks dengan ruang jalan.

Ideanya mudah: cmdlet boleh menjalankan berbilang lelaran secara selari daripada memproses satu objek demi satu objek secara berurutan , setiap satu melaksanakan blok skrip pada elemen koleksi yang berbeza. Dengan cara ini, jika anda mempunyai tugasan bebas (seperti berbilang permintaan HTTP, berbilang salinan fail ke destinasi yang berbeza atau pertanyaan terhadap banyak peti mel), anda boleh mengurangkan keseluruhan masa pelaksanaan dengan ketara.

Kelakuan ForEach-Object sebelum dan selepas -Selari

Tanpa parameter -Parallel, ForEach-Object memproses elemen mengikut urutanSatu demi satu, menunggu setiap blok selesai sebelum beralih ke blok seterusnya. Jika anda melakukan ujian mudah dengan 10 objek dan jeda buatan yang singkat, anda akan melihat bahawa jumlah masa secara praktikalnya adalah jumlah 10 masa individu.

Mengaktifkan -Parallel Kod yang sama boleh dilaksanakan beberapa kali lebih pantas.Ini kerana lelaran diagihkan di antara beberapa subproses. Satu contoh biasa: apa yang mengambil masa kira-kira 10 saat dalam mod berjujukan boleh jatuh kepada kurang daripada 3 saat secara selari, bergantung pada bilangan tugasan serentak dan jenis kerja yang anda lakukan dalam blok tersebut.

Urutan keluar dan bilangan operasi serentak

Ada satu butiran penting: apabila anda menggunakan ForEach-Object -Parallel, The Susunan keputusan tidak lagi dijamin.Item dikembalikan apabila tugasan selesai, bukan mengikut susunan asalnya. Jika logik anda bergantung pada susunan, anda perlu menyusun semula selepas itu atau memasukkan maklumat indeks untuk membinanya semula.

Secara lalai, PowerShell 7 berjalan lima operasi serentakJika anda perlu melaraskan ini, anda menggunakan parameter ThrottleLimitIni menentukan bilangan maksimum elemen yang boleh diproses secara serentak. Mengkonfigurasinya dengan betul adalah kunci untuk mencari keseimbangan yang tepat antara kelajuan dan penggunaan sumber.

Bilakah tidak digalakkan untuk selarikan?

Tidak semua masalah diselesaikan dengan melaksanakan paralelisme secara sembarangan. Dalam beberapa senario, seperti pemindahan fail yang besar melalui rangkaian terhad , menjalankan terlalu banyak operasi selari boleh menepu lebar jalur dan secara paradoks memperlahankan semuanya. Perkara yang sama berlaku untuk API atau perkhidmatan jarak jauh yang mempunyai had permintaan.

Dalam kes lain, seperti operasi yang bergantung sepenuhnya pada susunan pelaksanaan atau yang mengubah suai sumber kongsi yang sama , paralelisme boleh memperkenalkan keadaan perlumbaan atau ketidakkonsistenan. Dalam konteks ini, biasanya lebih baik untuk kekal dengan pendekatan berjujukan atau menggunakan paralelisme yang lebih terperinci dan terkawal.

Pilihan lain untuk berjalan secara selari dalam PowerShell

Plus ForEach-Object -Parallel, PowerShell menawarkan beberapa cara untuk bekerja secara selariKedua-dua versi lama dan dalam cabang 7.x. Setiap satu mempunyai kebaikan dan keburukan, dan penting untuk mengetahuinya bagi memilih alat yang betul.

Mula Kerja: pekerjaan dalam proses bebas

cmdlet itu Start-Job Ia wujud dalam semua versi PowerShell dan dilancarkan berfungsi dalam proses berasingan, setiap satu dengan contoh PowerShellnya sendiriIni memberikan pengasingan yang kuat, tetapi ia mempunyai banyak overhed: mencipta proses baharu, menyirsikan dan menyahsirikan objek kembali, dsb.

Dalam banyak senario, gelung berjujukan boleh berlaku lebih pantas daripada menyalahgunakan Start-Jobterutamanya apabila tugasan pendek atau mengembalikan sejumlah besar data yang kompleks. Tambahan pula, Start-Job tidak termasuk sebagai standard a ThrottleLimitOleh itu, anda perlu menguruskan sendiri berapa banyak kerja yang dijalankan secara serentak.

Start-ThreadJob: kerja berasaskan thread

Modul ini Kerja Utas menyediakan cmdlet Start-ThreadJobyang menggunakan runspace untuk mencipta pekerjaan yang lebih ringan daripada yang terdapat di Start-JobDengan berkongsi proses tersebut, banyak kehilangan maklumat jenis yang disebabkan oleh serialisasi antara proses dapat dielakkan.

Dalam PowerShell 7 dan versi yang lebih baharu, modul ThreadJob telah disertakan, manakala dalam Windows PowerShell 5.1 boleh dipasang daripada Galeri PowerShell. Start-ThreadJob menyokong parameter ThrottleLimitIni membolehkan anda mengawal berapa banyak kerja ini dijalankan serentak, menghalang anda daripada menghabiskan sumber sistem.

Ruang Jalan dan SDK PowerShell

Untuk senario lanjutan, anda boleh bekerja secara langsung dengan ruang nama System.Management.Automation.Runspaces daripada PowerShell SDK. Ini membolehkan anda mencipta logik paralelisme anda sendiri yang sangat halus, mengawal pengurusan ruang jalan, kolam, penyegerakan, dsb. Malah, kedua-duanya ForEach-Object -Parallel sebagai Start-ThreadJob Mereka bergantung secara dalaman pada ruang run.

Pendekatan ini menawarkan fleksibiliti maksimum dan potensi prestasi , tetapi ia juga melibatkan lebih banyak kerumitan dan kod "paip". Dalam banyak kes, cmdlet terbina dalam (ForEach-Object-Parallel dan Start-ThreadJob) memenuhi kebanyakan keperluan, menghapuskan keperluan untuk kerumitan sedemikian.

Aliran kerja dan foreach -Parallel dalam Windows PowerShell

Windows PowerShell 5.1 mempunyai fungsi untuk Aliran kerjaSkrip jenis khas yang direka untuk tugasan jangka panjang, dengan keupayaan untuk menjeda, menyambung semula dan menjalankan secara selari. Dalam aliran kerja, binaan boleh digunakan foreach -ParallelItu laksanakan blok skrip sekali untuk setiap elemen dalam koleksi pada masa yang sama.

Sintaks asas bagi foreach -Parallel ia seperti foreach -Parallel ($item in $collection) { ... }, Dan Ia hanya sah dalam aliran kerjaUnsur-unsur koleksi diproses secara selari, manakala arahan dalam blok tersebut, ia dilaksanakan secara berurutan untuk setiap elemen (walaupun ia juga boleh digabungkan dengan blok) parallel { ... } dalaman).

Walau bagaimanapun, aliran kerja Ia tidak tersedia dalam versi PowerShell 7 atau yang lebih baharuIa juga tidak disyorkan untuk pembangunan baharu. Walaupun begitu, adalah berbaloi untuk memahami sintaks dan konsepnya jika anda mengekalkan skrip legasi yang menggunakannya. foreach -Parallel, kerana kelakuannya berbeza daripada foreach normal dan ForEach-Object -Parallel.

Hadkan keserentakan dengan ThrottleLimit

Hanya kerana sesuatu boleh berjalan secara selari tidak bermakna ia akan menjadi lebih pantas. Malah, aplikasi yang sangat intensif I/O atau skrip ringan boleh mengalami kehilangan prestasi jika terdapat terlalu banyak tugasan serentak , sama ada disebabkan oleh CPU, cakera atau beban rangkaian, atau sekadar overhed mengurus begitu banyak thread sekaligus.

Untuk mengimbangi aspek ini, Start-ThreadJob y ForEach-Object -Parallel Mereka menawarkan parameter ThrottleLimitIni menetapkan bilangan maksimum kerja atau lelaran yang boleh dijalankan serentak. Jika anda cuba melancarkan lebih banyak kerja daripada yang dibenarkan, ia akan diantrekan sehingga satu selesai dan mengosongkan ruang.

Sejak PowerShell 7.1, ForEach-Object -Parallel menggunakan semula ruang larian daripada kolam lalai, dan nilai bagi ThrottleLimit menentukan saiz kolam tersebut. Nilai lalai ialah 5, yang biasanya merupakan titik permulaan yang baik. Terdapat juga pengubah suai untuk mencipta ruang jalan baharu bagi setiap lelaran (UseNewRunspace), tetapi ia hanya berkesan apabila anda memerlukan penebat yang sangat kuat dan menerima lebih banyak beban lampau.

Sebaliknya, cmdlet Start-Job kekurangan ThrottleLimitOleh itu, jika anda tidak mengawalnya secara manual, anda boleh berakhir dengan berpuluh-puluh atau beratus-ratus proses PowerShell berjalan pada masa yang sama, dengan kesan yang sepadan pada prestasi dan memori.

Mengukur prestasi pendekatan yang berbeza

Satu cara yang bijak untuk menentukan model paralelisme yang hendak digunakan ialah Ukur masa pelaksanaan sebenar untuk kes penggunaan andaUntuk melakukan ini, anda boleh menggunakan fungsi seperti Measure-Parallel, yang membandingkan kelajuan pelbagai pendekatan: Start-Job, Start-ThreadJob, ForEach-Object -Parallel y Start-Process.

Fungsi ini mencipta koleksi input simulasi (cth., nama fail ZIP), menjana beberapa "kelompok" atau sesi kerja, dan, untuk setiap pendekatan, mengukur berapa lama masa yang diperlukan untuk memproses bilangan elemen tertentu, dengan saiz kelompok yang dikonfigurasikan oleh BatchSize dan sejumlah karya JobCountIa juga menyesuaikan pendekatan yang tersedia bergantung pada versi PowerShell dan kehadiran atau ketiadaannya Start-ThreadJob.

Dalam, Measure-Parallel konfigurasikan fail boleh laku (seperti cmd.exe o shdengan senarai argumen, dan mentakrifkan hashtable dengan pelaksanaan khusus untuk setiap pendekatan. Measure-Command kira jumlah masa Dengan memproses semua kelompok untuk setiap alternatif, ia membolehkan anda melihat mesej terperinci dengan -Verbose Dan akhirnya, ia mengembalikan objek dengan ringkasan masa supaya ia boleh dibandingkan dengan mudah.

Menjalankan sesuatu seperti Measure-Parallel -Approach All -BatchSize 5 -JobCount 20 -Verbose Pada komputer Windows dengan PowerShell 7.5.1, diperhatikan bahawa, dalam kes khusus itu, Start-Process dapatkan masa yang paling singkatdiikuti dengan rapat oleh ForEach-Object -Parallel y Start-ThreadJobWalaupun Start-Job Ia ternyata pilihan paling perlahan disebabkan oleh kos overhed yang besar yang terlibat dalam melancarkan proses anak PowerShell.

Paralelisme dan gelung foreach "tradisional"

Sesuatu yang sering berlaku dalam praktiknya ialah, semasa anda memindahkan aliran kerja dan skrip lama ke PowerShell 7, anda mula menggantikan ruang jalan manual, modul pihak ketiga seperti PoshRSJob atau Alur Kerja melalui alat yang telah disepadukan, seperti Start-ThreadJob y ForEach-Object -ParallelIni memudahkan kod dan mengurangkan bilangan kebergantungan luaran. Ia juga biasa untuk mengintegrasikan penyelesaian automasi seperti DSC PowerShell.

Terdapat pentadbir yang menggunakan kolam runspace manual tetapi mula mengalami tingkah laku yang tidak stabil (contohnya, skrip yang akan ditamatkan secara rawak dalam persekitaran pengeluaran) dan, berhadapan dengan kesukaran untuk menyahpepijat masalah ini, telah memilih untuk mengurangkan kerumitan dan bergantung pada fungsi selari bersepadu yang telah diuji dan disokong oleh pasukan PowerShell itu sendiri.

Teknik lanjutan dengan foreach: penyarangan, penapisan dan pengendalian ralat

Di sebalik paralelisme, gelung foreach membolehkan anda membina logik yang sangat kaya apabila anda menggabungkan ayat-ayat if, penyarang gelung dan pengendalian pengecualian.

Dalam a foreach Ia adalah perkara biasa untuk digunakan bersyarat if untuk memproses elemen secara berbeza berdasarkan sifatnya. Contohnya, mengulangi semua fail dalam direktori dan hanya bertindak pada fail yang melebihi saiz tertentu, menyalinnya ke lokasi lain, memampatkannya atau memadamkannya jika memenuhi syarat umur tertentu.

Anda juga boleh membuat gelung sarang foreach perenggan menjana kombinasi elemen daripada beberapa koleksiContohnya, senarai parameter ujian, hasil darab Cartesian antara nombor dan huruf, atau traversal data dua dimensi. Dalam kes ini, adalah penting untuk tidak menggunakan semula nama pembolehubah yang sama dalam gelung dalam dan luar untuk mengelakkan kekeliruan dan ralat yang halus.

Berkenaan pengendalian ralat, jika foreach menghadapi pengecualian yang tidak dirawat, Ada kemungkinan seluruh skrip akan berhenti.yang tidak selalunya diingini. Cara biasa untuk mengukuhkan gelung adalah dengan membungkus logik dalaman dalam satu blok. try { ... } catch { ... }Jadi, jika ada masalah untuk item tertentu, anda boleh merekodkan ralat tersebut dan meneruskan koleksi yang lain tanpa menghentikan keseluruhan pelaksanaan.

Kesilapan biasa dan amalan terbaik dengan foreach

Terdapat beberapa kelemahan biasa apabila bekerja dengan gelung foreach dalam PowerShell . Salah satunya ialah menggunakan nama pembolehubah yang sama dalam gelung bersarang, yang menyebabkan nilai dalaman menulis ganti nilai luaran dan menghasilkan hasil yang tidak dapat diramalkan. Penyelesaiannya mudah: gunakan nama yang berbeza untuk setiap tahap penyarang.

Satu lagi kesilapan biasa ialah abuser de break tanpa memikirkannya dengan telitiIni menyebabkan gelung tamat sebelum memproses keseluruhan koleksi, sedangkan tujuannya hanyalah untuk melangkau elemen tertentu. Dalam banyak kes continue Ia lebih sesuai kerana ia membolehkan anda melangkau lelaran tertentu tanpa meninggalkan gelung sepenuhnya.

Anda juga perlu berhati-hati dengan gelung tak terhingga, terutamanya apabila mengubah suai koleksi yang sama yang anda sedang iterasi . Jika anda menambah elemen pada tatasusunan yang sama tanpa sebarang kawalan semasa iterasi, mudah untuk berakhir dengan gelung yang tidak pernah selesai. Teknik yang sangat berguna adalah dengan iterasi pada salinan koleksi asal, membuat pengubahsuaian yang diperlukan pada versi "sebenar".

Bagi amalan terbaik umum, biasanya dinasihatkan menggunakan ForEach-Object untuk data yang tiba melalui saluran paip, memastikan isi gelung semudah yang mungkin dibaca menggunakan fungsi tambahan dan menggunakan lekukan dan komen yang konsisten untuk memudahkan penyelenggaraan skrip dari semasa ke semasa.

Menguasai varian foreach yang berbeza dan pilihan paralelisme mereka dalam PowerShell, daripada ForEach-Object -Parallel y Start-ThreadJob orang dahulu kala sekalipun foreach -Parallel Dalam Aliran Kerja, ia membolehkan anda mereka bentuk skrip yang lebih pantas dan lebih mantap, memilih dalam setiap kes sama ada anda berminat untuk mengutamakan prestasi, memori, susunan output atau kesederhanaan kod, dan bukannya sentiasa mengehadkan diri anda kepada gelung berjujukan tradisional.