{"id":3279,"date":"2022-10-26T16:06:54","date_gmt":"2022-10-26T10:36:54","guid":{"rendered":"https:\/\/cthecosmos.com\/?p=3279"},"modified":"2022-10-26T16:06:54","modified_gmt":"2022-10-26T10:36:54","slug":"threads","status":"publish","type":"post","link":"https:\/\/cthecosmos.com\/?p=3279","title":{"rendered":"THREADS"},"content":{"rendered":"\n
\n
\n

Let’s talk about Threads

What is a Thread?

– A Thread is a path of execution within a process. A thread is also known as a lightweight process. The idea is to achieve parallelism by dividing a process into multiple threads.

-A thread is an active entity as it executes as a part of a process. It goes through various stages in its life cycle. A thread is born\/created, started, runs and dies.

-A thread has a parent\u2019s process control block (PCB), its own thread control block and stack and common address space.

-Threads within the process run in shared memory space. Thread switching does not need to interact with the operating system, hence threads have lesser context switching time.

-Thread is a lightweight process hence, takes fewer resources when compared with a process.

Threads can be implemented in 2 ways, User level threads and Kernel-level threads. The first one is managed by the user while the second, is managed by the operating system that would acts on the kernel i.e an operating system core.
<\/p>\n\n\n\n

Few things before we head onto for a simple thread program:

Create a thread<\/strong>
To create a thread, we use pthread_create() function that takes 4 parameters.

1) ID<\/strong>: This is of type pthread_t *<\/em><\/strong> . It is simply a pointer to the ID of the thread.

2) Attributes<\/strong>: pthread_attr_t *<\/em><\/strong> . This is used to set a few attributes of thread. Such as:
a. Detach State<\/strong> – Affects how you reclaim or leave active resources associated with a thread when a thread ends
( Default: PTHREAD_CREATE_JOINABLE<\/em>)

b. Scope <\/strong>– Chooses the scheduling contention scope for the created thread.
( Default: PTHREAD_SCOPE_SYSTEM<\/em>)

c. Inherit scheduler<\/strong> \u2013 Affects how the priority of the thread is determined by the system.
( Default: PTHREAD_EXPLICIT_SCHED<\/em>)

d. Scheduling policy<\/strong> \u2013 Affects how the threads are scheduled within the system or within the application. This is related to thread priority.
( Default: SCHED_OTHER<\/em> )

e. Scheduling priority<\/strong> \u2013 Also called as scheduling parameter for the thread.
( Default: 0<\/em>)

f. Guard Size<\/strong> \u2013 Changes the minimum size in bytes of the guard area of the thread\u2019s stack. If this value is set, it will be rounded up to the nearest page size.
( Default: a single page<\/em>)

g. Stack address<\/strong> – Provides an address for the application managed stack.
(Default: PTHREAD_STACK_MIN<\/em>)

h. Stack Size<\/strong> \u2013 Affects the number of functions that a thread can call before the thread fails due to insufficient stack space
(Default: PTHREAD_STACK_MIN<\/em>)

i. Stack<\/strong> \u2013 Provide both the address and size of an application-managed stack to use for the new thread.<\/p>\n\n\n\n

3) Starting routine<\/strong>: It is a void *<\/em><\/strong>. This is the name of the function that the thread starts to execute.
4) Arguments<\/strong>: It is a void *<\/em><\/strong>. This is the argument that the starting routine takes.
pthread_create(&thread_ID], NULL, Calling_this_function, &the_arg)<\/em><\/strong>;<\/p>\n\n\n\n

To Wait for a thread: Use pthread_join()<\/strong>. The parameters required are:

Thread ID<\/strong>: It is of type pthread_t<\/em><\/strong>. This is the ID of the thread that the parent thread waits for.

Reference to return value<\/strong>: It is of type void **<\/em><\/strong>. The value of exiting thread is caught by this pointer.
Exiting the thread. Use pthread_exit(). This is written at the end of starting routine.<\/p>\n<\/div>\n\n\n

\n#include<stdio.h>\n#include<pthread.h>\n\nint glb_val = 200;\n\nvoid *Calling_this_function( void *ptr )\n{\n        printf("Value  that was received during the starting routine: %d\\n ",*(int*)ptr);\n        pthread_exit(&glb_val);\n}\n\nvoid main()\n{\n        int the_arg = 10;\n        int *catch_thread=NULL; \/\/ pointer to an integer\n        pthread_t thread_ID;\n        pthread_create(&thread_ID,NULL,Calling_this_function,&the_arg); \/\/ Create the thread\n        pthread_join(thread_ID, (void**)&catch_thread);  \n\/\/ Wait for other function and get value in the pointer.\n        printf("Value received by parent: %d\\n",*catch_thread);\n\n}\n<\/pre><\/div>\n\n\n
Execution:<\/strong>
1) Execute with -lpthread
2) The program starts execution from main.
3) Creates a local variable for parent i.e the_arg.
4) Creates a pointer to catch value when the child thread returns i.e catch_thread
5) Creates variable for thread ID i.e thread_ID.
6) Creates a child thread at Calling_this_function() and pass the_arg as parameter.
7) Compiler identifies the Child thread i.e Calling_this_funciton()
8) Enters into the child thread i.e Calling_this_function()
9) Prints the statement with value as 10
10) Compiler waits for the child to die. I mean child process to end so that it can return and catch its value in catch_thread.
11) Execution of child process completed, return the reference to global variable glb_val.
12) Prints the global variable.
13) End of the program.<\/p>\n\n\n\n
Another simple program would be:<\/p>\n\n\n
\n#include<stdio.h>\n#include<unistd.h>\n#include<stdlib.h>\n#include<pthread.h>\n#include<sys\/types.h>\n#define Table_two 20\n#define Table_three 21\n#define Table_four 22\n#define Table_five 23\n#define UPTO 5\n\nvoid *TABLE_Two(void *ptr)\n{\n\tprintf("...Process ID of Table 2: %d...\\n",getpid());\n\n\twhile(1){\n\tint count;\n\tprintf("TWO TABLE: \\n");\n\tfor(count=1;count<=UPTO;count++)\n\t{\n\t\tprintf(" %d * %d =  %d\\n ",Table_two,count,count*Table_two);\n\t\/\/\tsleep(1);\n\t\n\t}\n\tsleep(2);\n\t}\n\tpthread_exit(NULL);\n\n\t\n\n}\n\n\nvoid *TABLE_Three(void *ptr)\n{\n\tprintf("...Process ID of Table 3: %d...\\n",getpid());\n\n\twhile(1){\n\tint count;\n\tprintf("\\t\\tTHREE TABLE: \\n");\n\tfor(count=1;count<=UPTO;count++)\n\t{\n\t\tprintf("\\t\\t %d * %d =  %d\\n ",Table_three,count,count*Table_three);\n\t\/\/\tsleep(1);\n\t}\n\tsleep(2);\n\t}\n\tpthread_exit(NULL);\n\t\n\n}\n\n\nvoid *TABLE_Four(void *ptr)\n{\n\n\tprintf("...Process ID of Table 4: %d...\\n",getpid());\n\n\twhile(1){\n\tint count;\n\tprintf("\\t\\t\\t\\tFOUR TABLE: \\n");\n\tfor(count=1;count<=UPTO;count++)\n\t{\n\t\tprintf("\\t\\t\\t\\t %d * %d =  %d\\n ",Table_four,count,count*Table_four);\n\t\/\/\tsleep(1);\n\t}\n\tsleep(2);\n\t}\n\tpthread_exit(NULL);\n\t\n\n}\n\n\nvoid *TABLE_Five(void *ptr)\n{\n\tprintf("...Process ID of Table 5: %d...\\n",getpid());\n\n\twhile(1){\n\tint count;\n\tprintf("\\t\\t\\t\\t\\t\\tFIVE TABLE: \\n");\n\tfor(count=1;count<=UPTO;count++)\n\t{\n\t\tprintf("\\t\\t\\t\\t\\t\\t %d * %d =  %d\\n ",Table_five,count,count*Table_five);\n\t\/\/\tsleep(1);\n\t}\n\tsleep(2);\n\t}\n\tpthread_exit(NULL);\n\t\n}\n\n\n\nvoid main()\n{\n\n\tprintf("...Process ID of main: %d...\\n",getpid());\n\n\tpthread_t  thid[4];\n\t\t\t\n\n\tpthread_create(&thid[0],NULL,TABLE_Two,NULL);\n\tpthread_create(&thid[1],NULL,TABLE_Three,NULL);\n\tpthread_create(&thid[2],NULL,TABLE_Four,NULL);  \t\n\tpthread_create(&thid[3],NULL,TABLE_Five,NULL);  \t\n\n\n\tpthread_join(thid[0],NULL);\n\tpthread_join(thid[1],NULL);\n\tpthread_join(thid[2],NULL);\n\tpthread_join(thid[3],NULL);\n\n\tprintf("\\n....End of threads execution...\\n");\n}\n\n<\/pre><\/div>\n\n\n
On execution, you would find that all <\/em><\/strong>four threads would be running at the same time. <\/em><\/strong><\/p>\n\n\n\n
Feel free to modify and experiment.<\/em><\/strong><\/p>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
Let’s talk about Threads What is a Thread? – A Thread is a path of execution within a process. A thread is also known as a lightweight process. The idea is to achieve parallelism by dividing a process into multiple threads. -A thread is an active entity as it executes as a part of a […]<\/p>\nRead More THREADS<\/span><\/a>","protected":false},"author":120055267,"featured_media":3285,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_wpcom_ai_launchpad_first_post":false,"_jetpack_feature_clip_id":0,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"{title}\n\n{excerpt}\n\n{url}","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":false,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2},"_wpas_customize_per_network":false,"jetpack_post_was_ever_published":false},"categories":[1342,28627],"tags":[1634593,38887748,47974053,34939379,772321180,3383,55794,57505,255],"class_list":["post-3279","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-education","category-embedded","tag-c-2","tag-embedded-2","tag-embedded-systems-2","tag-learning-2","tag-linux","tag-os","tag-processes","tag-threads","tag-ubuntu","fallback-thumbnail"],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t