TCP/IP network programming multi-thread server implementation (1)

TCP/IP network programming multi-thread server implementation (1)

Basic thread concepts

We have mentioned the multi-process server before, but we know that it has a high overhead, So we introduce the thread. we can regard it as a lightweight process. It has the following advantages over processes:

Thread creation and context switching are less costly and faster.

Special techniques are not required when data is exchanged between threads.

Process: in the operating system, a separate execution flow unit is formed.

Thread: the unit in which the process constitutes a separate execution flow.

Their inclusion relationships are: Operating System> process> thread. The specific difference between processes and threads is that each process has an independent and complete memory space, including the global data zone, heap zone, and stack zone, the overhead of the multi-process server is high because the data zone, heap zone, and stack zone memory are all copied to distinguish different function flows in the stack zone. Multithreading is much more efficient. It only separates the stack zone, and the data zone in the process is shared. An example of the memory structure is shown below:

 

Thread creation and running

The thread has a separate execution flow. Therefore, you must define the thread entry function separately and request the operating system to execute this function in a separate execution flow. The function to complete this function is as follows:

 
 

  
  
# Include
  
  
 
  
  
Int pthread_create (
  
  
 
  
  
Pthread_t * restrict thread, // save thread ID
  
  
 
  
  
Const pthread_attr_t * restrict attr, // thread attribute, NULL default attribute
  
  
 
  
  
Void * (* start_routine) (void *), // thread entry function, function pointer
  
  
 
  
  
Void * restrict arg // parameters passed to the entry function
  
  
 
  
  
);
 
 

Instance code:

 
 

  
  
#include 
  
  
 
  
  
#include 
  
  
 
  
  
#include 
  
  
 
  
  
void * thread_main(void *arg); 
  
  
 
  
  
int main(int argc, char *argv[]) 
  
  
 
  
  
{ 
  
  
 
  
  
pthread_t t_id; 
  
  
 
  
  
int thread_param = 5; 
  
  
 
  
  
if (pthread_create(&t_id, NULL, thread_main, (void *)&thread_param) != 0) 
  
  
 
  
  
{ 
  
  
 
  
  
puts("pthread_create() error"); 
  
  
 
  
  
return -1; 
  
  
 
  
  
} 
  
  
 
  
  
sleep(10); 
  
  
 
  
  
puts("end of main"); 
  
  
 
  
  
return 0; 
  
  
 
  
  
} 
  
  
 
  
  
void * thread_main(void *arg) 
  
  
 
  
  
{ 
  
  
 
  
  
int i; 
  
  
 
  
  
int cnt =* ((int *)arg); 
  
  
 
  
  
for (i = 0; i < cnt; i++) 
  
  
 
  
  
{ 
  
  
 
  
  
sleep(1); 
  
  
 
  
  
puts("running thread"); 
  
  
 
  
  
} 
  
  
 
  
  
return NULL; 
  
  
 
  
  
}
 
 

 

The above example uses sleep delay to control thread execution. If the main thread does not delay the execution, it is returned to return 0; when the process ends, the corresponding thread will be destroyed. Obviously, it is unreasonable to use sleep to control the thread execution stream. Let's look at a better delay function. The process (or thread) that calls this function will enter the waiting state, until the thread with the first parameter ID is terminated. In addition, the return value of the entry function of the thread can be obtained.

 
 

  
  
# Include
  
  
 
  
  
Int pthread_join (pthread_t thread, void ** status );
  
  
 
  
  
Parameter 1: thread ID
  
  
 
  
  
Parameter 2: Save the return value of the thread entry function
 
 

Instance code:

 
 

  
  
# Include
  
  
 
  
  
# Include
  
  
 
  
  
# Include
  
  
 
  
  
# Include
  
  
 
  
  
Void * thread_main (void * arg );
  
  
 
  
  
Int main (int argc, char * argv [])
  
  
 
  
  
{
  
  
 
  
  
Pthread_t t_id;
  
  
 
  
  
Int thread_param = 5;
  
  
 
  
  
Void * thr_ret;
  
  
 
  
  
// Create a thread
  
  
 
  
  
If (pthread_create (& t_id, NULL, thread_main, (void *) & thread_param )! = 0)
  
  
 
  
  
{
  
  
 
  
  
Puts ("pthread_create () error ");
  
  
 
  
  
Return-1;
  
  
 
  
  
}
  
  
 
  
  
// Wait for the thread to return
  
  
 
  
  
If (pthread_join (t_id, & thr_ret )! = 0)
  
  
 
  
  
{
  
  
 
  
  
Puts ("pthread_join () error ");
  
  
 
  
  
Return-1;
  
  
 
  
  
}
  
  
 
  
  
Printf ("Thread return message: % s \ n", (char *) thr_ret );
  
  
 
  
  
Free (thr_ret );
  
  
 
  
  
Return 0;
  
  
 
  
  
}
  
  
 
  
  
// Thread entry function
  
  
 
  
  
Void * thread_main (void * arg)
  
  
 
  
  
{
  
  
 
  
  
Int I;
  
  
 
  
  
Int cnt = * (int *) arg );
  
  
 
  
  
Char * msg = (char *) malloc (sizeof (char) * 50 );
  
  
 
  
  
Strcpy (msg, "Hello, I am thread ~ \ N ");
  
  
 
  
  
For (I = 0; I <cnt; I ++)
  
  
 
  
  
{
  
  
 
  
  
Puts ("running thread ");
  
  
 
  
  
}
  
  
 
  
  
Return (void *) msg;
  
  
 
  
  
}