UNIX network programming examples of TCP client-server programming (II.)

In this section we continue to introduce several other TCP client-server programs;

Fourth: TCP concurrent server, one sub-thread per client

As can be seen in the example of the concurrent server program in front of us: The parent process accepts the connection, derives the child process, and the subprocess processes the interaction with the customer.

Problems with this pattern:

Fork () is expensive. The memory image is copied from the parent process to the child process, all the descriptors are replicated in the child process, and so on.

Fork () child process, you need to use interprocess communication to pass information between the parent and child processes.

All threads in a process share the same global memory, which makes it easy for threads to share information, but this simple type also brings synchronization problems. All threads in a process share not only global variables, but also shared:

Process instructions, most data, open files (such as descriptive words), signal handlers and signal disposition, current working directory, user ID and group ID;

That's why we've introduced threads;

When a program is started by exec, a single thread is created that is called the initial thread or the main path. Additional threads are created by the Pthread_create function.

Each thread in a process is identified by a thread ID whose data type is pthread_t (often unsigned int). If the new thread is created successfully, its ID is returned through the TID pointer.

Each thread has a number of properties: The priority, the start stack size, whether it should be a daemon thread, and so on. When creating a thread, we can override the default by initializing a phread_attr_t variable to describe these properties.

Finally, when you create a thread, we describe a function that it will execute. The thread starts by invoking the function, then either the display terminates (calls to pthread_exit) or the implicit termination (the function returns). Parameter with a pointer of Arg.

We can call Pthread_join to wait for a thread to terminate. Similar to Waitpid.

We must specify the TID to wait for the thread. You cannot wait for any one thread to end (similar to the case where the WAITPID process ID parameter is-1).

Mutual exclusion Lock:

Multiple threads Modifying a shared variable is the simplest problem, and the workaround is to protect the shared variable with a mutex (mutex), and only if we hold a mutex to access the variable.

A mutex is a variable of type pthread_mutex_t.

Condition variables:

Mutexes are suitable for blocking simultaneous access to shared variables, but we need something to allow us to sleep and wait for a certain condition to occur. We need a way to make the main loop go to sleep until a thread notifies it that something is ready. Conditional variables plus mutexes can provide this functionality. Mutexes provide mutually exclusive mechanisms, and conditional variables provide a signaling mechanism.

A condition variable is a variable of type pthread_cond_t.

Multithreaded client program:

2. #include "Unpthread.h"
4. void* CopyTo (void*);
6. static int sockfd;//global variable, common to all threads
8. Static FILE *FP;
10. void Str_cli1 (FILE *fp_arg, int sockfd_arg) {
12. Char Recvline[maxline];
14. pthread_t Tid;
16. sockfd = Sockfd_arg;
18. fp = Fp_arg;
20. Pthread_create (&tid,null,copyto,null);
22. While (Readline (sockfd,recvline,maxline) >0)
24. Fputs (recvline,stdout);
26. }
30. void* CopyTo (void* Arg) {
32. Char Sendline[maxline];
34. while (Fgets (SENDLINE,MAXLINE,FP)!=null)
36. Writen (Sockfd,sendline,strlen (sendline));
38. Shutdown (SOCKFD,SHUT_WR);
40. return (NULL);
42. }
46. Int
48. Main (int argc, char **argv)
50. {
52. int sockfd;
54. struct sockaddr_in servaddr;
58. if (argc! = 2)
60. err_quit ("Usage:tcpcli <ipaddress>");
64. sockfd = Socket (af_inet, sock_stream, 0);
68. Bzero (&servaddr, sizeof (SERVADDR));
70. servaddr.sin_family = af_inet;
72. Servaddr.sin_port = htons (Serv_port);
74. Inet_pton (Af_inet, argv[1], &servaddr.sin_addr);
78. Connect (SOCKFD, (SA *) &servaddr, sizeof (SERVADDR));
82. Str_cli1 (stdin, SOCKFD); /* Do it all */
86. Exit (0);
88. }

Server program:

2. #include "Unpthread.h"
4. static void *doit (void *); /* Each thread executes the This function */
8. Int
10. Main (int argc, char **argv)
12. {
14. int LISTENFD, CONNFD;
16. pthread_t Tid;
18. Socklen_t Addrlen, Len;
20. struct SOCKADDR *cliaddr;
24. if (argc = = 2)
26. listenfd = Tcp_listen (NULL, argv[1], &addrlen);
28. else if (argc = = 3)
30. listenfd = Tcp_listen (argv[1], argv[2], &addrlen);
32. Else
34. err_quit ("Usage:tcpserv01 [<host>] <service or port>");
38. cliaddr = Malloc (Addrlen);
42. for (;;) {
44. len = Addrlen;
46. connfd = Accept (LISTENFD, cliaddr, &len);
48. Pthread_create (&tid, NULL, &doit, (void *) CONNFD);
50. }
52. }
56. static void *
58. doit (void *arg)
60. {
62. Pthread_detach (Pthread_self ());
64. Str_echo ((int) arg); /* Same function as before */
66. Close ((int) arg); /* Do with connected socket */
68. return (NULL);
70. }

Note: Here we compile, because pthread is not the system default library, so use the command:

GCC Tcpcli.c-o client-lunp-lpthread

GCC Tcpserv.c-o server-lunp-lpthread

Server Run command: sudo./server 127.0.0.1 9877

Client Run command:./client 127.0.0.1

We notice that each client's program is actually a change of the STR_CLI function, and the main function does not change;

OK, and introduced a design example, continue tomorrow, not to be continued ...

Copyright NOTICE: This article for Bo Master http://www.zuiniusn.com original article, without Bo Master permission not reproduced.

UNIX network programming examples of TCP client-server programming (II.)