[Netwok/Netty]04. 사전에 파악할 용어

(출처 : https://shortstories.gitbooks.io/studybook/content/c8fc_c694_d2b9_c9d5.html
           
http://clairdelunes.tistory.com/62
           
http://homoefficio.github.io/2017/02/19/Blocking-NonBlocking-Synchronous-Asynchronous/)
대체적인 뜻만 파악하고 차후 하나씩 분석한다.


1. Sync 통신
    
특정 서비스를 요청하면 응답이 올 때 까지 기다리는 통신. 
    혹은 응답을 받아서 작업 완료 여부까지 요청하는 작업까지 진행한다.
    직관적 흐름을 추적할 수 있다.

2. Async 통신
    
특정 서비스를 요청하면 응답이 올 때 까지 기다리지 않고 다른 작업을 하고 있으면서, 완료여부에는 관심없는 통신.
    
메모리 자원의 효율적 활용이 가능. Future, Callback과 같은 패턴이 있음.

3. Blocking Socket
    
특정 서비스를 요청하면 요청받은 자가 작업이 모두 종료될 때까지 요청자에게 작업 제어권을 넘겨주지 않고 대기하는 상태.

4. Non-Blocking Sokect
    
특정 서비스를 요청한 직후 바로 응답을 받아서 남아있는 작업을 진행할 수 있는 제어권이 있는 Socket.
    
Sync/Async 는 '요청하는 자가 작업 완료에 대하여 신경을 쓰는가' 가 주 관심사이면
    
Blocking/Non-Blocking은 '요청하는 자가 요청 직후 바로 제어권을 바로 잡을 수 있는가' 가 주 관심사다.

5. Event Driven Network Programming
    
소켓을 이벤트의 주체로 하는 네트워크 프로그래밍. 데이터들을 소켓에 전달하는 핸들러를 이용한다.
    
기능별로 분리된 논리에 의하여 명확성이 있고 재사용성이 증가되며 오류의 부담이 완화되어있다.

6. Channel
    
일종의 소켓으로서 기존 Java의 Socket의 복잡함을 단순하게 작업하는 API들을 제공한다.

7. EventLoop
    
데이터가 교환하는 이벤트가 발생되어, 이를 처리하는 일련의 작업 순서를 생명주기라 부르겠다.
    EventLoop는 이러한 생명주기를 관리한다. 
이러한 EventLoop들이의 집합을 EventLoopGroup라 부른다.
    
EventLoop는 데이터 환이 진행되는동안 (생명주기가 돌고 있는동안) 에는 하나의 작업(Thread) 만을 담당한다.
    
EventLoop에서 처리되는 모든 입출력 동작은 해당 Thread에서 처리된다.
    
Channel은 EventLoop에 등록할 수 있다.

8. ChannelFuture
    Async 통신방식 특성에 따라 요청에 대한 응답이 바로 오지 않을 수 있다.
    따라서 그 결과를 확인하는 방법이 요구되는데, ChannelFuture는 이러한 실행에 대한 결과를 파악할 수 있도록 해준다.

9. OutBound, 당발
    
상대방이 아닌 본 Channel이 상대방에게 보낸다는 형용사.

10. InBound, 타발
    
상대방으로부터 본 Channel에게 보낸다는 형용사.

11. Handler
    당발, 타발 전송 할 때의 데이터를 관리한다.

12. PipleLine
    
Handler들의 Chainning하는 컨테이너를 제공하고 당발, 타발 이벤트를 전달한다.

13. Decoder
    
전문을 수신할 때 데이터를 변환한다.
    
당발 전문이 올 때, Byte에서 개발자가 지정한 다른 형태로 변환하는 작업을 한다.

14. Encoder
    
전문을 송신할 때 데이터를 변환한다.
    
타발 전문을 보낼 때, 해당 형태에서 Byte로 변환하는 작업을 한다.

15. Bootstrap
    
서버, 클라이언트를 구축한다. 사전적 의미는 한 번 시작하면 알아서 진행되는 일련의 과정이다.
    이 뜻에 따라  method chaning이 가능하다. 
일종의 기동을 하기위한 전체적인 틀 혹은 컨테이너.


[Netwok/Netty]03. ByteBuffer VS ByteBuf - ByteBuf

(출처 : https://netty.io/4.0/api/io/netty/buffer/ByteBuf.html)


1. 차이점

ByteBuffer는 capacity, limit, potion로 데이터를 읽고 썼다.
읽든 쓰든 position이 변경되고, flip을 통해 읽기와 쓰기를 하는데 있어 계산을 하면서 개발해야 한다. 
또한 capacity는 한번 지정하면 변경이 불가하기에 새로 객체를 생성해야된다.
그러니까 setCapacity(int capacity)같은 method가 없다는 의미.
게다가 capacity를 넘는 데이터를 입력하면 BufferOverflowException발생한다.

Bytebuf는 capacity, read index, write index만을 두고 있기 때문에
따로 flip이라는 동작을 하지 않아도 읽고 쓰는 작업에 편의성이 있다.
capacity를 변경하는 method를 지원한다. capacity를 넘는 데이터를 입력하면 2 제곱 단위로 증가후에 입력한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public class DiffernceBoth {
 
    public static void main(String[] args) {
        
        ByteBuffer byteBuffer = ByteBuffer.allocate(13);
        // java.nio.HeapByteBuffer[pos=0 lim=13 cap=13]
        System.out.println(byteBuffer);
        
        byteBuffer = ByteBuffer.allocate(14);
        // java.nio.HeapByteBuffer[pos=0 lim=13 cap=14]
        System.out.println(byteBuffer);
        
//        BufferOverflowException
//        byteBuffer.put("012345678912341".getBytes());
        
        
        ByteBuf byteBuf = Unpooled.buffer(13);
        // (ridx: 0, widx: 0, cap: 13)
        System.out.println(byteBuf);
        
        byteBuf.capacity(14);
        // (ridx: 0, widx: 0, cap: 14)
        System.out.println(byteBuf);
        
        // write 59 bytes
        byteBuf.writeBytes("This is byte array longer than previous capacity of byteBuf".getBytes());
        // (ridx: 0, widx: 59, cap: 64)
        System.out.println(byteBuf);
        
        byteBuf.capacity(14);
        // This is byte a
        System.out.println(byteBuf.toString(Charset.defaultCharset()));
        // (ridx: 0, widx: 14, cap: 14)
        System.out.println(byteBuf);
        
        
    }
 
}
cs


2. 객체생성
    
Unpooled.buffer(int initialCapacity)라는 method를 통해 생성하길 권장한다.
    실제로 생성자는 있지만 override해야 되는 method들이 많기 때문에 비효율적이다.
    (예제 소스를 쓰자니 overrided method가 워낙 많아서 생략)


3. read, write, clear
    ByteBuffer와 다른점은 없으나 읽을수 있는 byte와 쓸 수 있는 byte를 명확하게 보여주기 때문에 편의성이 있다.
    그리고 안에 내용들을 모두 초기화 하는 clear가 있다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public class ReadWrite {
 
    public static void main(String[] args) {
        
        ByteBuf byteBuf = Unpooled.buffer(12);
        // read : 0, write : 12
        System.out.print("read : " + byteBuf.readableBytes());
        System.out.println(", write : " + byteBuf.writableBytes());
 
        System.out.println("write 11 bytes");
        byteBuf.writeBytes("Hello world".getBytes());
        // read : 11, write : 1
        System.out.print("read : " + byteBuf.readableBytes());
        System.out.println(", write : " + byteBuf.writableBytes());
        
        System.out.println("read 4 bytes");
        byteBuf.readInt();
        // read : 7, write : 1
        System.out.print("read : " + byteBuf.readableBytes());
        System.out.println(", write : " +byteBuf.writableBytes());
        
        System.out.println("clear");
        byteBuf.clear();
        // read : 0, write : 12
        System.out.print("read : " + byteBuf.readableBytes());
        System.out.println(", write : " +byteBuf.writableBytes());        
        
        
    }
 
}
cs



[Netwok/Netty]02. ByteBuffer VS ByteBuf - ByteBuffer

(출처 : http://aoruqjfu.fun25.co.kr/index.php/post/561)

  1. Buffer
    사전적 의미는 완충을 말한다.
    컴퓨터 시스템의 어떤 장치에서 다른 장치로 전송을 할 때에, 
    일시적으로 그 데이터를 보관하는 일종의 메모리 영역이다.
    buffering이라 함은 buffer를 채우는 동작을 일컷는 말로서 유사어로 Queue가 있다.

  2. ByteBuffer
    Java NIO에서 제공되는 Buffer다.
    NIO의 Buffer는 다양한 자료형들을 관리하고있으며 내부의 배열상태를 관리한다.(ByteBuffer, CharBuffer, IntBuffer...)

  3. Buffer의 field
    • capacity
      Buffer에 저장할 수 있는 최대 크기. 한 번 지정하면 변경이 불가능하다.

    • position
      Buffer를 읽고 있는 현재 위치, Buffer를 쓰고 있는 현재 위치를 말한다.
      초기값은 0이고 읽고 쓸 때마다 증가된다. limit와 capacity보다 작거나 같다.

    • limit
      읽고 쓸 수 있는 공간의 최대치를 말한다. limit는 변경이가능하며 capacity보다는 크게 지정될 수 없다.

  4. Buffer의 method
    • public static ByteBuffer allocate(int capacity)
      capacity를 사용자가 직접 지정하고 position은 초기값으로 지정한다.
      limit는 capacity와 동일하게 입력된다. ByteBuffer를 새로 생성할 때 사용되며 JVM Heap에 생성한다.
      ByteBuffer의 하위 빈 HeapByteBuffer를 생성하는 셈이다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Allocate {
 
    public static void main(String[] args) {
        
        ByteBuffer byteBuffer = ByteBuffer.allocate(11);
 
        // java.nio.HeapByteBuffer[pos=0 lim=11 cap=11]
        System.out.println(byteBuffer);
        
        
        // 11 Bytes Put
        byte[] source = "Hello world".getBytes(); 
        byteBuffer.put(source);
 
        // java.nio.HeapByteBuffer[pos=1 lim=11 cap=11]
        System.out.println(byteBuffer);
    }
 
}
cs



    • public static ByteBuffer allocateDireact(int capacity)
      capacity를 사용자가 직접 지정하고 position은 초기값으로 지정한다.
      limit는 capacity와 동일하게 입력된다. ByteBuffer를 새로 생성할 때 사용되며 JVM Heap에 생성한다. 
      ByteBuffer의 하위 빈 MappedByteBuffer의 하위 빈 DirectByteBuffer를 생성하는 셈이다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class AllocateDirect {
 
    public static void main(String[] args) {
        
        ByteBuffer byteBuffer = ByteBuffer.allocateDirect(11);
        
        // java.nio.DirectByteBuffer[pos=0 lim=11 cap=11]
        System.out.println(byteBuffer);
        
        // true
        System.out.println(byteBuffer.isDirect());
 
    }
 
}
cs



    • public static ByteBuffer wrap(byte[] array)
      배열을 이용해서 객체를 생성한다. 이는 HeapByteBuffer를 이용한다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Wrap {
 
    public static void main(String[] args) {
        
        byte[] array = {123456789100};
        ByteBuffer byteBuffer = ByteBuffer.wrap(array);
 
        // java.nio.HeapByteBuffer[pos=0 lim=11 cap=11]
        System.out.print(byteBuffer);
        
        // false
        System.out.println(byteBuffer.isDirect());
        
    }
 
}
cs



    • public ByteBuffer put(byte b)
      현재 position을 기준으로 하여 byte를 write한다. 이후 position은 1 증가.
    • public byte get()
      현재 position을 기준으로 하여 byte를 read한다. 이후 position은 1 증가.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class ReadWrite {
 
    public static void main(String[] args) {
        
        ByteBuffer byteBuffer = ByteBuffer.allocate(11);
 
        // java.nio.HeapByteBuffer[pos=0 lim=11 cap=11]
        System.out.println(byteBuffer);
        
        
        
        byteBuffer.put((byte1);
        System.out.println("write 1 Byte");
        
        // java.nio.HeapByteBuffer[pos=1 lim=11 cap=11]
        System.out.println(byteBuffer);
        
        
        
        byteBuffer.get();            
        System.out.println("read 1 Byte");
        
        // java.nio.HeapByteBuffer[pos=2 lim=11 cap=11]
        System.out.println(byteBuffer);
        
    }
 
}
cs


    • public final Buffer rewind()
      position을 0으로 이동
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public class Rewind {
 
    public static void main(String[] args) {
        
        ByteBuffer byteBuffer = ByteBuffer.allocate(11);
 
        // java.nio.HeapByteBuffer[pos=0 lim=11 cap=11]
        System.out.println(byteBuffer);
        
        
        byteBuffer.put((byte10);
        System.out.println("write 1 Byte");
        // java.nio.HeapByteBuffer[pos=1 lim=11 cap=11]
        System.out.println(byteBuffer);
        
        
        byteBuffer.put((byte20);                            
        System.out.println("write 1 Byte");
        // java.nio.HeapByteBuffer[pos=2 lim=11 cap=11]
        System.out.println(byteBuffer);
        
        
        byteBuffer.rewind();
        System.out.println("rewind");
        // java.nio.HeapByteBuffer[pos=0 lim=11 cap=11]
        System.out.println(byteBuffer);
 
        
        byteBuffer.get();
        System.out.println("read 1 Byte");
        // java.nio.HeapByteBuffer[pos=1 lim=11 cap=11]
        System.out.println(byteBuffer);
        
        
    }
 
}
cs


    • public final Buffer flip()
      limit를 현재 position으로 두고, 현재 position을 0으로 변경
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class Flip {
 
    public static void main(String[] args) {
        ByteBuffer byteBuffer = ByteBuffer.allocateDirect(11);
 
        System.out.println(byteBuffer);
 
        byteBuffer.put((byte10);
        byteBuffer.put((byte20);
        byteBuffer.put((byte30);
        byteBuffer.put((byte40);
        System.out.println("write 4 Bytes");
        
        System.out.println(byteBuffer);
 
        System.out.println("flip");
        byteBuffer.flip();
 
        // 11 : 0 : 4
        System.out.println(byteBuffer);
    }
 
}
 
cs


+ Recent posts