使用C定期从客户端向服务器发送数据

Question

I am creating a multithreaded socket program that needs to send 2 sets of data to the server periodically. The client needs to send GPS information every 3 seconds and polarity information every 4 seconds. My idea on implementing this was to simply create a new thread, make a infinite loop, send() the GPS information, sleep() for 1 second, send() the polarity information, and then sleep() for 2 seconds. Would this be a sufficient way of going about this? Sorry, I'm new to socket programming so I don't know of any alternative methods.

Answer 1

Your proposed scheme is:

send the GPS information, sleep for 1 second, send the polarity information, and then sleep for 2 seconds

Over a period of 12 seconds, that leads to:

1. GPS; sleep 1
2. polarity; sleep 1
3. sleep 1
4. GPS; sleep 1
5. polarity; sleep 1
6. sleep 1
7. GPS; sleep 1
8. polarity; sleep 1
9. sleep 1
10. GPS; sleep 1
11. polarity; sleep 1
12. sleep 1

This sends the GPS information 4 times (correct) and the polarity 4 times, and every 3 seconds, not 3 times and every 4 seconds as the specification requires. The desired sequence might be:

1. GPS; polarity; sleep 1
2. sleep 1
3. sleep 1
4. GPS; sleep 1
5. polarity; sleep 1
6. sleep 1
7. GPS; sleep 1
8. sleep 1
9. polarity; sleep 1
10. GPS; sleep 1
11. sleep 1
12. sleep 1

Note that in some second, both GPS and polarity must be sent.

You can achieve this in either of two ways. Assuming you need to use threads at all, use two threads, one on a three second wait, one on a four second wait. Coordinate access to the socket with a mutex so that on multiples of 12 seconds, you still get sane behaviour.

However, you could do it all with a single-threaded process that waits appropriate intervals:

int i_gps = 3;
int i_pol = 4;
int t_gps = 0;
int t_pol = 0;
int t_cur = 0;

while (1)
{
    if (t_cur == t_gps && t_cur == t_pol)
    {
        t_cur = t_gps = t_pol = 0;  // Avoid integer overflow
    }
    if (t_cur == t_gps)
    {
        send GPS
        t_gps += i_gps;
    }
    if (t_cur == t_pol)
    {
        send polarity
        t_pol += i_pol;
    }
    sleep 1;
    t_cur++;
}

You can also sleep for multiple seconds by altering the code at the end of the loop to determine which send comes next and sleeping for the appropriate amount of time and incrementing t_cur by the appropriate amount of time (rather than just using 1 second all the time).

If you need to avoid drift (because the code above assumes that the send process is instantaneous and it isn't), then you have to use sub-second sleeps and trap the time at the start of the loop and adjust the sleep interval to allow for the time taken to do the sending.