Cara Mengakhiri Thread dalam Program C ( Contoh pthread_exit )

Di bagian II (Pembuatan dan Identifikasi Thread) dari seri Thread Linux, kita membahas tentang ID thread, cara membandingkan dua ID thread, dan cara membuat thread.

Dalam artikel ini kita akan fokus pada bagaimana sebuah thread diakhiri.

Linux Threads Series:part 1, part 2, part 3 (artikel ini).

Program Contoh Utas C

Jika kita mengambil contoh yang sama seperti yang dibahas pada bagian II dari seri ini :

#include<stdio.h>
#include<string.h>
#include<pthread.h>
#include<stdlib.h>
#include<unistd.h>

pthread_t tid[2];

void* doSomeThing(void *arg)
{
    unsigned long i = 0;
    pthread_t id = pthread_self();

    if(pthread_equal(id,tid[0]))
    {
        printf("\n First thread processing\n");
    }
    else
    {
        printf("\n Second thread processing\n");
    }

    for(i=0; i<(0xFFFFFFFF);i++);

    return NULL;
}

int main(void)
{
    int i = 0;
    int err;

    while(i < 2)
    {
        err = pthread_create(&(tid[i]), NULL, &doSomeThing, NULL);
        if (err != 0)
            printf("\ncan't create thread :[%s]", strerror(err));
        else
            printf("\n Thread created successfully\n");

        i++;
    }

    sleep(5);
    return 0;
}

Apakah Anda mengamati fungsi 'sleep()' yang digunakan? Apakah Anda mendapatkan pertanyaan tentang mengapa sleep() digunakan? Nah jika Anda melakukannya maka Anda berada di tempat yang tepat untuk mendapatkan jawabannya dan jika tidak maka itu akan menjadi bacaan yang bagus.

Jika saya menghapus fungsi sleep() dari kode di atas dan kemudian mencoba mengkompilasi dan menjalankannya, saya melihat output berikut:

$ ./threads
Thread created successfully
First thread processing
Thread created successfully

Tetapi jika saya menjalankannya dengan sleep() diaktifkan maka saya melihat output sebagai  :

$ ./threads
Thread created successfully
First thread processing
Thread created successfully
Second thread processing

Jadi kita melihat bahwa log 'Pemrosesan utas kedua' hilang jika kita menghapus fungsi sleep().

Jadi, mengapa ini terjadi? Nah, ini terjadi karena tepat sebelum utas kedua akan dijadwalkan, utas induk (dari mana dua utas dibuat) menyelesaikan eksekusinya. Ini berarti bahwa utas default tempat fungsi main() sedang berjalan telah selesai dan karenanya proses dihentikan saat main() dikembalikan.

Pemutusan Thread

Seperti yang sudah dibahas di atas bahwa setiap program dimulai dengan setidaknya satu utas yang merupakan utas di mana fungsi main() dijalankan. Jadi masa pakai maksimum setiap utas yang dieksekusi dalam program adalah utas utama. Jadi, jika kita ingin utas utama harus menunggu sampai semua utas lainnya selesai maka ada fungsi pthread_join().

#include <pthread.h>
int pthread_join(pthread_t thread, void **rval_ptr);

Fungsi di atas memastikan bahwa utas induknya tidak berhenti sampai selesai. Fungsi ini dipanggil dari dalam utas induk dan argumen pertama adalah ID utas dari utas yang akan ditunggu dan argumen kedua adalah nilai balik dari utas tempat kita ingin utas induk menunggu. Jika kita tidak tertarik dengan nilai kembalian maka kita dapat mengatur pointer ini menjadi NULL.

Jika kita mengklasifikasikan pada tingkat yang lebih luas, maka kita melihat bahwa sebuah utas dapat diakhiri dengan tiga cara :

1. Jika utas kembali dari rutinitas awal.
2. Jika dibatalkan oleh beberapa utas lainnya. Fungsi yang digunakan di sini adalah pthread_cancel().
3. Jika memanggil fungsi pthread_exit() dari dalam dirinya sendiri.

Fokus di sini adalah pada pthread_exit(). Prototipenya adalah sebagai berikut :

#include <pthread.h>
void pthread_exit(void *rval_ptr);

Jadi kita melihat bahwa fungsi ini hanya menerima satu argumen, yaitu pengembalian dari utas yang memanggil fungsi ini. Nilai kembalian ini diakses oleh utas induk yang menunggu utas ini berakhir. Nilai kembalian dari utas yang diakhiri oleh fungsi pthread_exit() dapat diakses di argumen kedua dari pthread_join yang baru saja dijelaskan di atas.

Contoh Pemutusan Thread C

Mari kita ambil contoh di mana kita menggunakan fungsi yang dibahas di atas :

#include<stdio.h>
#include<string.h>
#include<pthread.h>
#include<stdlib.h>
#include<unistd.h>

pthread_t tid[2];
int ret1,ret2;

void* doSomeThing(void *arg)
{
    unsigned long i = 0;
    pthread_t id = pthread_self();

    for(i=0; i<(0xFFFFFFFF);i++);

    if(pthread_equal(id,tid[0]))
    {
        printf("\n First thread processing done\n");
        ret1  = 100;
        pthread_exit(&ret1);
    }
    else
    {
        printf("\n Second thread processing done\n");
        ret2  = 200;
        pthread_exit(&ret2);
    }

    return NULL;
}

int main(void)
{
    int i = 0;  
    int err;
    int *ptr[2];

    while(i < 2)
    {
        err = pthread_create(&(tid[i]), NULL, &doSomeThing, NULL);
        if (err != 0)
            printf("\ncan't create thread :[%s]", strerror(err));
        else
            printf("\n Thread created successfully\n");

        i++;
    }

    pthread_join(tid[0], (void**)&(ptr[0]));
    pthread_join(tid[1], (void**)&(ptr[1]));

    printf("\n return value from first thread is [%d]\n", *ptr[0]);
    printf("\n return value from second thread is [%d]\n", *ptr[1]);

    return 0;
}

Pada kode di atas :

• Kami membuat dua utas menggunakan pthread_create()
• Fungsi start untuk kedua thread sama yaitu doSomeThing()
• Utas keluar dari fungsi awal menggunakan fungsi pthread_exit() dengan nilai kembalian.
• Dalam fungsi utama setelah utas dibuat, fungsi pthread_join() dipanggil untuk menunggu dua utas selesai.
• Setelah kedua utas selesai, nilai baliknya diakses oleh argumen kedua dalam panggilan pthread_join().

Output dari kode di atas keluar sebagai  :

$ ./threads
Thread created successfully
Thread created successfully
First thread processing done
Second thread processing done
return value from first thread is [100]
return value from second thread is [200]

Jadi kita melihat bahwa kedua utas dijalankan sepenuhnya dan nilai baliknya diakses di fungsi utama.