2. 程式人生 > >week7：網路程式設計之基礎

week7：網路程式設計之基礎

阿新 • • 發佈：2018-11-10

一、OSI模型

二、網路通訊要素

2.1、IP地址

2.2、埠號

2.3、傳輸協議

三、socket程式設計

socket即是一種特殊的檔案，一些socket函式就是對其進行的操作（讀/寫IO、開啟、關閉)。

Socket 是任何一種計算機網路通訊中最基礎的內容。例如當你在瀏覽器位址列中輸入 http://www.cnblogs.com/ 時，你會開啟一個套接字，然後連線到 http://www.cnblogs.com/ 並讀取響應的頁面然後顯示出來。而其他一些聊天客戶端如 gtalk 和 skype 也是類似。任何網路通訊都是通過 Socket 來完成的。Python 官方關於 Socket 的函式請看 

http://docs.python.org/library/socket.html

socket和file的區別：

　　1、file模組是針對某個指定檔案進行【開啟】【讀寫】【關閉】

　　2、socket模組是針對 伺服器端 和 客戶端Socket 進行【開啟】【讀寫】【關閉】

Python 提供了兩個基本的 socket 模組。

   第一個是 Socket，它提供了標準的 BSD Sockets API。

   第二個是 SocketServer， 它提供了伺服器中心類，可以簡化網路伺服器的開發。

3.1、Socket 型別

套接字格式：

socket(family,type[,protocal]) 使用給定的地址族、套接字型別、協議編號（預設為0）來建立套接字。

 

socket型別

描述

socket.AF_UNIX

只能夠用於單一的Unix系統程序間通訊

socket.AF_INET

伺服器之間網路通訊

socket.AF_INET6

IPv6

socket.SOCK_STREAM

流式socket , for TCP

socket.SOCK_DGRAM

資料報式socket , for UDP

socket.SOCK_RAW

原始套接字，普通的套接字無法處理ICMP、IGMP等網路報文，而SOCK_RAW可以；其次，SOCK_RAW也可以處理特殊的IPv4報文；此外，利用原始套接字，可以通過IP_HDRINCL套接字選項由使用者構造IP頭。

socket.SOCK_SEQPACKET

可靠的連續資料包服務

建立TCP Socket：

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

建立UDP Socket：

s=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

3.2、Socket 函式

注意點:

1）TCP傳送資料時，已建立好TCP連線，所以不需要指定地址。UDP是面向無連線的，每次傳送要指定是發給誰。

2）服務端與客戶端不能直接傳送列表，元組，字典。需要字串化repr(data)。

 

socket函式

描述

服務端socket函式

s.bind(address)

將套接字繫結到地址, 在AF_INET下,以元組（host,port）的形式表示地址.

s.listen(backlog)

開始監聽TCP傳入連線。backlog指定在拒絕連線之前，作業系統可以掛起的最大連線數量。該值至少為1，大部分應用程式設為5就可以了。

s.accept()

接受TCP連線並返回（conn,address）,其中conn是新的套接字物件，可以用來接收和傳送資料。address是連線客戶端的地址。

客戶端socket函式

s.connect(address)

連線到address處的套接字。一般address的格式為元組（hostname,port），如果連接出錯，返回socket.error錯誤。

s.connect_ex(adddress)

功能與connect(address)相同，但是成功返回0，失敗返回errno的值。

公共socket函式

s.recv(bufsize[,flag])

接受TCP套接字的資料。資料以字串形式返回，bufsize指定要接收的最大資料量。flag提供有關訊息的其他資訊，通常可以忽略。

s.send(string[,flag])

傳送TCP資料。將string中的資料傳送到連線的套接字。返回值是要傳送的位元組數量，該數量可能小於string的位元組大小。

s.sendall(string[,flag])

完整發送TCP資料。將string中的資料傳送到連線的套接字，但在返回之前會嘗試傳送所有資料。成功返回None，失敗則丟擲異常。

s.recvfrom(bufsize[.flag])

接受UDP套接字的資料。與recv()類似，但返回值是（data,address）。其中data是包含接收資料的字串，address是傳送資料的套接字地址。

s.sendto(string[,flag],address)

傳送UDP資料。將資料傳送到套接字，address是形式為（ipaddr，port）的元組，指定遠端地址。返回值是傳送的位元組數。

s.close()

關閉套接字。

s.getpeername()

返回連線套接字的遠端地址。返回值通常是元組（ipaddr,port）。

s.getsockname()

返回套接字自己的地址。通常是一個元組(ipaddr,port)

s.setsockopt(level,optname,value)

設定給定套接字選項的值。

s.getsockopt(level,optname[.buflen])

返回套接字選項的值。

s.settimeout(timeout)

設定套接字操作的超時期，timeout是一個浮點數，單位是秒。值為None表示沒有超時期。一般，超時期應該在剛建立套接字時設定，因為它們可能用於連線的操作（如connect()）

s.gettimeout()

返回當前超時期的值，單位是秒，如果沒有設定超時期，則返回None。

s.fileno()

返回套接字的檔案描述符。

s.setblocking(flag)

如果flag為0，則將套接字設為非阻塞模式，否則將套接字設為阻塞模式（預設值）。非阻塞模式下，如果呼叫recv()沒有發現任何資料，或send()呼叫無法立即傳送資料，那麼將引起socket.error異常。

s.makefile()

建立一個與該套接字相關連的檔案

 

四、socket程式設計思路

TCP服務端：

1 建立套接字，繫結套接字到本地IP與埠

   # socket.socket(socket.AF_INET,socket.SOCK_STREAM) , s.bind()

2 開始監聽連線                   #s.listen()

3 進入迴圈，不斷接受客戶端的連線請求              #s.accept()

4 然後接收傳來的資料，併發送給對方資料         #s.recv() , s.sendall()

5 傳輸完畢後，關閉套接字                     #s.close()

 

TCP客戶端:

1 建立套接字，連線遠端地址

       # socket.socket(socket.AF_INET,socket.SOCK_STREAM) , s.connect()

2 連線後傳送資料和接收資料          # s.sendall(), s.recv()

3 傳輸完畢後，關閉套接字          #s.close()

故事1：一次會話

######服務端##########
import socket
address = ('127.0.0.1', 8000)
sk = socket.socket()
sk.bind(address)
sk.listen(3)
print('server waiting...')

conn, addr = sk.accept()
client_data = conn.recv(1024)
print(str(client_data, "utf8"))

inp = input('>>>')
conn.send(bytes(inp, 'utf8'))

sk.close()

 

#######客戶端##############
import socket

sk = socket.socket()
print(sk)


address = ('127.0.0.1', 8000)
sk.connect(address)

inp = input('>>>')
sk.send(bytes(inp, 'utf8'))

data = sk.recv(1024)
print(str(data, 'utf8'))

sk.close()

故事2：持久會話

##############服務端##############
import socket
address = ('127.0.0.1', 8000)
sk = socket.socket()
sk.bind(address)
sk.listen(3)
print('server waiting...')

conn, addr = sk.accept()
while 1:
    client_data = conn.recv(1024)
    print(str(client_data, "utf8"))

    inp = input('>>>')
    conn.send(bytes(inp, 'utf8'))

sk.close()
#############客戶端##############
import socket

sk = socket.socket()
print(sk)


address = ('127.0.0.1', 8000)
sk.connect(address)

while True:
    inp = input('>>>')
    sk.send(bytes(inp, 'utf8'))

    data = sk.recv(1024)
    print(str(data, 'utf8'))

sk.close()

故事3：持久會話，然後再結束

##############服務端##############
import socket
address = ('127.0.0.1', 8000)
sk = socket.socket()
sk.bind(address)
sk.listen(3)
print('server waiting...')

conn, addr = sk.accept()
while 1:
    client_data = conn.recv(1024)
    if not client_data: break
    print('.........', str(client_data, "utf8"))

    inp = input('>>>')
    conn.send(bytes(inp, 'utf8'))

sk.close()
import socket

sk = socket.socket()
print(sk)


address = ('127.0.0.1', 8000)
sk.connect(address)

while True:
    inp = input('>>>')
    if inp == 'exit':
        break
    sk.send(bytes(inp, 'utf8'))

    data = sk.recv(1024)
    print(str(data, 'utf8'))

sk.close()

故事4：持久會話，然後再結束，客戶端只發空，然後會出現什麼情況

##############服務端##############
import socket
address = ('127.0.0.1', 8000)
sk = socket.socket()
sk.bind(address)
sk.listen(3)
print('server waiting...')

conn, addr = sk.accept()
while 1:
    client_data = conn.recv(1024)
    if not client_data: break
    print('.........', str(client_data, "utf8"))

    inp = input('>>>')
    conn.send(bytes(inp, 'utf8'))

sk.close()
import socket

sk = socket.socket()
print(sk)


address = ('127.0.0.1', 8000)
sk.connect(address)

while True:
    inp = input('>>>')
    if inp == 'exit':
        break
    sk.send(bytes(inp, 'utf8'))

    data = sk.recv(1024)
    print(str(data, 'utf8'))

sk.close()

這樣如果客戶端發的資料就是空資料的話豈不是也意外退出，那不就bug啦？

其實不用擔心，如果客戶端send了一個空資料後客戶端繼續向下執行，而server端的recv方法會繼續阻塞，直到接收到一個非空資料才會繼續向下執行。

 故事5：持久會話，然後再結束，服務多個客戶端

##############服務端##############
import socket
address = ('127.0.0.1', 8000)
sk = socket.socket()
sk.bind(address)
sk.listen(3)
print('server waiting...')


while 1:
    conn, addr = sk.accept()
    while 1:
        client_data = conn.recv(1024)
        print('.........', str(client_data, "utf8"))
        if not client_data:break

        inp = input('>>>')
        conn.send(bytes(inp, 'utf8'))

sk.close()
#############客戶端##############
import socket

sk = socket.socket()
print(sk)


address = ('127.0.0.1', 8000)
sk.connect(address)

while True:
    inp = input('>>>')
    if inp == 'exit':
        break
    sk.send(bytes(inp, 'utf8'))

    data = sk.recv(1024)
    print(str(data, 'utf8'))

sk.close()

 另外一種方法：

##############服務端##############
import socket
address = ('127.0.0.1', 8000)
sk = socket.socket()
sk.bind(address)
sk.listen(3)
print('server waiting...')

conn, addr = sk.accept()
while 1:
    client_data = conn.recv(1024)
    print('.........', str(client_data, "utf8"))
    if not client_data:
        conn,addr = sk.accept()
        continue


    inp = input('>>>')
    conn.send(bytes(inp, 'utf8'))

sk.close()

 

#############客戶端##############
import socket

sk = socket.socket()
print(sk)


address = ('127.0.0.1', 8000)
sk.connect(address)

while True:
    inp = input('>>>')
    if inp == 'exit':
        break
    sk.send(bytes(inp, 'utf8'))

    data = sk.recv(1024)
    print(str(data, 'utf8'))

sk.close()

 故事6：持久會話，然後再結束，服務多個客戶端，如果按住紅色stop_button按鈕的退出處理

##############服務端##############
import socket
address = ('127.0.0.1', 8000)
sk = socket.socket()
sk.bind(address)
sk.listen(3)
print('server waiting...')


while 1:
    conn, addr = sk.accept()
    print(addr)
    while 1:
        try:
            client_data = conn.recv(1024)
        except Exception:
            break
        print('.........', str(client_data, "utf8"))
        if not client_data:break

        inp = input('>>>')
        conn.send(bytes(inp, 'utf8'))

sk.close()

 

#############客戶端##############
import socket

sk = socket.socket()
print(sk)


address = ('127.0.0.1', 8000)
sk.connect(address)

while True:
    inp = input('>>>')
    if inp == 'exit':
        break
    sk.send(bytes(inp, 'utf8'))

    data = sk.recv(1024)
    print(str(data, 'utf8'))

sk.close()

 五、遠端執行

#############客戶端##############
import socket

sk = socket.socket()
print(sk)


address = ('127.0.0.1', 8000)
sk.connect(address)

while True:
    inp = input('>>>')
    if inp == 'exit':
        break
    sk.send(bytes(inp, 'utf8'))
    result_len = int(str(sk.recv(1024)), 'utf8')
    print(result_len)
    data = bytes()

    while len(data) != result_len:
        recv = sk.recv(1024)
        data += recv
    print(str(data, 'gbk'))

sk.close()
##############服務端##############
import subprocess

# subprocess.Popen()


import socket
address = ('127.0.0.1', 8000)
sk = socket.socket()
sk.bind(address)
sk.listen(3)
print('server waiting...')


while 1:
    conn, addr = sk.accept()
    print(addr)
    while 1:
        try:
            client_data = conn.recv(1024)
        except Exception:
            break
        print('.........', str(client_data, "utf8"))
        if not client_data:break

        obj = subprocess.Popen(str(client_data,'utf8'), shell=True, stdout=subprocess.PIPE)
        cmd_result = obj.stdout.read()
        result_len = bytes(str(len(cmd_result)), 'utf8')
        print('>>>>>>>', result_len)
        conn.sendall(result_len)

        conn.sendall(cmd_result)

sk.close()

conclusion:

              sendall會把資料直接全部發送到客戶端，客戶端將所有的資料都放到緩衝區,每次recv多少位元組取決於recv內的引數，理論不應該超過8k。

所以，並不能一次recv()無限大資料，所以這裡我們應該通過迴圈去接收。

六、解決大資料傳送和粘包問題

##############服務端##############
import subprocess

# subprocess.Popen()


import socket
address = ('127.0.0.1', 8000)
sk = socket.socket()
sk.bind(address)
sk.listen(3)
print('server waiting...')


while 1:
    conn, addr = sk.accept()
    print(addr)
    while 1:
        try:
            client_data = conn.recv(1024)
        except Exception:
            break
        print('.........', str(client_data, "utf8"))
        if not client_data:break

        obj = subprocess.Popen(str(client_data, 'utf8'), shell=True, stdout=subprocess.PIPE)
        cmd_result = obj.stdout.read()

        result_len = bytes(str(len(cmd_result)), 'utf8')
        print('>>>>>>>', result_len)
        conn.sendall(result_len) #粘包現象

        conn.recv(1024)#解決粘包
        # import time
        # time.sleep(1)

        conn.sendall(cmd_result)

sk.close()
#############客戶端##############
import socket

sk = socket.socket()
print(sk)


address = ('127.0.0.1', 8000)
sk.connect(address)

while True:
    inp = input('>>>')
    if inp == 'exit':
        break
    sk.send(bytes(inp, 'utf8'))
    result_len = int(str(sk.recv(1024)), 'utf8')
    sk.sendall('111')
    print(result_len)
    data = bytes()

    while len(data) != result_len:
        recv = sk.recv(1024)
        data += recv
    print(str(data, 'gbk'))

sk.close()

七、檔案傳送

post_serve

import subprocess
import os

# subprocess.Popen()


import socket
address = ('127.0.0.1', 8000)
sk = socket.socket()
sk.bind(address)
sk.listen(3)
print('server waiting...')
BASE_DIR = os.path.dirname(os.path.abspath(__file__))


while 1:
    conn, addr = sk.accept()
    # print(addr)
    while 1:
        data = conn.recv(1024)
        cmd, filename, filesize = str(data, 'utf8').split('|')
        path = os.path.join(BASE_DIR, 'ma', filename)
        filesize = int(filesize)

        f = open(path, 'ab')
        has_receive = 0
        while has_receive != filesize:
            data = conn.recv(1024)
            f.write(data)
            has_receive += len(data)
        f.close()

post_client

import socket
import os

sk = socket.socket()
print(sk)


address = ('127.0.0.1', 8000)
sk.connect(address)

BASE_DIR = os.path.dirname(os.path.abspath(__file__))

while True:
    inp = input('>>>').strip()  # post\11.png

    cmd,path = inp.split('|')

    path = os.path.join(BASE_DIR, path)

    filename = os.path.basename(path)
    filesize = os.stat(path).st_size

    file_info = 'post|%s|%s' % (filename, filesize)

    sk.sendall(bytes(file_info, 'utf8'))

    f = open(path, 'rb')
    has_sent = 0
    while has_sent != filesize:
        data = f.read(1024)
        sk.sendall(data)
        has_sent += len(data)
    f.close()
    print('上傳成功')

八、serve端實現併發聊天

簡單例子

##############服務端##############
import socketserver

class MyServer(socketserver.BaseRequestHandler):

    def handle(self):
        print("服務端啟動...")
        while True:
            conn = self.request
            print(self.client_address)
            while True:
                client_data=conn.recv(1024)
                print(str(client_data,"utf8"))
                print("waiting...")
                conn.sendall(client_data)
            conn.close()

if __name__ == '__main__':
    server = socketserver.ThreadingTCPServer(('127.0.0.1', 8091), MyServer)
    server.serve_forever()


#############客戶端##############
import socket

ip_port = ('127.0.0.1', 8091)
sk = socket.socket()
sk.connect(ip_port)
print("客戶端啟動：")
while True:
    inp = input('>>>')
    sk.sendall(bytes(inp,"utf8"))
    if inp == 'exit':
        break
    server_response=sk.recv(1024)
    print(str(server_response,"utf8"))
sk.close()

聊天併發例項

import socketserver

class MyServer(socketserver.BaseRequestHandler):

    def handle(self):
        print("服務端啟動...")
        while True:
            conn = self.request
            print(self.client_address)
            while True:

                client_data=conn.recv(1024)

                print(str(client_data,"utf8"))
                print("waiting...")
                server_response=input(">>>")
                conn.sendall(bytes(server_response,"utf8"))
                # conn.sendall(client_data)

            conn.close()
            # print self.request,self.client_address,self.server


if __name__ == '__main__':
    server = socketserver.ThreadingTCPServer(('127.0.0.1', 8098), MyServer)
    server.serve_forever()


import socket


ip_port = ('127.0.0.1', 8098)
sk = socket.socket()
sk.connect(ip_port)
print ("客戶端啟動：")
while True:
    inp = input('>>>')
    sk.sendall(bytes(inp,"utf8"))
    server_response=sk.recv(1024)
    print (str(server_response,"utf8"))
    if inp == 'exit':
        break
sk.close()

九、socketserver模組

它包含了種五種server類，BaseServer(不直接對外服務)。TCPServer使用TCP協議，UDPServer使用UDP協議，還有兩個不常使用的，即UnixStreamServer和UnixDatagramServer,這兩個類僅僅在unix環境下有用(AF_unix)。

建立一個socketserver 至少分以下幾步

  1. First, you must create a request handler class by subclassing the BaseRequestHandlerclass and overriding its handle() method; this method will process incoming requests. 　　
  2. Second, you must instantiate one of the server classes, passing it the server’s address and the request handler class.
  3. Then call the handle_request() orserve_forever() method of the server object to process one or many requests.
  4. Finally, call server_close() to close the socket.

讓你的socketserver併發起來， 必須選擇使用以下一個多併發的類

1

2

3

4

5

6

7

class socketserver.ForkingTCPServer

 

class socketserver.ForkingUDPServer

 

class socketserver.ThreadingTCPServer

 

class socketserver.ThreadingUDPServer

 

相關推薦

week7：網路程式設計之基礎

一、OSI模型 二、網路通訊要素 2.1、IP地址 2.2、埠號 2.3、傳輸協議 三、socket程式設計 socket即是一種特殊的檔案，一些socket函式就是對其進行的操作（讀/寫IO、開啟、關閉)。 Socket 是任何一種計算機網路通訊中最基礎的內容。例如當你

week7：網路程式設計之程序

一、執行緒與程序 什麼是執行緒? 執行緒是作業系統能夠進行運算排程的最小單位。它被包含在程序之中，是程序中的實際運作單位。一條執行緒指的是程序中一個單一順序的控制流，一個程序中可以併發多個執行緒，每條執行緒並行執行不同的任務。 什麼是程序?  threads are

網路遊戲《叢林戰爭》開發與學習之（一）：網路程式設計的基礎知識

《叢林戰爭》是一款完整的網路遊戲案例，運用U3D開發客戶端，Socket開發服務端，其中涉及到了網路程式設計、資料庫和Unity的功能實現，之前通過U3D開發了一個單機遊戲《黑暗之光》，並沒有涉及網路程式設計的知識，通過《叢林戰爭》這個完整的遊戲，系統性地學習網路程式設計，並

Learning-Python【29】：網路程式設計之粘包

粘包問題 　　上一篇部落格遺留了一個問題，在接收的最大位元組數設定為 1024 時，當接收的結果大於1024，再執行下一條命令時還是會返回上一條命令未執行完成的結果。這就是粘包問題。 　　因為TCP協議又叫流式協議，每次傳送給客戶端的資料實際上是傳送到客戶端所在作業系統的快取上，客戶端就是一個應用程式，需

Python併發程式設計（三）：網路程式設計之粘包現象

目錄 一、什麼是粘包 須知：只有TCP有粘包現象，UDP永遠不會粘包 粘包不一定會發生 如果發生了：1.可能是在客戶端已經粘了 　　　　　　2.客戶端沒有粘，可能是在服務端粘了 首先需要掌握一個socket收發訊息的原理 應用

Python之路（十四）：網路程式設計基礎 Python基礎之網路程式設計

Python基礎之網路程式設計     學習網路程式設計之前,要對計算機底層的通訊實現機制要有一定的理解。 OSI 網際網路協議按照功能不同分為osi七層或tcp/ip五層或tcp/ip四層   可以將應用層，表示層，會

linux網路程式設計之TCP/IP基礎（二）：利用ARP和ICMP協議解釋ping命令

一、MTU 乙太網和IEEE 802.3對資料幀的長度都有限制，其最大值分別是1500和1492位元組，將這個限制稱作最大傳輸單元（MTU，Maximum Transmission Unit）。如果I

Python3 與 C# 網路程式設計之～ 網路基礎篇

最新版本檢視：https://www.cnblogs.com/dotnetcrazy/p/9919202.html 入門篇 官方文件：https://docs.python.org/3/library/ipc.html（程序間通訊和網路） 例項程式碼：https://github.com/lotapp/

Python之路（十五）：網路程式設計（上）

python基礎之網路程式設計(上篇)   socket程式設計 　　本篇介紹socket是基於什麼來的，為什麼要知道網際網路底層實現通訊的原理 一、客戶端/服務端架構 即C/S架構，包括 1.硬體C/S架構(印表機) 2.軟體C/S架構(web

Java：網路程式設計基礎

網路通訊的三個條件 IP地址 網路中裝置的標識，不易記憶，可用主機名 埠 用於標識程序的邏輯地址，不同程序的標識 協議 通訊的規則，如TCP，UDP IP地址 IP地址的組成：網路號+主機號共4×8 32位 A類IP地址:第一段號碼為

Python網路程式設計之socket模組基礎例項

[linux 公社]https://www.linuxidc.com/Linux/2018-12/155920.htm 1、引言 本文呢主要對Python網路程式設計中用到的socket模組進行初步總結。首先從網路基礎理論出發，介紹了TCP協議和UDP協議；然後總結了sock

Python網路程式設計之socket模組基礎例項！

  TCP是流協議，而UDP是資料報協議。換句話說，TCP在客戶機和伺服器之間建立持續的開放連線，在該連線的生命期內，位元組可以通過該連線寫出（並且保證順序正確）。然而，通過 TCP 寫出的位元組沒有內建的結構，所以需要高層協議在被傳輸的位元組流內部分隔資料記錄和欄位。 UD

網路程式設計之：TCP伺服器的簡單實現

說到TCP伺服器，就不得不提socket程式設計，我們知道，在TCP/IP協議中,“IP地址+TCP或UDP埠號”唯一標識⽹絡通訊中的唯一一個程序,“IP地址+埠號”就稱為socket。 在TCP協

網路程式設計之WCF程式設計：WCF服務和客戶端的建立，回撥

1.概念 Windows Communication Foundation(WCF)是由微軟發展的一組資料通訊的應用程式開發介面，可以翻譯為Windows通訊介面。它是.NET框架的一部分，由 .NET Framework 3.0 開始引入。 WCF的終結點有三個要素組成

Boost.Asio C++ 網路程式設計之十：基於TCP的非同步服務端

       這個流程圖是相當複雜的：從Boost.Asio出來你可以看到4個箭頭指向on_accept，on_read，on_write和on_check_ping。這也就意味著你永遠不知道哪個非同步呼叫是下一個完成的呼叫，但是你可以確定的是它是這4個操作中的一個。基於TC

Boost.Asio C++ 網路程式設計之七：基於TCP的同步客戶端

      從本篇開始，我們會深入學習怎樣使用Boost.Asio建立更加複雜的客戶端和服務端應用。你可以執行並測試它們，而且在理解之後，你可以把它們做為框架來構造自己的應用。在接下來的例子中：1.客戶

Boost.Asio C++ 網路程式設計之二：同步和非同步

       首先，非同步程式設計和同步程式設計是截然不同的。在同步程式設計中，所有的操作都是順序執行的，比如從socket中讀取（請求），然後寫入（迴應）到socket中。每一個操作都是阻塞的。因為操作是阻塞的，所以為了不影響主程式，當在socket上讀寫時，通常會建立一個

Boost.Asio C++ 網路程式設計之五：TCP回顯客戶端/服務端

       回顯就是服務端將接收到的任何內容回發給客戶端顯示，然後關閉客戶端的連線。這個服務端可以處理任何數量的客戶端。每個客戶端連線之後傳送一個訊息，服務端接收到訊息後把它傳送回去。在那之後，服務端關閉連線。具體流程如下圖所示。        對於TCP而言，我們需要

Java網路程式設計之獲取IP地址：InetAddress類

示例程式碼： /* * 網路通訊的第一個要素：IP地址。通過IP地址，唯一的定位網際網路上一臺主機 * InetAddress:位於java.net包下 * 1.InetAddress用來代表IP地址。一個InetAdress的物件就代表著一個IP地址 * 2.如

Boost.Asio C++ 網路程式設計之九：基於TCP的非同步客戶端

       現在，是比較有趣（也比較難）的非同步實現！ 當檢視流程圖時，你需要知道Boost.Asio代表由Boost.Asio執行的一個非同步呼叫。例如do_read()，Boost.Asio和on_read()代表了從do_read()到on_read()的邏輯流程，