C++ Multithreading

Multithreading adalah bentuk khusus dari multitasking dan multitasking adalah fitur yang memungkinkan komputer Anda menjalankan dua atau lebih program secara bersamaan. Secara umum, ada dua jenis multitasking:berbasis proses dan berbasis thread.

Multitasking berbasis proses menangani eksekusi program secara bersamaan. Multitasking berbasis thread berurusan dengan eksekusi bersamaan dari bagian-bagian dari program yang sama.

Sebuah program multithreaded berisi dua atau lebih bagian yang dapat berjalan secara bersamaan. Setiap bagian dari program semacam itu disebut utas, dan setiap utas menentukan jalur eksekusi yang terpisah.

C++ tidak mengandung dukungan bawaan untuk aplikasi multithread. Sebaliknya, itu sepenuhnya bergantung pada sistem operasi untuk menyediakan fitur ini.

Tutorial ini mengasumsikan bahwa Anda bekerja pada OS Linux dan kami akan menulis program C++ multi-utas menggunakan POSIX. POSIX Threads, atau Pthreads menyediakan API yang tersedia di banyak sistem POSIX mirip Unix seperti FreeBSD, NetBSD, GNU/Linux, Mac OS X dan Solaris.

Membuat Utas

Rutin berikut digunakan untuk membuat utas POSIX

#include <pthread.h>
pthread_create (thread, attr, start_routine, arg) 

Di sini, pthread_create membuat utas baru dan membuatnya dapat dieksekusi. Rutin ini dapat dipanggil beberapa kali dari mana saja dalam kode Anda. Berikut adalah deskripsi parameter

No.No	Parameter &Deskripsi
1	benang Pengidentifikasi unik dan buram untuk utas baru yang dikembalikan oleh subrutin.
2	attr Objek atribut buram yang dapat digunakan untuk mengatur atribut utas. Anda dapat menentukan objek atribut utas, atau NULL untuk nilai default.
3	mulai_rutin Rutinitas C++ yang akan dijalankan oleh utas setelah dibuat.
4	arg Argumen tunggal yang dapat diteruskan ke start_routine. Itu harus diteruskan dengan referensi sebagai pemeran penunjuk tipe void. NULL dapat digunakan jika tidak ada argumen yang akan diteruskan.

Jumlah maksimum utas yang dapat dibuat oleh suatu proses tergantung pada implementasi. Setelah dibuat, utas adalah rekan, dan dapat membuat utas lainnya. Tidak ada hierarki tersirat atau ketergantungan antar utas.

Mengakhiri Utas

Ada rutinitas berikut yang kami gunakan untuk mengakhiri utas POSIX

#include <pthread.h>
pthread_exit (status) 

Di sini pthread_exit digunakan untuk secara eksplisit keluar dari thread. Biasanya, rutinitas pthread_exit() dipanggil setelah thread menyelesaikan pekerjaannya dan tidak lagi diperlukan.

Jika main() selesai sebelum utas yang dibuatnya, dan keluar dengan pthread_exit(), utas lainnya akan terus dijalankan. Jika tidak, mereka akan dihentikan secara otomatis saat main() selesai.

Contoh

Kode contoh sederhana ini membuat 5 utas dengan rutin pthread_create(). Setiap utas mencetak "Halo Dunia!" pesan, dan kemudian diakhiri dengan panggilan ke pthread_exit().

#include <iostream>
#include <cstdlib>
#include <pthread.h>

using namespace std;

#define NUM_THREADS 5

void *PrintHello(void *threadid) {
   long tid;
   tid = (long)threadid;
   cout << "Hello World! Thread ID, " << tid << endl;
   pthread_exit(NULL);
}

int main () {
   pthread_t threads[NUM_THREADS];
   int rc;
   int i;
   
   for( i = 0; i < NUM_THREADS; i++ ) {
      cout << "main() : creating thread, " << i << endl;
      rc = pthread_create(&threads[i], NULL, PrintHello, (void *)i);
      
      if (rc) {
         cout << "Error:unable to create thread," << rc << endl;
         exit(-1);
      }
   }
   pthread_exit(NULL);
}

Kompilasi program berikut menggunakan library -lpthread sebagai berikut −

$gcc test.cpp -lpthread

Sekarang, jalankan program Anda yang memberikan output berikut

main() : creating thread, 0
main() : creating thread, 1
main() : creating thread, 2
main() : creating thread, 3
main() : creating thread, 4
Hello World! Thread ID, 0
Hello World! Thread ID, 1
Hello World! Thread ID, 2
Hello World! Thread ID, 3
Hello World! Thread ID, 4

Meneruskan Argumen ke Utas

Contoh ini menunjukkan cara meneruskan beberapa argumen melalui suatu struktur. Anda dapat meneruskan tipe data apa pun dalam panggilan balik utas karena mengarah ke void seperti yang dijelaskan dalam contoh berikut −

#include <iostream>
#include <cstdlib>
#include <pthread.h>

using namespace std;

#define NUM_THREADS 5

struct thread_data {
   int  thread_id;
   char *message;
};

void *PrintHello(void *threadarg) {
   struct thread_data *my_data;
   my_data = (struct thread_data *) threadarg;

   cout << "Thread ID : " << my_data->thread_id ;
   cout << " Message : " << my_data->message << endl;

   pthread_exit(NULL);
}

int main () {
   pthread_t threads[NUM_THREADS];
   struct thread_data td[NUM_THREADS];
   int rc;
   int i;

   for( i = 0; i < NUM_THREADS; i++ ) {
      cout <<"main() : creating thread, " << i << endl;
      td[i].thread_id = i;
      td[i].message = "This is message";
      rc = pthread_create(&threads[i], NULL, PrintHello, (void *)&td[i]);
      
      if (rc) {
         cout << "Error:unable to create thread," << rc << endl;
         exit(-1);
      }
   }
   pthread_exit(NULL);
}

Ketika kode di atas dikompilasi dan dieksekusi, menghasilkan hasil sebagai berikut

main() : creating thread, 0
main() : creating thread, 1
main() : creating thread, 2
main() : creating thread, 3
main() : creating thread, 4
Thread ID : 3 Message : This is message
Thread ID : 2 Message : This is message
Thread ID : 0 Message : This is message
Thread ID : 1 Message : This is message
Thread ID : 4 Message : This is message

Menggabungkan dan Melepaskan Utas

Ada dua rutinitas berikut yang dapat kita gunakan untuk menggabungkan atau melepaskan utas

pthread_join (threadid, status) 
pthread_detach (threadid) 

Subrutin pthread_join() memblokir utas panggilan hingga utas 'threadid' yang ditentukan berakhir. Ketika sebuah utas dibuat, salah satu atributnya menentukan apakah itu dapat digabungkan atau dilepaskan. Hanya utas yang dibuat sebagai dapat digabungkan yang dapat digabungkan. Jika sebuah utas dibuat sebagai terlepas, utas itu tidak akan pernah bisa digabungkan.

Contoh ini mendemonstrasikan bagaimana menunggu penyelesaian thread dengan menggunakan rutinitas join Pthread.

#include <iostream>
#include <cstdlib>
#include <pthread.h>
#include <unistd.h>

using namespace std;

#define NUM_THREADS 5

void *wait(void *t) {
   int i;
   long tid;

   tid = (long)t;

   sleep(1);
   cout << "Sleeping in thread " << endl;
   cout << "Thread with id : " << tid << "  ...exiting " << endl;
   pthread_exit(NULL);
}

int main () {
   int rc;
   int i;
   pthread_t threads[NUM_THREADS];
   pthread_attr_t attr;
   void *status;

   // Initialize and set thread joinable
   pthread_attr_init(&attr);
   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);

   for( i = 0; i < NUM_THREADS; i++ ) {
      cout << "main() : creating thread, " << i << endl;
      rc = pthread_create(&threads[i], &attr, wait, (void *)i );
      if (rc) {
         cout << "Error:unable to create thread," << rc << endl;
         exit(-1);
      }
   }

   // free attribute and wait for the other threads
   pthread_attr_destroy(&attr);
   for( i = 0; i < NUM_THREADS; i++ ) {
      rc = pthread_join(threads[i], &status);
      if (rc) {
         cout << "Error:unable to join," << rc << endl;
         exit(-1);
      }
      cout << "Main: completed thread id :" << i ;
      cout << "  exiting with status :" << status << endl;
   }

   cout << "Main: program exiting." << endl;
   pthread_exit(NULL);
}

Ketika kode di atas dikompilasi dan dieksekusi, menghasilkan hasil sebagai berikut

main() : creating thread, 0
main() : creating thread, 1
main() : creating thread, 2
main() : creating thread, 3
main() : creating thread, 4
Sleeping in thread
Thread with id : 0 .... exiting
Sleeping in thread
Thread with id : 1 .... exiting
Sleeping in thread
Thread with id : 2 .... exiting
Sleeping in thread
Thread with id : 3 .... exiting
Sleeping in thread
Thread with id : 4 .... exiting
Main: completed thread id :0  exiting with status :0
Main: completed thread id :1  exiting with status :0
Main: completed thread id :2  exiting with status :0
Main: completed thread id :3  exiting with status :0
Main: completed thread id :4  exiting with status :0
Main: program exiting.