TCP stream vs UDP message

问题:

TCP is stream oriented meaning data is transferred as a continues stream of bytes. But what confuses me is that TCP creates segments and passes this down to IP. IP creates packets encapsulates segments and transfers them. So where exactly the continuous stream here?

UDP on the other hand is message oriented. It receives messages from application layer, creates datagrams and pushes it down to IP. So far it is the same as TCP, instead a datagram created and pushed down. What makes this protocol a message oriented?

回答1:

The interface/API presented to you the user(programmer) of these protocols are:

UDP

Message oriented, you have an API (send/recv and similar) that provide you with the ability to send one datagram, and receive one datagram. 1 send() call results in 1 datagram sent, and 1 recv() call will recieve exactly 1 datagram.

TCP

Stream oriented, you have an API (send/recv and similar) that gives you the ability to send or receive a byte stream. There is no preservation of message boundaries, TCP can bundle up data from many send() calls into one segment, or it could break down data from one send() call into many segments - but that's transparent to applications sitting on top of TCP, and recv() just gives you back data, with no relation to how many send() calls produced the data you get back.

回答2:

TCP is a connection-oriented protocol meaning it first sets up a connection to the receiver then sends the data in segments (PDU for transport layer) which is carried by IP packets. This way it's called stream because it keeps the stream of data between to ends during transfer.

UDP is a connection-less transport protocol (just like IP) with data unit called datagram. So unlike tcp, UDP transfers data without setting up a connection just sending down datagram messages to IP layer in order to be transferred.

回答3:

TCP is stream oriented because it is able to assemble data in contiguous format. E.g. you had data from number 1 to 4000 bytes. Now it will be divided into tcp segments where each segment would have a sequence number say first is 1-1200 byte, second is 1201 - 2400 and so on.

It might be delivered out of order while being sent through ip datagrams but is assembled into contiguous data latter there by appearing as a stream. The sequence number helps to reorder packets.

A little deeper explaination is:

A byte stream consist of one big chunk of data with no segments or other irregularities. With datagrams (smaller) data chunks are send and received at once as a whole. In practice it means that with datagrams each send/write call sends one packet, and each read/recv call receives one packet, while with stream protocol the data can be send and received in any way. E.g. A sender can call send() ten times, while the receiver receives all that data with one recv call. With datagrams ten send calls means ten packets and ten receive calls

Datagrams and streams

Byte streams

回答4:

The specialty about TCP is that this behaviour is transparent to the user resp. the app.

The only thing the app has to do is call send() and recv() on order to send and get data.

The layers below ensure that the data is received in exactly the order it was sent, and that missing data is retransmitted if it "stays missing".

UDP, OTOH, keeps the data of one send() call together, even if it is split into several IP packets. In this way, these data can be seen as one datagram.

回答5:

Lot of confusion here. Let me clarify.

TCP/IP is a stream-oriented, Packet and Connection oriented protocol. UDP is just a packet-oriented protocol. Doesn't establish connection first.

Let us say that you are you using a Java program to connect to a network in your application by calling java.net.Socket class on the client side and java.net.ServerSocket on the server side. Once the connection is established the data transmission starts. The question comes, is the data sent in stream (Codata or infinite stream) or packet if I chose TCP? The answer is data received by the TCP method is stream but TCP converts stream into packet before sending the lower lavel stack. Basically, the application layer above sends the data in stream to the TCP layer and TCP breaks it down into packets to the network layer, and performs packet-to-streaming while receiving fro the server (receiving) side because your application Java can understand only Stream. File transmission is preferred via TCP over UDP because you can't afford losing of packets.

UDP, on the other hand, is a packet-oriented protocol where the application such as Java class java.net.DatagramPacket; java.net.DatagramPacket; import java.net.DatagramsSocket creates a packet first before talking to UDP, and the packet is sent out with additional information by UDP/IP protocols to the server side. Note, some applications might present the data as a stream when the underlying protocol is UDP. However, this is the layering of an additional protocol on top of UDP, and it is not something inherent in the UDP protocol itself. Live straming of TV is generally UDP because you are not worried about loss of packets.