To understand the backlog argument, we must realize that for a given listening socket, the kernel maintains two queues :
要明白backlog參數(shù)的含義，我們必須明白對于一個listening socket，kernel維護者兩個隊列：
1.An incomplete connection queue, which contains an entry for each SYN that has arrived from a client for which the server is awaiting completion of the TCP three-way handshake. These sockets are in the SYN_RCVD state .
1.一個未完成連接的隊列，此隊列維護著那些已收到了客戶端SYN分節(jié)信息，等待完成三路握手的連接，socket的狀態(tài)是SYN_RCVD
2.A completed connection queue, which contains an entry for each client with whom the TCP three-way handshake has completed. These sockets are in the ESTABLISHED state
2.一個已完成的連接的隊列，此隊列包含了那些已經(jīng)完成三路握手的連接，socket的狀態(tài)是ESTABLISHED
The backlog argument to the listen function has historically specified the maximum value for the sum of both queues.
backlog參數(shù)歷史上被定義為上面兩個隊列的大小之和
Berkeley-derived implementations add a fudge factor to the backlog: It is multiplied by 1.5
Berkely實現(xiàn)中的backlog值為上面兩隊列之和再乘以1.5
When a SYN arrives from a client, TCP creates a new entry on the incomplete queue and then responds with the second segment of the three-way handshake: the server's SYN with an ACK of the client's SYN (Section 2.6). This entry will remain on the incomplete queue until the third segment of the three-way handshake arrives (the client's ACK of the server's SYN), or until the entry times out. (Berkeley-derived implementations have a timeout of 75 seconds for these incomplete entries.)
當客戶端的第一個SYN到達的時候，TCP會在未完成隊列中增加一個新的記錄然后回復給客戶端三路握手中的第二個分節(jié)(服務端的SYN和針對客戶端的ACK)，這條記錄會在未完成隊列中一直存在，直到三路握手中的最后一個分節(jié)到達，或者直到超時(Berkeley時間將這個超時定義為75秒)
If the queues are full when a client SYN arrives, TCP ignores the arriving SYN (pp. 930–931 of TCPv2); it does not send an RST. This is because the condition is considered temporary, and the client TCP will retransmit its SYN, hopefully finding room on the queue in the near future. If the server TCP immediately responded with an RST, the client's connect would return an error, forcing the application to handle this condition instead of letting TCP's normal retransmission take over. Also, the client could not differentiate between an RST in response to a SYN meaning "there is no server at this port" versus "there is a server at this port but its queues are full."
如果當客戶端SYN到達的時候隊列已滿，TCP將會忽略后續(xù)到達的SYN，但是不會給客戶端發(fā)送RST信息，因為此時允許客戶端重傳SYN分節(jié)，如果返回錯誤信息，那么客戶端將無法分清到底是服務端對應端口上沒有相應應用程序還是服務端對應端口上隊列已滿這兩種情況
posted @
2010-02-07 19:43 許海斌 閱讀(18819) |
評論 (2) |
編輯 收藏
今天看到有人在問這個問題，寫了下代碼，標準庫分離了算法和數(shù)據(jù)結(jié)構(gòu)，按照這個框架寫程序確實比較方便，個人認為熟讀和透徹理解標準庫源碼是每個想成為資深c++程序員的必修課，就框架結(jié)構(gòu)而論，stl很好的分離了算法和數(shù)據(jù)結(jié)構(gòu)，就算法而論，標準庫里有很多常見算法的經(jīng)典實現(xiàn)，所以有非常高的研究價值。
#include <iostream>
#include <stddef.h>
#include <stdlib.h>
#include <string>
#include <iterator>
#include <algorithm>
#include <vector>
using namespace std;
template <typename InputIterator1, typename InputIterator2, typename OutputIterator>
OutputIterator delete_intersection(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2, OutputIterator dest)
{
while (first1 != last1 && first2 != last2) {
if (*first1 > *first2) {
*dest = *first2;
++first2;
++dest;
} else if (*first1 < *first2) {
*dest = *first1;
++first1;
++dest;
} else {
++first1;
++first2;
}
}
for (;first2 != last2; ++first2) *dest = *first2;
return dest;
}
int main() {
int a[] = {1,1,2,2,5,6,9,9};
int b[] = {1,2,3,4,4,6,7,8,9,9,9,10};
vector<int> vc;
delete_intersection(a, a + sizeof(a)/sizeof(a[0]), b, b + sizeof(b)/sizeof(b[0]), back_inserter(vc));
std::copy(a, a + sizeof(a)/sizeof(a[0]), ostream_iterator<int>(cout, ","));
cout << endl;
std::copy(b, b + sizeof(b)/sizeof(b[0]), ostream_iterator<int>(cout, ","));
cout << endl;
std::copy(vc.begin(), vc.end(), ostream_iterator<int>(cout, ","));
cout << endl;
::system("PAUSE");
return EXIT_SUCCESS;
}posted @
2009-03-05 18:56 許海斌 閱讀(1082) |
評論 (4) |
編輯 收藏
boost的線程庫不能強行終止，所以通過time_wait可以讓其自然的結(jié)束
1 #include <iostream>
2 #include <boost/thread/thread.hpp>
3 #include <boost/thread/mutex.hpp>
4 #include <boost/thread/condition.hpp>
5 #include <boost/date_time/posix_time/posix_time.hpp>
6
7 using namespace std;
8 using namespace boost;
9
10 boost::mutex test_mutex;
11 boost::condition_variable test_condition;
12
13 void test() {
14
15 for (;;) {
16
17 boost::mutex::scoped_lock lock(test_mutex);
18 if (test_condition.timed_wait(lock, get_system_time() + posix_time::seconds(3))) {
19 cout << "成功接收到通知" << endl; //這里加個break就結(jié)束了
20 } else {
21 cout << "沒有等待到通知" << endl;
22 }
23
24 }
25 }
26
27 int main() {
28
29 boost::thread test_thread(test);
30
31 for (;;) {
32 ::system("PAUSE");
33 cout << "開始發(fā)送通知" << endl;
34 test_condition.notify_one();
35 }
36
37 }
posted @
2009-02-19 17:18 許海斌 閱讀(5122) |
評論 (0) |
編輯 收藏
在泛型編程中，對于一個concept的一系列modeling，尤其是這些modeling中還有c++基本類型的時候，如果要抽取其特性，可以用一個traits類來解決，traits的名稱可命名為concept名稱_traits，對于其中的基本類型的traits可以用類模板的偏特化實現(xiàn)。
posted @
2009-02-09 17:59 許海斌 閱讀(1541) |
評論 (0) |
編輯 收藏
程序中幾個線程一起往控制臺寫入log_info，但是可以很清楚的看到begin or write_process不會同時連續(xù)的出現(xiàn)，而且在begin of write_process和end of write_process之間肯定不會出現(xiàn)begin of read_process或者end of read_process。但是begin of read_process卻會在控制臺上連續(xù)出現(xiàn)，這說明在同一時刻只有一個write_prcess在運行，但是wrte_process沒有運行的時候，會有多個read_process并發(fā)運行。
1 #include <iostream>
2
3 #include <boost/thread/thread.hpp>
4 #include <boost/thread/shared_mutex.hpp>
5
6 using namespace std;
7 using namespace boost;
8
9 boost::shared_mutex shr_mutex;
10
11 /// 這個是輔助類，能夠保證log_info被完整的輸出
12 class safe_log {
13 public:
14 static void log(const std::string& log_info) {
15 boost::mutex::scoped_lock lock(log_mutex);
16 cout << log_info << endl;
17 }
18
19 private:
20 static boost::mutex log_mutex;
21 };
22
23 boost::mutex safe_log::log_mutex;
24
25 void write_process() {
26 shr_mutex.lock();
27 safe_log::log("begin of write_process");
28 safe_log::log("end of write_process");
29 shr_mutex.unlock();
30 }
31
32 void read_process() {
33 shr_mutex.lock_shared();
34 safe_log::log("begin of read_process");
35 safe_log::log("end of read_process");
36 shr_mutex.unlock_shared();
37 }
38
39 int main() {
40
41 thread_group threads;
42 for (int i = 0; i < 10; ++ i) {
43 threads.create_thread(&write_process);
44 threads.create_thread(&read_process);
45 }
46
47 threads.join_all();
48
49 ::system("PAUSE");
50
51 return 0;
52 }
posted @
2009-01-21 13:58 許海斌 閱讀(2664) |
評論 (0) |
編輯 收藏