Scribd Logo
Upload

Welcome to Scribd!

  • 46 views

    PrakW9S03 Multithreading Using Posix Thread

    Uploaded by

    Samuel Prastio
    Threads are lightweight processes that can be used to improve application performance through parallelism. While threads share resources like memory and files with other threads in a process, they have their own program counter, registers, and stack. This allows threads to execute concurrently within a process. The POSIX threads (Pthreads) standard supports multithreading in C programs by providing functions like pthread_create() and pthread_join() to manage threads. Key advantages of multithreading over multiprocessing include faster context switching and communication between threads.

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd

    PrakW9S03 Multithreading Using Posix Thread

    Uploaded by

    Samuel Prastio
    46 views4 pages
    Threads are lightweight processes that can be used to improve application performance through parallelism. While threads share resources like memory and files with other threads in a process, they have their own program counter, registers, and stack. This allows threads to execute concurrently within a process. The POSIX threads (Pthreads) standard supports multithreading in C programs by providing functions like pthread_create() and pthread_join() to manage threads. Key advantages of multithreading over multiprocessing include faster context switching and communication between threads.

    Original Title

    PrakW9S03_Multithreading_using_Posix_Thread

    Copyright

    © © All Rights Reserved

    Available Formats

    PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    Threads are lightweight processes that can be used to improve application performance through parallelism. While threads share resources like memory and files with other threads in a process, they have their own program counter, registers, and stack. This allows threads to execute concurrently within a process. The POSIX threads (Pthreads) standard supports multithreading in C programs by providing functions like pthread_create() and pthread_join() to manage threads. Key advantages of multithreading over multiprocessing include faster context switching and communication between threads.

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd
    Download as pdf or txt
    46 views4 pages

    PrakW9S03 Multithreading Using Posix Thread

    Uploaded by

    Samuel Prastio
    Threads are lightweight processes that can be used to improve application performance through parallelism. While threads share resources like memory and files with other threads in a process, they have their own program counter, registers, and stack. This allows threads to execute concurrently within a process. The POSIX threads (Pthreads) standard supports multithreading in C programs by providing functions like pthread_create() and pthread_join() to manage threads. Key advantages of multithreading over multiprocessing include faster context switching and communication between threads.

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd
    Download as pdf or txt
    of 4

    Multithreading Supported by POSIX Threads

    What is a Thread?
    A thread is a single sequence stream within in a process. Because threads have some of the properties of
    processes, they are sometimes called lightweight processes.

    What are the differences between process and thread?


    Threads are not independent of one other like processes as a result threads shares with other threads their
    code section, data section and OS resources like open files and signals. But, like process, a thread has its
    own program counter (PC), a register set, and a stack space.

    Why Multithreading?
    Threads are popular way to improve application through parallelism. For example, in a browser, multiple
    tabs can be different threads. MS word uses multiple threads, one thread to format the text, other thread to
    process inputs, etc.
    Threads operate faster than processes due to following reasons:
    1) Thread creation is much faster.
    2) Context switching between threads is much faster.
    3) Threads can be terminated easily
    4) Communication between threads is faster.

    Can we write multithreading programs in C?


    Unlike Java, multithreading is not supported by the language standard. POSIX Threads (or Pthreads) is a
    POSIX standard for threads. Implementation of pthread is available with gcc compiler.

    A simple C program to demonstrate use of pthread basic functions


    Please note that the below program may compile only with C compilers with pthread library.

    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h> //Header file for sleep()
    #include <pthread.h>

    // A normal C function that is executed as a thread


    // when its name is specified in pthread_create()
    void *myThreadFun(void *vargp)
    {
    sleep(1);
    printf("Printing Horas from Thread \n");
    return NULL;
    }

    int main()
    {
    pthread_t thread_id;
    printf("Before Thread\n");
    pthread_create(&thread_id, NULL, myThreadFun, NULL);
    pthread_join(thread_id, NULL);
    printf("After Thread\n");
    exit(0);
    }

    • In main() we declare a variable called thread_id, which is of type pthread_t, which is an


    integer used to identify the thread in the system. After declaring thread_id, we call
    pthread_create()function to create a thread.
    pthread_create() takes 4 arguments.

    • The first argument is a pointer to thread_id which is set by this function.


    • The second argument specifies attributes. If the value is NULL, then default attributes shall be
    used.
    • The third argument is name of function to be executed for the thread to be created.
    • The fourth argument is used to pass arguments to the function, myThreadFun.
    • The pthread_join()function for threads is the equivalent of wait() for processes. A call to
    pthread_join blocks the calling thread until the thread with identifier equal to the first argument
    terminates.

    How to compile above program?


    To compile a multithreaded program using gcc, we need to link it with the pthreads library. Following is
    the command used to compile the program.

    jansutris10@ubuntu:~/$ gcc multithread.c -lpthread


    jansutris10@ubuntu:~/$ ./a.out
    Before Thread
    Printing Horas from Thread
    After Thread
    jansutris10@ubuntu:~/$

    Program to show multiple threads with global and static variables


    As mentioned above, all threads share data segment. Global and static variables are stored in data
    segment. Therefore, they are shared by all threads. The following example program demonstrates the
    same.
    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <pthread.h>

    // Let us create a global variable to change it in threads


    int g = 0;
    // The function to be executed by all threads
    void *myThreadFun(void *vargp)
    {
    // Store the value argument passed to this thread
    int *myid = (int *)vargp;

    // Let us create a static variable to observe its changes


    static int s = 0;

    // Change static and global variables


    ++s; ++g;

    // Print the argument, static and global variables


    printf("Thread ID: %d, Static: %d, Global: %d\n", *myid, ++s,
    ++g);
    }

    int main()
    {
    int i;
    pthread_t tid;

    // Let us create three threads


    for (i = 0; i < 3; i++)
    pthread_create(&tid, NULL, myThreadFun, (void *)&tid);

    pthread_exit(NULL);
    return 0;
    }

    jansutris10@ubuntu:~/$ gcc multithread.c -lpthread


    jansutris10@ubuntu:~/$ ./a.out
    Thread ID: 3, Static: 2, Global: 2
    Thread ID: 3, Static: 4, Global: 4
    Thread ID: 3, Static: 6, Global: 6
    jansutris10@ubuntu:~/$
    Please note that above is simple example to show how threads work. Accessing a global variable in a
    thread is generally a bad idea. What if thread 2 has priority over thread 1 and thread 1 needs to change the
    variable. In practice, if it is required to access global variable by multiple threads, then they should be
    accessed using a mutex.
    Task:
    Despite of the fact that a thread must execute in process, the process and its associated threads are
    different concept. Please, explore each of topics below.

    • Threads
    • Why Threads?
    • Processes Vs Threads
    • User-Level Threads
    • Kernel-Level Threads
    • Advantages of Threads over Multiple Processes
    • Disadvantages of Threads over Multiprocesses
    • Application that Benefits from Threads
    • Application that cannot benefit from Threads
    • Resources used in Thread creation and Process Creation
    • Context Switch
    • Major Steps of Context Switching
    • Action of Kernel to Context switch among threads
    • Action of kernel to Context switch among processes

    EOF

    You might also like