Institute of Information Science - University of Miskolc

User Tools

Site Tools

Trace:
tanszek:oktatas:iss_t:integration_based_on_tcp_ip_sockets

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision		Previous revision
tanszek:oktatas:iss_t:integration_based_on_tcp_ip_sockets [2023/05/08 18:53] – [Exercises] kneheztanszek:oktatas:iss_t:integration_based_on_tcp_ip_sockets [2024/02/25 15:43] (current) – [Blocking and non-blocking TCP sockets in Java] knehez
Line 27: Line 27:
 {{:tanszek:oktatas:iss_t:sockets-blocking-nonblocking.png?800|}} {{:tanszek:oktatas:iss_t:sockets-blocking-nonblocking.png?800|}}
  
-Reading: +Blocking and non-blocking TCP sockets differ mainly in handling input/output (I/O) operations, particularly regarding how a program's execution flow is managed when waiting for operations to complete. Here's a breakdown of the main differences: 
 + 
 +=== Blocking sockets === 
 + 
 +**Execution Flow**: In the case of blocking sockets, when a socket operation (like recv or send) is called, the program's execution is "blocked" until the operation completes. For example, if you call recv to read data from a socket, the call will wait forever until data is received. 
 + 
 +**Ease of Use**: Blocking sockets are straightforward to use and understand because the operations appear sequential and synchronous. The program will not proceed until the current operation finishes, simplifying the logic, especially for simple networked applications. 
 + 
 +**Performance Considerations**: While //blocking sockets// are easier to work with, they can lead to inefficient use of resources. For instance, if a server implemented with blocking sockets handles multiple connections, it would need //to spawn a new thread or process for each connection to avoid one operation blocking the entire server//. 
 + 
 +=== Non-Blocking sockets === 
 + 
 +**Execution Flow**: Non-blocking sockets, on the other hand, allow the program's execution to continue immediately, even if the socket operation cannot be completed at that moment. 
 + 
 +**Complexity**: Because the program continues to run even when data is not immediately available, using non-blocking sockets can lead to more complex program structures. Developers often use event loops or select/poll mechanisms to efficiently manage these sockets, especially when handling multiple connections simultaneously. 
 + 
 +**Performance and Scalability**: Non-blocking sockets can lead to more efficient and scalable applications. A single process or thread can manage multiple socket connections without spawning new threads or processes for each connection, using system resources better and enabling the server to handle many connections concurrently. 
 + 
 +Reading (Java implementations): 
  
   * http://tutorials.jenkov.com/java-nio/nio-vs-io.html   * http://tutorials.jenkov.com/java-nio/nio-vs-io.html
Line 41: Line 59:
        
    serverSocketChannel.socket().bind(new InetSocketAddress(9999));    serverSocketChannel.socket().bind(new InetSocketAddress(9999));
-   serverSocketChannel.configureBlocking(false);  // ez a sor jelzi a blokkolásmentes működést+   serverSocketChannel.configureBlocking(false);  // non blocking enabled
        
    while(true){    while(true){
Line 53: Line 71:
  
  
-===== Java examples ===== 
- 
-[[Java example for Blocking and Non-Blocking Socket]] 
- 
-[[HTTP server]] 
  
  
tanszek/oktatas/iss_t/integration_based_on_tcp_ip_sockets.1683572022.txt.gz · Last modified: 2023/05/08 18:53 by knehez