Multithreading di C#: Manfaat, Dasar & Praktik Terbaik

Apa itu Pemrograman Multi-utas

Multithreading adalah konsep dasar dalam rekayasa perangkat lunak. Dalam C#, pemrograman multithread sangat penting bagi pengembang perangkat lunak yang bekerja dengan .NET Framework. Pengembang banyak menggunakan multithreading di C# karena memungkinkan mereka membuat aplikasi yang kompleks dan responsif secara efisien.

Blog ini memberikan ikhtisar c# multithreading sementara, pada saat yang sama, juga melihat bagaimana pemrogram dapat membuat dan mengelola utas dengan mudah. Ini juga mencakup keuntungan menggunakan multithreading dan berbagai model threading yang tersedia di C#.

Manfaat dan Keunggulan Pemrograman Multithreaded

Saat dijalankan secara bersamaan, multithreading meningkatkan efektivitas aplikasi. Manfaat paling umum dari utas C# adalah sebagai berikut:

• Peningkatan kinerja aplikasi: Dengan bantuan multithreading, aplikasi berjalan lebih cepat dengan banyak tugas yang berjalan di ruang yang sama.Secara total, ini mengurangi waktu eksekusi dan memberi jalan untuk banyak tugas.
• Peningkatan throughput: Multitasking dalam C# meningkatkan throughput aplikasi.Ketika dua utas berbeda berjalan secara bersamaan, ini dapat menghemat waktu dan sumber daya.
• Responsif yang ditingkatkan: Dengan bantuan multithreading, pengguna dapat mengakses ujung depan aplikasi saat program berjalan di latar belakang.
• Pemanfaatan sumber daya yang meningkat: Multithreading memungkinkan pengguna untuk mengakses sumber daya sistem dengan lebih efisien.Misalnya, utas dapat berbagi sumber daya seperti file, memori, dan perangkat I/O, membuka jalan menuju efisiensi.
• Pemrograman yang lebih mudah diakses: Multithreading memungkinkan pemrograman yang lebih mudah karena pengguna dapat menulis utas secara mandiri.Ini juga memungkinkan pengguna untuk men-debug dan menguji aplikasi secara terpisah.
• Komunikasi yang dioptimalkan: Sinkronisasi utas memungkinkan komunikasi proses-ke-proses yang lebih baik.Ini dapat digunakan untuk komunikasi yang lebih mudah diakses antar utas.

Pertama, ini memengaruhi objek tunggal yang dapat disinkronkan. Kedua, dapat digunakan dengan kelas System.Threading dan Interlocked.

Konsep Dasar Multithreading di C#

Multithreading memungkinkan pengguna melakukan banyak tugas secara bersamaan dengan bantuan beberapa inti prosesor. Berikut adalah konsep dasar yang digunakan dalam multithreading:

• Utas: Utas adalah unit dasar dalam multithreading yang membantu menjalankan suatu proses.Ini adalah jalur eksekusi dalam program tertentu yang dapat berjalan bersamaan dengan utas lainnya.

Di C#, kita dapat menemukan dua jenis thread, yaitu thread latar depan dan latar belakang. Kelas utas rata-rata menyertakan nama, prioritas, isAlive, ThreadState, Start(), Suspend(), Resume(), dan Join().

• Kumpulan utas: Kumpulan utas adalah utas yang membantu menjalankan tugas.Ini memungkinkan sistem operasi untuk menggunakan kembali utas yang ada dan meminimalkan risiko kemungkinan biaya tambahan.
• Sinkronisasi: Sinkronisasi mengabaikan akses ke utas lain untuk beberapa operasi.Ini adalah proses penting untuk menegakkan integritas data dan mencegah overhead.
• Kebuntuan: Kebuntuan adalah kesalahan yang terjadi saat dua utas berbagi sumber daya dan mencoba melanjutkan tanpa berhasil.Ini dapat menyebabkan sistem membeku atau bahkan menyebabkan waktu tunggu.
• Pemrograman asinkron: Pemrograman asinkron memungkinkan menjalankan banyak tugas di latar belakang sambil membiarkan utas utama berjalan tanpa gangguan.Ini membuka jalan bagi beberapa antarmuka pengguna yang responsif, meningkatkan kinerja aplikasi.

Membuat dan Menjalankan Thread

Membuat dan menjalankan dapat lebih mudah dengan contoh-contoh ini. Contoh multithreading C# diberikan di bawah ini:

menggunakan Sistem;

menggunakan System.Threading;

Program kelas {

static void Main() {

int Indekspekerja = 0;

Thread pekerjaThread = Thread baru(ThreadStart baru(Pekerja));

pekerjaThread.Mulai();

for (int mainIndex = 1; mainIndex <= 10; mainIndex++) {

Console.WriteLine(“Thread utama: {0}”, mainIndex);

Utas.Tidur(200);

}

pekerjaThread.Bergabung();

}

pekerja void statis () {

for (int pekerjaIndex = 1; pekerjaIndex <= 10; pekerjaIndex++) {

Console.WriteLine(“Thread pekerja: {0}”, workerIndex * 2);

Utas.Tidur(200);

}

}

}

Keluaran:

Utas utama: 1

Utas pekerja: 2

Utas utama: 2

Utas pekerja: 4

Utas utama: 3

Utas pekerja: 6

Utas utama: 4

Utas pekerja: 8

Utas utama: 5

Utas pekerja: 10

Utas utama: 6

Utas pekerja: 12

Utas utama: 7

Utas pekerja: 14

Utas utama: 8

Utas pekerja: 16

Utas utama: 9

Utas pekerja: 18

Utas utama: 10

Utas pekerja: 20

Penjelasan: Dalam keluaran ini, kedua utas bekerja secara bersamaan untuk mencetak angka 1 hingga 10 dan 2 hingga 20, yang terakhir digandakan dari indeks loop.Dalam contoh ini, metode C# thread sleep (Thread.Sleep) telah digunakan.

Dengan cara yang sama, kita akan melihat contoh utas C# lainnya menggunakan utas latar depan:

menggunakan Sistem;

menggunakan System.Threading;

Program kelas {

static void Main() {

Utas utas saya = Utas baru (Pekerja);

myThread.Start();

Console.WriteLine(“Utas Utama: Dimulai”);

untuk (int i = 1; i <= 5; i++) {

Console.WriteLine(“Utas Utama: Hitung {0}”, i);

Utas.Tidur(500);

}

Console.WriteLine(“Utas Utama: Berakhir”);

}

pekerja void statis () {

untuk (dalam j = 1; j <= 5; j++) {

Console.WriteLine(“Thread Pekerja: Jumlah {0}”, j * 3);

Utas.Tidur(750);

}

Console.WriteLine(“Thread Pekerja: Berakhir”);

}

}

Keluaran:

Utas Utama: Dimulai

Utas Pekerja: Hitung 3

Utas Utama: Hitung 1

Utas Pekerja: Hitung 6

Utas Utama: Hitungan 2

Utas Pekerja: Hitung 9

Utas Utama: Hitung 3

Utas Pekerja: Hitung 12

Utas Utama: Hitungan 4

Utas Pekerja: Hitung 15

Utas Utama: Hitungan 5

Utas Pekerja: Berakhir

Utas Utama: Berakhir

Penjelasan: Keluaran ini menunjukkan bagaimana kedua utas bekerja secara bersamaan.Karena utas utama dan latar belakang bekerja secara paralel, utas utama mencetak angka dari 1 hingga 5. Utas pekerja mencetak kelipatan 3 hingga 15.

Lihat Kursus Pengembangan Perangkat Lunak di upGrad untuk meningkatkan keterampilan.

Baca Artikel Populer kami yang terkait dengan Pengembangan Perangkat Lunak

Sinkronisasi Benang

Sinkronisasi utas melibatkan koordinasi kolektif dari banyak utas dalam suatu program. Ini memastikan bahwa program dijalankan dalam urutan tertentu yang memberikan akses ke sumber daya bersama.

Dalam C#, ini dilakukan dengan menggunakan primitif sinkronisasi seperti kata kunci kunci, objek sinkronisasi, dan kelas Interlocked.

Contoh sinkronisasi utas C# diberikan di bawah ini:

Menggunakan Sistem;

Menggunakan System.Threading;

kelas TablePrinter

{

PrintTable kosong publik ()

{

kunci (ini)

{

untuk (int i = 3; i <= 8; i++)

{

Utas.Tidur(200);

Console.WriteLine(i*5);

}

}

}

}

Program kelas

{

public static void Main(string[] args)

{

TablePrinter tp = new TablePrinter();

Utas t1 = Utas baru (ThreadStart baru (tp.PrintTable));

Utas t2 = Utas baru (ThreadStart baru (tp.PrintTable));

t1.Mulai();

t2.Mulai();

}

}

Keluaran:

15

20

25

30

35

40

45

50

55

60

Jelajahi Kursus Gratis Pengembangan Perangkat Lunak Kami

Kebuntuan

Kebuntuan dalam multithreading terjadi ketika setidaknya dua atau lebih dua utas bergantung pada sekumpulan sumber daya. Ketika satu utas tumpang tindih dengan rute ke bantuan sementara yang lain mencoba melakukan hal yang sama, itu menjadi jalan buntu.

Misalnya, jika Utas A memiliki kunci pada Sumber Daya 1 dan sedang menunggu untuk mengakses Sumber Daya 2 sementara Utas B menunggu Sumber Daya 1, ini dapat mengakibatkan kebuntuan.

Contoh diberikan di bawah ini:

menggunakan Sistem;

menggunakan System.Threading;

namespace deadlockincsharp

{

kelas publik Contoh

{

objek hanya baca statis firstLock = objek baru();

objek hanya baca statis secondLock = objek baru();

ThreadJob kekosongan statis ()

{

Console.WriteLine(“\t\t\t\tMengunci firstLock”);

kunci (kunci pertama)

{

Console.WriteLine(“\t\t\t\tLocked firstLock”);

Utas.Tidur(1500);

Console.WriteLine(“\t\t\t\tLocking secondLock”);

kunci (Kunci kedua)

{

Console.WriteLine(“\t\t\t\tLocked secondLock”);

}

Console.WriteLine(“\t\t\t\tMelepaskan secondLock”);

}

Console.WriteLine(“\t\t\t\tReleased firstLock”);

}

statis kosong Utama()

{

Thread baru(ThreadStart baru(Pekerjaan Thread)).Mulai();

Utas.Tidur(1000);

Console.WriteLine(“Mengunci kunci kedua”);

kunci (Kunci kedua)

{

Console.WriteLine(“Locked secondLock”);

Console.WriteLine(“Mengunci FirstLock”);

kunci (kunci pertama)

{

Console.WriteLine(“Terkunci firstLock”);

}

Console.WriteLine(“Melepaskan FirstLock”);

}

Console.WriteLine(“Melepaskan secondLock”);

Konsol.Baca();

}

}

}

Keluaran:

Mengunci kunci kedua

Terkunci kunci kedua

Mengunci duluKunci

Dikunci duluKunci

Dirilis firstLock

Dirilis kunci kedua

Keterampilan Pengembangan Perangkat Lunak Dalam Permintaan

Kolam Benang

Kumpulan utas membantu mengelola beberapa utas eksekusi di lingkungan multithread di C#. Ini memastikan bahwa semua utas memiliki akses ke sumber daya yang dikontrol tanpa menimbulkan kebuntuan.

Pengelola kumpulan utas menjaga kumpulan utas, di mana ia bertanggung jawab untuk membuat, menghancurkan, dan menjadwalkan utas.

Berikut adalah contoh kumpulan utas menggunakan TPL (Task Parallel Library):

menggunakan Sistem;

menggunakan System.Threading.Tasks;

Program kelas

{

statis kosong Utama()

{

Tugas<string> tugas = Tugas.Factory.StartNew<string>

(() => DownloadString(“http://www.example.com/”));

string hasil = tugas.Hasil;

Console.WriteLine(hasil);

Konsol.Baca();

}

string statis DownloadString(string uri)

{

menggunakan (var wc = new System.Net.WebClient())

return wc.DownloadString(uri);

}

Keluaran:

Outputnya tergantung pada konten yang tersedia di halaman web. Program ini akan memastikan mengunduh konten dari halaman web dari URL yang ditentukan. Ini kemudian akan mencetaknya.

Pemrograman Asinkron dengan Task Parallel Library (TPL)

Task Parallel Library (TPL) adalah alat yang ampuh untuk menangani APIS dan tipe publik. Ini menangani System.Threading dan System.Threading.Tasks .

.NET Framework 4 menawarkan API tingkat bahasa dan kerangka kerja untuk pengembang yang ingin menulis kode paralel. Dengan bantuan TPL, pemrograman asinkron memungkinkan program berjalan tanpa memblokir utas utama.

Berikut adalah contoh pemrograman asinkron dengan TPL:

Tugas<string> tugas = Tugas.Factory.StartNew<string>(() => {

kembalikan "hasil";

});

string hasil = tugas.Hasil;

async Task MyMethod() {

hasil string = menunggu tugas;

}

Lihatkursus teknologi gratis kami untuk mendapatkan keunggulan dalam persaingan.

Praktik Terbaik untuk Multithreading di C#

Multithreading dapat menghemat waktu dalam hal kinerja dan multitasking. Untuk mengetahui lebih lanjut tentang cara kerja multithreading, Anda dapat memilih Master of Science dalam Ilmu Komputer dari LJMU .

Berikut beberapa praktik terbaik untuk membantu pengguna menghemat waktu dan mencatat efisiensi tertinggi.

• Memanfaatkan koleksi thread-safe: Koleksi bersamaan .NET Framework menyediakan versi thread-safe dari setiap koleksi, yang memudahkan multithreading untuk bekerja secara efisien.Koleksi ini mencakup daftar dan kueri, serta kamus.
• Terapkan sinkronisasi utas: Pengguna dapat dengan cepat menerapkan kunci, monitor, dan semafor karena sifat alat utas.
• Gunakan thread-pooling: Multithreading bisa lebih mudah dan lebih efisien untuk sistem, berkat sebagian besar thread-pooling dilakukan oleh pengguna.Pada saat yang sama, pengguna dapat menggunakannya untuk membuat utas secara otomatis.
• Gunakan penyimpanan lokal-utas: Saat mempraktikkan multithreading, pastikan akses ke sumber daya tertentu dengan mengoptimalkan penyimpanan lokal-utas dan menawarkan akses ke banyak utas.
• Hindari berbagi status yang dapat diubah: Status yang dapat diubah bersama hanya akan menyebabkan bug dan kondisi balapan, yang bisa rumit.Pastikan untuk menghindari keadaan yang dapat berubah dengan biaya berapa pun.
• Gunakan model asinkron: Metode asinkron membantu Anda mengimplementasikan banyak tugas secara paralel tanpa memulainya lagi atau meninggalkannya dalam antrean.
• Hindari kebuntuan: Kebuntuan dapat terjadi saat menjalankan program menggunakan multithreading.Saat menulis program, coba jalankan utas hanya demi satu, hindari kebuntuan.
• Gunakan token pembatalan: Token pembatalan memungkinkan utas diakhiri tanpa masalah dan menghindari kebuntuan.

Jelajahi Kursus Rekayasa Perangkat Lunak Populer kami

Kesimpulan

Multithreading dalam C# tetap menjadi konsep penting dengan model efisiensi tinggi yang sedang bekerja. Ini memberikan cara yang fleksibel bagi pemrogram untuk membagi beban kerja suatu program menjadi beberapa tugas yang berjalan secara bersamaan dan mandiri.

Meskipun multithreading bisa sangat bermanfaat, namun dapat menimbulkan potensi hambatan jika tidak diterapkan dengan hati-hati.

Dengan anggaran global untuk perangkat lunak giat melebihi $856 miliar antara 2009-2023, pengembangan perangkat lunak menjanjikan karier yang cerah bagi pengembang.

Terapkan untuk Bootcamp Pengembangan Perangkat Lunak Full Stack dari upGrad sekarang! Kursus full stack development bisa menjadi batu loncatan bagi developer yang ingin mengeluarkan potensi mereka dalam ilmu komputer.