การใช้งาน Thread ในภาษา C แบบง่ายๆ พร้อมตัวอย่าง

การเขียนโปรแกรมด้วยการใช้งานหลาย ๆ thread เป็นเทคนิคที่พบได้บ่อยในโลกของการพัฒนาซอฟต์แวร์ ทั้งยังช่วยเพิ่มประสิทธิภาพของโปรแกรมให้สามารถทำงานได้พร้อมกันหลายงานในเวลาเดียวกันด้วย ในภาษา C การทำงานกับ threads นั้นไม่ได้ยากเกินไป โดยเราสามารถใช้ไลบรารี POSIX Threads หรือที่รู้จักกันในชื่อ Pthreads ซึ่งเป็นมาตรฐานสำหรับการทำ multi-threading ในระบบปฏิบัติการแบบ UNIX วันนี้เราจะนำเสนอวิธีการใช้งาน thread ในภาษา C แบบง่ายๆ พร้อมกับตัวอย่าง code สามตัวอย่างและอธิบายการทำงาน

จุดประสงค์ของการใช้งาน Thread

ก่อนที่เราจะพูดถึงการใช้งาน thread มาทำความเข้าใจกันก่อนว่า thread คืออะไร? Thread เป็นหน่วยการประมวลผลที่เล็กที่สุดของเป็น process ที่สามารถจัดการและกำหนดให้ทำงานได้ด้วยตัวมันเอง แต่ละ thread สามารถทำงานร่วมกับ thread อื่นๆ ในกระบวนการเดียวกันได้โดยการแชร์แหล่งข้อมูลเดียวกัน เช่น ความจำ ไฟล์ เครือข่าย ฯลฯ

การใช้งาน Threads ในภาษา C

ตัวอย่างโค้ดที่ 1: การสร้าง Thread พื้นฐาน

ลองมาดูตัวอย่างของการสร้าง thread ง่ายๆ ในภาษา C ด้วยไลบรารี Pthreads กันค่ะ:

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

// ฟังก์ชันที่จะรันใน thread
void* doWork(void* arg) {
    // ทำงานของ thread ที่นี่
    printf("Thread ID: %ld, Working...\n", (long)pthread_self());
    return NULL; // เสร็จสิ้นการทำงาน
}

int main() {
    pthread_t thread1, thread2;

    // สร้าง thread
    if(pthread_create(&thread1, NULL, doWork, NULL)) {
        fprintf(stderr, "Error creating thread\n");
        return 1;
    }
    if(pthread_create(&thread2, NULL, doWork, NULL)) {
        fprintf(stderr, "Error creating thread\n");
        return 1;
    }

    // รอให้ thread ทำงานเสร็จ
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    printf("Threads completed\n");

    return 0;
}

ในตัวอย่างนี้ เรามีการสร้าง thread สอง threads โดยใช้ฟังก์ชัน `pthread_create` และโค้ดส่วนที่ทำงานใน thread จะอยู่ในฟังก์ชัน `doWork` ที่ทำการพิมพ์เลข ID ของ thread ที่กำลังทำงานออกมา เมื่อทำงานเสร็จแล้วเราต้องใช้ฟังก์ชัน `pthread_join` เพื่อรอให้ทุก thread ทำงานเสร็จก่อนจะปิดโปรแกรม

ตัวอย่างโค้ดที่ 2: การส่งข้อมูลเข้าไปใน Thread

ต่อไปนี้คือตัวอย่างโค้ดที่แสดงวิธีการส่งค่าเข้าไปยัง thread:

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

// โครงสร้างที่จะเก็บข้อมูลสำหรับแต่ละ thread
typedef struct {
    int id;
    char* message;
} ThreadData;

// ฟังก์ชันที่จะรันใน thread
void* printMessage(void* arg) {
    ThreadData* data = (ThreadData*)arg;
    printf("Thread ID: %d, Message: %s\n", data->id, data->message);
    return NULL;
}

int main() {
    pthread_t thread1, thread2;
    ThreadData data1 = {1, "Hello from 1"};
    ThreadData data2 = {2, "Hello from 2"};

    // สร้าง thread พร้อมส่งข้อมูล
    if(pthread_create(&thread1, NULL, printMessage, (void*)&data1)) {
        fprintf(stderr, "Error creating thread\n");
        return 1;
    }
    if(pthread_create(&thread2, NULL, printMessage, (void*)&data2)) {
        fprintf(stderr, "Error creating thread\n");
        return 1;
    }

    // รอให้ thread ทำงานเสร็จ
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    return 0;
}

ในตัวอย่างนี้ เราสร้างโครงสร้าง `ThreadData` เพื่อเก็บข้อมูลที่เราต้องการให้แต่ละ thread จัดการ จากนั้นเราส่งออบเจกต์นี้เป็นอาร์กิวเมนต์เมื่อสร้าง thread ด้วยฟังก์ชัน `pthread_create` ข้อมูลนี้จะถูก type-cast เป็น `void*` และสามารถ type-cast กลับเพื่อใช้ในฟังก์ชัน `printMessage` ได้

ตัวอย่างโค้ดที่ 3: การใช้ Mutex ในการจัดการการเข้าถึงทรัพยากรร่วม

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

int counter = 0; // ตัวแปรร่วมที่ทุก thread สามารถเข้าถึงได้
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; // Mutex

// ฟังก์ชันที่จะรันใน thread
void* incrementCounter(void* arg) {
    // ใช้ mutex ในการ lock การเข้าถึงตัวแปรร่วม
    pthread_mutex_lock(&lock);
    counter += 1; // เพิ่มค่า counter
    printf("Counter value: %d\n", counter);
    pthread_mutex_unlock(&lock); // ปลดล็อค mutex

    return NULL;
}

int main() {
    pthread_t threads[5];

    // สร้างหลาย ๆ thread
    for(int i = 0; i < 5; i++) {
        if(pthread_create(&threads[i], NULL, incrementCounter, NULL)) {
            fprintf(stderr, "Error creating thread\n");
            return 1;
        }
    }

    // รอให้ทุก ๆ thread ทำงานเสร็จ
    for(int i = 0; i < 5; i++) {
        pthread_join(threads[i], NULL);
    }

    pthread_mutex_destroy(&lock); // ทำลาย mutex เมื่อใช้งานเสร็จแล้ว

    return 0;
}

ในตัวอย่างนี้ เราได้แสดงวิธีการใช้ mutex ในการควบคุมการเข้าถึงตัวแปรร่วม `counter` เพื่อป้องกันปัญหาที่เกิดขึ้นจากสภาวะแข่งขัน (race condition) เมื่อมีหลาย threads พยายามเข้าถึงและปรับเปลี่ยนค่าของตัวแปรเดียวกันในเวลาเดียวกัน เราใช้ `pthread_mutex_lock` ก่อนที่จะแก้ไขค่าของตัวแปร และใช้ `pthread_mutex_unlock` หลังจากทำการแก้ไขเพื่อปล่อย lock เมื่อเราใช้งาน mutex เสร็จแล้ว เราต้องทำลายมันด้วยฟังก์ชัน `pthread_mutex_destroy`

Usecase ของการใช้งาน Thread ในโลกจริง

การใช้ thread มีประโยชน์มากในการพัฒนาโปรแกรมที่ต้องการเพิ่มความเร็วในการประมวลผล หรือต้องการรับมือกับหลายงานพร้อมกัน เช่น การพัฒนาเว็บเซิร์ฟเวอร์ที่ต้องการรับมือกับรีเควสต์จากผู้ใช้หลายคนในเวลาเดียวกัน หรือแม้แต่ในการพัฒนาแอปพลิเคชันเดสก์ทอปที่ต้องการให้ UI ไม่ติดขัดจากการทำงานที่หนักหรือต้องการเวลานาน การใช้ thread ช่วยให้เราสามารถทำงานเหล่านี้ได้โดยไม่รบกวนถึงการทำงานหลักของโปรแกรม

เมื่อคุณเข้าใจและมีทักษะในการใช้งาน thread ในภาษา C แล้ว คุณจะพบว่าเป็นประตูสู่การพัฒนาซอฟต์แวร์ที่มีประสิทธิภาพและเสถียรภาพสูง ที่ EPT หรือ Expert-Programming-Tutor เรามีหลักสูตรที่จะช่วยให้คุณเจาะลึกไปยังความรู้การเขียนโปรแกรมทั้งหมดนี้ พร้อมทั้งการใช้งาน thread และการพัฒนาโปรแกรมอย่างมืออาชีพ หากคุณสนใจที่จะเรียนรู้และพัฒนาทักษะของคุณในด้านนี้ อย่าลืมสมัครเรียนกับเราที่ EPT ที่เรายินดีที่จะนำพาคุณสู่โลกของการพัฒนาซอฟต์แวร์ด้วยมือของคุณเอง!

สร้างโอกาสในการเรียนรู้และปูทางสู่อาชีพโปรแกรมเมอร์ที่รอคุณอยู่ กับ EPT พร้อมกันเสมอ!

หมายเหตุ: ข้อมูลในบทความนี้อาจจะผิด โปรดตรวจสอบความถูกต้องของบทความอีกครั้งหนึ่ง บทความนี้ไม่สามารถนำไปใช้อ้างอิงใด ๆ ได้ ทาง EPT ไม่ขอยืนยันความถูกต้อง และไม่ขอรับผิดชอบต่อความเสียหายใดที่เกิดจากบทความชุดนี้ทั้งทางทรัพย์สิน ร่างกาย หรือจิตใจของผู้อ่านและผู้เกี่ยวข้อง