Thread (komputasi)
Dalam ilmu komputer , rangkaian eksekusi adalah urutan instruksi terprogram terkecil yang dapat dikelola secara mandiri oleh penjadwal , yang biasanya merupakan bagian dari sistem operasi . [1] Implementasi thread dan proses berbeda antara sistem operasi, tetapi dalam banyak kasus, thread merupakan komponen dari suatu proses. Beberapa utas dapat berada dalam satu proses, mengeksekusi secara bersamaan dan berbagi sumber daya seperti memori , sementara proses yang berbeda tidak berbagi sumber daya ini. Khususnya, untaian proses berbagi kode yang dapat dieksekusi dan nilai variabelnya pada waktu tertentu.
Sistem dengan prosesor tunggal umumnya mengimplementasikan multithreading dengan mengiris waktu : central processing unit (CPU) beralih di antara rangkaian perangkat lunak yang berbeda. Peralihan konteks ini umumnya terjadi sangat sering dan cukup cepat sehingga pengguna menganggap rangkaian atau tugas berjalan secara paralel. Pada sistem multiprosesor atau multi-core , beberapa utas dapat dijalankan secara paralel , dengan setiap prosesor atau inti mengeksekusi thread terpisah secara bersamaan; pada prosesor atau inti dengan rangkaian perangkat keras , utas perangkat lunak terpisah juga dapat dijalankan secara bersamaan oleh utas perangkat keras terpisah.Sistem vs multiprosesor tunggal
Sejarah
Thread membuat penampilan awal dengan nama "tugas" di Pemrograman Multiprogram OS / 360 dengan Variable Number of Duty (MVT) pada tahun 1967. Saltzer (1966) memuji Victor A. Vyssotsky dengan istilah "utas". [2] Penjadwal proses dari banyak sistem operasi modern secara langsung mendukung pengulangan waktu-pengiris dan multiprosesor, dan kernel sistem operasi memungkinkan pemrogram untuk memanipulasi untaian dengan memaparkan fungsionalitas yang diperlukan melalui antarmuka pemanggilan-sistem . Beberapa penerapan threading disebut utas kernel , sedangkan proses ringan (LWP) adalah jenis khusus utas kernel yang berbagi status dan informasi yang sama. Selain itu, program dapat memiliki thread ruang-pengguna saat menjalin dengan pengatur waktu, sinyal, atau metode lain untuk mengganggu eksekusi mereka sendiri, melakukan semacam pengiris waktu ad hoc .
Threads vs. processes
Thread berbeda dari proses sistem operasi multitasking tradisional dalam hal itu:
- proses biasanya independen, sedangkan untaian ada sebagai subhimpunan suatu proses
- proses membawa lebih banyak informasi status daripada utas, sedangkan banyak utas dalam proses proses yang sama seperti memori dan sumber daya lainnya
- proses memiliki ruang alamat yang terpisah, sedangkan utas berbagi ruang alamat
- proses hanya berinteraksi melalui mekanisme komunikasi antar-proses yang disediakan sistem
- Perpindahan konteks antara utas dalam proses yang sama biasanya lebih cepat daripada peralihan konteks antar proses.
Sistem seperti Windows NT dan OS / 2 dikatakan memiliki benang murah dan proses mahal ; dalam sistem operasi lain tidak ada perbedaan yang begitu besar kecuali biaya saklar ruang alamat yang pada beberapa arsitektur (terutama x86 ) menghasilkan penyangga terjemahan lookaside (TLB) flush.
Single threading
Dalam pemrograman komputer , single-threading adalah pemrosesan satu perintah dalam satu waktu. Kebalikan dari single-threading adalah multithreading.
Dalam analisis formal variabel ' semantik dan proses menyatakan istilah threading tunggal dapat digunakan secara berbeda untuk berarti "backtracking dalam satu thread", yang umum dalam komunitas pemrograman fungsional .
Multithreading
Multithreading terutama ditemukan dalam sistem operasi multitasking. Multithreading adalah pemrograman yang meluas dan model eksekusi yang memungkinkan beberapa utas ada dalam konteks satu proses. Benang ini berbagi sumber daya proses, tetapi dapat dijalankan secara independen. Model pemrograman berulir menyediakan pengembang dengan abstraksi yang berguna dari eksekusi bersamaan. Multithreading juga dapat diterapkan ke satu proses untuk memungkinkan eksekusi paralel pada sistem multiprocessing .
Aplikasi multithreaded memiliki keuntungan sebagai berikut:
- Responsif : multithreading dapat memungkinkan aplikasi tetap responsif terhadap input. Dalam program satu-benang, jika thread eksekusi utama memblokir tugas yang berjalan lama, seluruh aplikasi dapat muncul untuk membekukan. Dengan memindahkan tugas yang berjalan lama ke thread pekerja yang berjalan bersamaan dengan utas eksekusi utama, adalah mungkin bagi aplikasi untuk tetap responsif terhadap input pengguna saat menjalankan tugas di latar belakang. Di sisi lain, dalam banyak kasus multithreading bukan satu-satunya cara untuk menjaga program responsif, dengan non-blocking I / O dan / atau Unix yang tersedia untuk mendapatkan hasil yang sama.
- Eksekusi yang lebih cepat : keuntungan dari program multithread ini memungkinkannya untuk beroperasi lebih cepat pada sistem komputer yang memiliki banyak unit pemrosesan sentral (CPU) atau satu atau lebih prosesor multi-core , atau di seluruh klaster mesin, karena rangkaian program secara alami meminjamkan diri mereka untuk eksekusi paralel, dengan asumsi kemandirian yang cukup (bahwa mereka tidak perlu menunggu satu sama lain).
- Konsumsi sumber daya yang lebih rendah : menggunakan utas, aplikasi dapat melayani beberapa klien secara bersamaan menggunakan sumber daya yang lebih sedikit daripada yang dibutuhkan saat menggunakan banyak salinan proses itu sendiri. Sebagai contoh, server HTTP Apache menggunakan kumpulan thread : sekumpulan benang listener untuk mendengarkan permintaan yang masuk, dan kumpulan thread server untuk memproses permintaan tersebut.
- Pemanfaatan sistem yang lebih baik : sebagai contoh, sistem file yang menggunakan beberapa utas dapat mencapai throughput yang lebih tinggi dan latensi yang lebih rendah karena data dalam medium yang lebih cepat (seperti memori cache) dapat diambil oleh satu utas sementara utas yang lain mengambil data dari media yang lebih lambat (seperti sebagai penyimpanan eksternal) dengan tidak ada benang yang menunggu yang lain selesai.
- Pembagian dan komunikasi yang disederhanakan : tidak seperti proses, yang membutuhkan pesan lewat atau mekanisme memori bersama untuk melakukan komunikasi antar-proses (IPC), utas dapat berkomunikasi melalui data, kode dan file yang sudah mereka bagikan.
- Paralelisasi : aplikasi yang ingin menggunakan sistem multicore atau multi-CPU dapat menggunakan multithreading untuk memisahkan data dan tugas ke dalam subtugas paralel dan membiarkan arsitektur yang mendasari mengatur bagaimana thread berjalan, baik secara bersamaan pada satu inti atau secara paralel pada beberapa core. Lingkungan komputasi GPU seperti CUDA dan OpenCL menggunakan model multithreading di mana puluhan hingga ratusan thread berjalan secara paralel di seluruh data pada sejumlah besar core .
Multithreading memiliki kekurangan berikut:
- Sinkronisasi : karena benang berbagi ruang alamat yang sama, programmer harus berhati-hati untuk menghindari kondisi balapan dan perilaku non-intuitif lainnya. Agar data dapat dimanipulasi dengan benar, untaian akan sering harus bertemu tepat waktu untuk memproses data dalam urutan yang benar. Thread mungkin juga memerlukan operasi yang saling eksklusif (sering diimplementasikan menggunakan mutex ) untuk mencegah data umum dari dimodifikasi atau dibaca secara simultan sementara dalam proses yang dimodifikasi. Penggunaan yang sembrono dari primitif semacam itu dapat menyebabkan kebuntuan , livelock atau ras melebihi sumber daya.
- Thread menabrak sebuah proses : operasi ilegal yang dilakukan oleh thread menabrak seluruh proses; Oleh karena itu, satu kesalahan salah satu benang dapat mengganggu pemrosesan semua utas lainnya dalam aplikasi.
Menjadwalkan
Sistem operasi menjadwalkan benang baik secara preemptif atau kooperatif. Pada sistem operasi multi-pengguna , multithreading preemptif adalah pendekatan yang lebih banyak digunakan untuk kontrol berbutir lebih halus atas waktu eksekusi melalui pengalihan konteks . Namun, penjadwalan preemptive mungkin konteks beralih benang di saat-saat yang tidak diantisipasi oleh programmer sehingga menyebabkan konvoi kunci , inversi prioritas , atau efek samping lainnya. Sebaliknya, multithreading kooperatif bergantung pada utas untuk melepaskan kontrol eksekusi sehingga memastikan bahwa thread berjalan sampai selesai . Hal ini dapat menimbulkan masalah jika blok thread multitasking yang kooperatif dengan menunggu sumber daya atau jika ia menghabiskan thread lain dengan tidak menghasilkan kontrol eksekusi selama komputasi intensif.
Sampai awal tahun 2000an, kebanyakan komputer desktop hanya memiliki satu CPU single-core, tanpa dukungan untuk rangkaian perangkat keras , meskipun utas masih digunakan pada komputer tersebut karena perpindahan antar utas umumnya masih lebih cepat daripada switch konteks proses-penuh. Pada tahun 2002, Intel menambahkan dukungan untuk multithreading secara bersamaan ke prosesor Pentium 4 , dengan nama hyper-threading ; pada tahun 2005, mereka memperkenalkan prosesor Pentium D dual-core dan AMD memperkenalkan prosesor dual-core Athlon 64 X2 .
Prosesor dalam embedded system , yang memiliki persyaratan lebih tinggi untuk perilaku real-time , mungkin mendukung multithreading dengan mengurangi waktu switch-thread, mungkin dengan mengalokasikan file register khusus untuk setiap thread daripada menyimpan / memulihkan file register umum.
Proses, utas kernel, utas pengguna, dan serat
Penjadwalan dapat dilakukan pada level kernel atau level pengguna, dan multitasking dapat dilakukan secara preemptif atau kooperatif. Ini menghasilkan berbagai konsep terkait.
Pada tingkat kernel, sebuah proses berisi satu atau lebih kernel thread , yang berbagi sumber daya proses, seperti memori dan menangani file - proses adalah unit sumber daya, sementara utas adalah unit penjadwalan dan eksekusi. Penjadwalan kernel secara seragam dilakukan secara preemptif atau, lebih jarang, secara kooperatif. Pada tingkat pengguna, proses seperti sistem runtime dapat menjadwalkan beberapa utas eksekusi. Jika ini tidak berbagi data, seperti dalam Erlang, mereka biasanya secara analog disebut proses, sementara jika mereka berbagi data mereka biasanya disebut (pengguna) untaian , terutama jika dijadwalkan secara preemptive. Benang pengguna terjadwal secara kooperatif dikenal sebagai serat ; proses yang berbeda dapat menjadwalkan thread pengguna secara berbeda. Untaian pengguna dapat dijalankan oleh utas kernel dengan berbagai cara (satu-ke-satu, banyak-ke-satu, banyak-ke-banyak). Istilah " proses ringan " beragam mengacu pada utas pengguna atau mekanisme kernel untuk menjadwalkan utas pengguna ke utas kernel.
Sebuah proses adalah unit "berat" penjadwalan kernel, karena membuat, menghancurkan, dan beralih proses relatif mahal. Memproses sumber daya sendiri yang dialokasikan oleh sistem operasi. Sumber daya termasuk memori (untuk kode dan data), menangani file , soket, gagang perangkat, jendela, dan blok kontrol proses . Proses diisolasi oleh isolasi proses , dan tidak berbagi ruang alamat atau sumber daya file kecuali melalui metode eksplisit seperti menangani file yang diwariskan atau segmen memori bersama, atau memetakan file yang sama dengan cara yang dibagi - lihat komunikasi interprocess . Membuat atau menghancurkan suatu proses relatif mahal, karena sumber daya harus diperoleh atau dilepaskan. Proses biasanya multitasked preemptively, dan proses switching relatif mahal, di luar biaya dasar switching konteks , karena masalah seperti flushing cache. [Sebuah]
Utas kernel adalah unit penjadwalan kernel "ringan". Setidaknya satu utas kernel ada dalam setiap proses. Jika beberapa utas kernel ada dalam suatu proses, maka mereka berbagi memori dan sumber daya file yang sama. Kernel thread secara preemptive multitasked jika penjadwal proses sistem operasi adalah preemptif. Kernel thread tidak memiliki sumber daya kecuali tumpukan , salinan register termasuk penghitung program , dan penyimpanan lokal-thread (jika ada), dan dengan demikian relatif murah untuk dibuat dan dihancurkan. Peralihan benang juga relatif murah: ia memerlukan sakelar konteks (menyimpan dan memulihkan register dan penunjuk tumpukan), tetapi tidak mengubah memori virtual dan dengan demikian ramah cache (meninggalkan TLB valid). Kernel dapat menetapkan satu utas ke setiap inti logis dalam suatu sistem (karena setiap prosesor membagi dirinya menjadi beberapa inti logis jika mendukung multithreading, atau hanya mendukung satu inti logis per inti fisik jika tidak), dan dapat menukar untaian yang diblokir. Namun, utas kernel membutuhkan waktu lebih lama daripada untaian pengguna untuk ditukarkan.
Thread kadang-kadang diterapkan di pustaka userspace , yang disebut sebagai thread pengguna . Kernel tidak menyadari mereka, sehingga mereka dikelola dan dijadwalkan di userspace . Beberapa implementasi mendasarkan utas pengguna mereka di atas beberapa utas kernel, untuk memperoleh manfaat dari mesin multi-prosesor ( model M: N ). Dalam artikel ini, istilah "thread" (tanpa kernel atau kualifikasi pengguna) default untuk merujuk ke utas kernel. Untaian pengguna seperti yang diterapkan oleh mesin virtual juga disebut utas hijau . Untaian pengguna umumnya cepat dibuat dan dikelola, tetapi tidak dapat memanfaatkan multithreading atau multiprocessing, dan akan diblokir jika semua utas kernel terkait diblokir bahkan jika ada beberapa thread pengguna yang siap dijalankan.
Serat adalah unit penjadwalan yang lebih ringan yang terjadwal secara kooperatif : serat yang sedang berjalan harus secara eksplisit " menghasilkan " untuk memungkinkan serat lain untuk berjalan, yang membuat implementasinya jauh lebih mudah daripada kernel atau utas pengguna . Serat dapat dijadwalkan untuk berjalan di semua thread dalam proses yang sama. Ini memungkinkan aplikasi untuk mendapatkan peningkatan kinerja dengan mengatur penjadwalan sendiri, daripada mengandalkan penjadwal kernel (yang mungkin tidak disetel untuk aplikasi). Lingkungan pemrograman paralel seperti OpenMP biasanya melaksanakan tugas mereka melalui serat. Berkaitan erat dengan serat adalah coroutines , dengan perbedaan bahwa coroutines adalah konstruksi tingkat bahasa, sedangkan serat adalah membangun tingkat sistem.
Masalah benang dan serat
Concurrency dan struktur data
Benang dalam proses yang sama berbagi ruang alamat yang sama. Hal ini memungkinkan kode berjalan secara bersamaan untuk pasangan dengan erat dan nyaman bertukar data tanpa overhead atau kompleksitas IPC . Ketika dibagi antar utas, bagaimanapun, bahkan struktur data sederhana menjadi rentan terhadap kondisi balapan jika mereka membutuhkan lebih dari satu instruksi CPU untuk memperbarui: dua utas mungkin berakhir dengan mencoba untuk memperbarui struktur data pada saat yang sama dan menemukannya secara tak terduga berubah di bawah kaki. Bug yang disebabkan oleh kondisi balapan bisa sangat sulit untuk mereproduksi dan mengisolasi.
Untuk mencegah hal ini, threading antarmuka pemrograman aplikasi (API) menawarkan primitif sinkronisasi seperti mutex untuk mengunci struktur data terhadap akses bersamaan. Pada sistem uniprocessor, benang yang masuk ke dalam mutex yang terkunci harus tidur dan karenanya memicu saklar konteks. Pada sistem multi-prosesor, utas dapat memilih polling mutex dalam spinlock . Kedua hal ini dapat menggetarkan kinerja dan memaksa prosesor dalam sistem symmetric multiprocessing (SMP) untuk bersaing untuk bus memori, terutama jika granularity penguncian baik-baik saja.
I / O dan penjadwalan
Benang pengguna atau implementasi serat biasanya sepenuhnya di ruang pengguna . Akibatnya, pengalihan konteks antara utas pengguna atau serat dalam proses yang sama sangat efisien karena tidak memerlukan interaksi dengan kernel sama sekali: sakelar konteks dapat dilakukan dengan menyimpan register CPU secara lokal yang digunakan oleh utas pengguna yang sedang dieksekusi atau serat dan kemudian memuat register yang diperlukan oleh utas pengguna atau serat untuk dieksekusi. Karena penjadwalan terjadi di userspace, kebijakan penjadwalan dapat lebih mudah disesuaikan dengan persyaratan beban kerja program.
Namun, penggunaan sistem pemblokiran panggilan di thread pengguna (sebagai lawan utas kernel) atau serat dapat menjadi masalah. Jika pengguna thread atau serat melakukan panggilan sistem yang memblokir, pengguna lain benang dan serat dalam proses tidak dapat dijalankan sampai sistem panggilan kembali. Contoh khas masalah ini adalah ketika melakukan I / O: sebagian besar program ditulis untuk melakukan I / O secara bersamaan. Ketika operasi I / O dimulai, panggilan sistem dibuat, dan tidak kembali sampai operasi I / O selesai. Pada periode intervening, seluruh proses "diblokir" oleh kernel dan tidak dapat berjalan, yang membintangi thread pengguna dan serat lain dalam proses yang sama dari eksekusi.
Solusi umum untuk masalah ini adalah menyediakan I / O API yang mengimplementasikan antarmuka sinkron dengan menggunakan non-blocking I / O internal, dan menjadwalkan thread pengguna lain atau serat saat operasi I / O sedang berlangsung. Solusi serupa dapat disediakan untuk panggilan sistem pemblokiran lainnya. Atau, program dapat ditulis untuk menghindari penggunaan I / O sinkron atau panggilan sistem pemblokiran lainnya.
SunOS 4.x menerapkan proses ringan atau LWP. NetBSD 2.x +, dan DragonFly BSD mengimplementasikan LWPs sebagai utas kernel (model 1: 1). SunOS 5.2 melalui SunOS 5.8 serta NetBSD 2 ke NetBSD 4 mengimplementasikan model dua tingkat, multipleksing satu atau lebih thread tingkat pengguna pada setiap utas kernel (M: N model). SunOS 5.9 dan yang lebih baru, serta NetBSD 5 menghilangkan dukungan utas pengguna, kembali ke model 1: 1. FreeBSD 5 menerapkan model M: N. FreeBSD 6 didukung baik 1: 1 dan M: N, pengguna dapat memilih yang mana yang harus digunakan dengan program yang diberikan menggunakan /etc/libmap.conf. Dimulai dengan FreeBSD 7, 1: 1 menjadi default. FreeBSD 8 tidak lagi mendukung model M: N.
Penggunaan utas kernel menyederhanakan kode pengguna dengan memindahkan beberapa aspek yang paling kompleks dari threading ke kernel. Program tidak perlu menjadwalkan utas atau secara eksplisit menghasilkan prosesor. Kode pengguna dapat ditulis dalam gaya prosedural yang sudah dikenal, termasuk panggilan ke API pemblokiran, tanpa melaparkan utas lainnya. Namun, pengeditan kernel dapat memaksa sebuah konteks beralih antar utas kapan saja, dan dengan demikian memaparkan bahaya ras dan bug konkuren yang sebaliknya akan tersembunyi. Pada sistem SMP, ini semakin diperburuk karena utas kernel dapat secara harfiah dieksekusi pada prosesor terpisah secara paralel.
Model
1: 1 (pengedian tingkat kernel)
Thread yang dibuat oleh pengguna dalam korespondensi 1: 1 dengan entitas terjadwal dalam kernel [10] adalah implementasi threading paling sederhana. OS / 2 dan Win32 menggunakan pendekatan ini dari awal, sementara di Linux C library biasa mengimplementasikan pendekatan ini (melalui NPTL atau LinuxThreads yang lebih lama). Pendekatan ini juga digunakan oleh Solaris , NetBSD , FreeBSD , macOS , dan iOS .
N: 1 ( tingkat pengguna)
Model N: 1 menyiratkan bahwa semua thread tingkat aplikasi memetakan ke satu entitas terjadwal tingkat kernel; [10] kernel tidak memiliki pengetahuan tentang utas aplikasi. Dengan pendekatan ini, pengalihan konteks dapat dilakukan dengan sangat cepat dan, di samping itu, dapat diterapkan bahkan pada kernel sederhana yang tidak mendukung threading. Salah satu kelemahan utama, bagaimanapun, adalah bahwa hal itu tidak dapat mengambil keuntungan dari akselerasi perangkat keras pada prosesor multithread atau komputer multi-prosesor : tidak pernah ada lebih dari satu thread yang dijadwalkan pada saat yang bersamaan. [10] Sebagai contoh: Jika salah satu untaian perlu menjalankan permintaan I / O, seluruh proses diblokir dan keunggulan penguliran tidak dapat digunakan. The GNU Portable Threads menggunakan tingkat pengguna threading, seperti halnya Benang Negara .
M: N (threading hibrida)
M: N memetakan beberapa nomor M utas aplikasi ke sejumlah N beberapa entitas kernel, atau "virtual processors." Ini adalah kompromi antara tingkat kernel ("1: 1") dan tingkat pengguna ("N: 1") threading. Secara umum, sistem pengguliran "M: N" lebih rumit untuk diterapkan daripada kernel atau utas pengguna, karena perubahan pada kernel dan kode ruang-pengguna diperlukan. Dalam implementasi M: N, pustaka threading bertanggung jawab untuk menjadwalkan utas pengguna pada entitas terjadwal yang tersedia; ini membuat pengalihan konteks utas sangat cepat, karena menghindari panggilan sistem. Namun, ini meningkatkan kompleksitas dan kemungkinan inversi prioritas , serta penjadwalan suboptimal tanpa koordinasi (dan mahal) yang ekstensif antara penjadwal userland dan penjadwal kernel.
Contoh implementasi hibrida
- Aktivasi scheduler yang digunakan oleh implementasi pustaka POSIX asli NetBSD (model M: N sebagai lawan dari kernel 1: 1 atau model implementasi userspace)
- Proses ringan yang digunakan oleh versi lama dari sistem operasi Solaris
- Marcel dari proyek PM2 .
- OS untuk Tera Cray MTA-2
- Microsoft Windows 7 penjadwalan mode pengguna
- The Glasgow Haskell Compiler (GHC) untuk bahasa Haskell menggunakan benang ringan yang dijadwalkan pada benang sistem operasi.
Contoh penerapan serat
Serat dapat diimplementasikan tanpa dukungan sistem operasi, meskipun beberapa sistem operasi atau pustaka memberikan dukungan eksplisit untuk mereka.
- Win32 memasok fiber API [13] (Windows NT 3.51 SP3 dan yang lebih baru)
- Ruby sebagai benang Hijau
- Netscape Portable Runtime (termasuk implementasi serat ruang pengguna)
- rusuk2
Dukungan bahasa pemrograman
IBM PL / I (F) termasuk dukungan untuk multithreading (disebut multitasking ) pada akhir 1960-an, dan ini dilanjutkan di Optimizing Compiler dan versi yang lebih baru. Kompilator IBM Enterprise PL / I memperkenalkan API "thread" model baru. Versi keduanya bukan bagian dari standar PL / I.
Banyak bahasa pemrograman mendukung penguliran dalam kapasitas tertentu. Banyak penerapan C dan C ++ mendukung penguliran, dan memberikan akses ke API threading asli dari sistem operasi. Beberapa bahasa pemrograman tingkat tinggi (dan biasanya cross-platform ), seperti Java , Python , dan .NET Framework languages, mengekspos threading ke pengembang sementara mengabstraksi perbedaan platform tertentu dalam penerapan threading dalam runtime. Beberapa bahasa pemrograman dan ekstensi bahasa lainnya juga mencoba untuk mengaburkan konsep konkurensi dan threading dari pengembang sepenuhnya ( Cilk , OpenMP , Message Passing Interface (MPI)). Beberapa bahasa dirancang untuk paralelisme sekuensial (terutama menggunakan GPU), tanpa memerlukan konkurensi atau utas ( Ateji PX , CUDA ).
Beberapa bahasa pemrograman yang diinterpretasikan memiliki implementasi (misalnya, Ruby MRI untuk Ruby, CPython untuk Python) yang mendukung threading dan konkurensi tetapi tidak paralel pelaksanaan thread, karena kunci juru bahasa global (GIL). GIL adalah kunci eksklusi mutual yang dipegang oleh interpreter yang dapat mencegah interpreter menafsirkan secara bersamaan kode aplikasi pada dua atau lebih benang sekaligus, yang secara efektif membatasi paralelisme pada beberapa sistem inti. Ini membatasi kinerja sebagian besar untuk thread yang terikat prosesor, yang membutuhkan prosesor, dan tidak banyak untuk I / O-terikat atau yang terikat jaringan.
Implementasi lain dari bahasa pemrograman yang diinterpretasikan, seperti Tcl menggunakan ekstensi Thread, hindari batas GIL dengan menggunakan model Apartemen di mana data dan kode harus secara eksplisit "dibagikan" di antara untaian. Di Tcl setiap utas memiliki satu atau lebih juru bahasa.
Bahasa deskripsi perangkat keras pemrograman acara-driven seperti Verilog memiliki model threading yang berbeda yang mendukung sejumlah besar benang (untuk pemodelan perangkat keras).
Praktis multithreading
Antarmuka standar untuk implementasi thread adalah POSIX Threads (Pthreads), yang merupakan seperangkat panggilan perpustakaan fungsi-C. Vendor OS bebas untuk mengimplementasikan antarmuka yang diinginkan, tetapi pengembang aplikasi harus dapat menggunakan antarmuka yang sama di berbagai platform. Sebagian besar platform Unix termasuk dukungan Linux Pthreads. Microsoft Windows memiliki seperangkat fungsi utasnya sendiri dalam antarmuka process.h untuk multithreading, seperti beginthread . Java menyediakan antarmuka standar lain atas sistem operasi host menggunakan Java concurrency library java.util.concurrent.
Pustaka multithreading menyediakan pemanggilan fungsi untuk membuat utas baru, yang mengambil fungsi sebagai parameter. Benang konkuren kemudian dibuat yang mulai menjalankan fungsi berlalu dan berakhir ketika fungsi kembali. Pustaka thread juga menawarkan fungsi sinkronisasi yang memungkinkan untuk menerapkan kondisi ras -Memberi fungsi multithreading gratis menggunakan mutex , variabel kondisi, bagian penting , semaphores , monitor dan primitif sinkronisasi lainnya.
Paradigma lain dari penggunaan thread adalah thread pool di mana sejumlah thread yang dibuat saat startup yang kemudian menunggu tugas yang akan ditugaskan. Ketika tugas baru tiba, tugas itu bangun, menyelesaikan tugas dan kembali menunggu. Hal ini menghindari pembuatan ulir dan penghancuran fungsi yang relatif mahal untuk setiap tugas yang dilakukan dan mengambil alih manajemen thread dari tangan pengembang aplikasi dan meninggalkannya ke pustaka atau sistem operasi yang lebih sesuai untuk mengoptimalkan pengelolaan thread. Misalnya, kerangka kerja seperti Grand Central Dispatch dan Threading Building Blocks .
Dalam model pemrograman seperti CUDA yang dirancang untuk komputasi paralel data , rangkaian untaian menjalankan kode yang sama secara paralel hanya menggunakan IDnya untuk menemukan datanya dalam memori. Intinya, aplikasi harus dirancang agar setiap thread melakukan operasi yang sama pada segmen memori yang berbeda sehingga mereka dapat beroperasi secara paralel dan menggunakan arsitektur GPU.
Sumber :
Tidak ada komentar:
Posting Komentar