Developer Ahn

• 1_불변 객체(Immutable Object)
  : String은 이미 불변 객체로 정의돼있다.

   
  package kr.co.ioacademy; //iocademy 윤찬식 강사님
  
  // Java 의 클래스 = 레퍼런스 타입
  // : 객체는 힙에 생성된다.
  
  // Immutable Object(불변 객체)
  // 장점
  // 1. 생성자의 방어 복사 및 접근 메소드의 방어 복사가 필요없다.
  // 2. 병렬 프로그래밍을 작성할 때, 동기화 없이 객체를 공유 가능하다.
  //   "특별한 이유가 없다면 객체를 불변 객체로 설계해야 한다."
  //    : Effective Java, Effective Objective-C
  
  // 단점
  // 객체가 가지는 값마다 새로운 객체가 필요하다.
  // String s += "xxx";   // "Helloxxx"
  //  : 내용이 동일한 객체는 공유되는 메커니즘을 제공해야 한다.(Flyweight)
  //    - static factory method
  
  // 불변 클래스를 만드는 방법
  // 1. 객체를 변경하는 setter 를 제공하지 않습니다.
  // 2. 모든 필드를 final
  // 3. 가변 객체 참조 필드를 사용자가 얻을 수 없도록 해야 한다 (private)
  // 4. 상속 금지 (final class, final method, 생성자를 private 으로 정의하고 public static factory method를 제공)
  
  public class Example1 {
      public static void main(String[] args) {
          Point pos = new Point(10, 20);
  
          // Integer i;
  
          Rect r = new Rect(pos);
          // pos.setY(100);    // 공격!
  
          pos = r.getPosition();
          // pos.setX(-9999);
  
          String s = r.getName();
          s = "xxx";
  
          System.out.println(r);
      }
  }
  
  // String, Integer, Long ... : Immutable Object
  
  class Rect {
      // 캡슐화, 정보 은닉
      private final Point position;
      private String name;
  
      public Rect(Point position) {
          this.position = position.clone();
          this.name = "Tom";
      }
  
      public String getName() {
          return name;
      }
  
      public Point getPosition() {
          return position.clone();
      }
  
      @Override
      public String toString() {
          return "Rect{" +
                  "position=" + position +
                  ", name='" + name + '\'' +
                  '}';
      }
  }
  
  
  class Point implements Cloneable {
      final int x;
      final int y;
  
      @Override
      public Point clone() {
          try {
              return (Point) super.clone();
          } catch (CloneNotSupportedException e) {
              e.printStackTrace();
          }
          return null;
      }
  
  
      public Point(int x, int y) {
          this.x = x;
          this.y = y;
      }
  
      public int getX() {
          return x;
      }
  
      public int getY() {
          return y;
      }
      /*
      public void setX(int x) {
          this.x = x;
      }
  
      public void setY(int y) {
          this.y = y;
      }
      */
  
      @Override
      public String toString() {
          return "Point{" +
                  "x=" + x +
                  ", y=" + y +
                  '}';
      }
  }
  

  
  

• 2_불변 객체
  : final로 선언된 배열은 변하지 않지만, 배열 안의 데이터가 변할수 있다. -> VALUES 는 변하지 않지만 VALUE 안에 데이터가 변할수가 있다.

   
  package kr.co.ioacademy; //iocademy 윤찬식 강사님
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.Collections;
  
  public class Example2 {
      /*
      private static final Integer[] VALUES =
              { 1, 2, 3, 4, 5 };
  
      // 해결 방법 1. 방어 복사본
      public static Integer[] values() {
          return VALUES.clone();
      }
      */
  
      // 해결 방법 2. 수정불가 컬렉션 사용 - UnsupportedOperationException
      private static final Integer[] PRIVATE_VALUES = {1, 2, 3, 4, 5};
      public static final Collection<Integer> VALUES =
              Collections.unmodifiableCollection(Arrays.asList(PRIVATE_VALUES));
  
      public static void main(String[] args) {
          Collection<Integer> arr = Example2.VALUES;
          arr.add(10);
  
          for (Integer e : VALUES) {
              System.out.println(e);
          }
      }
  }
  

  
  

• 객체 비교
  - 1_equals 재정의

  package kr.co.ioacademy; //iocademy 윤찬식 강사님
  
  import java.util.Objects;
  
  // 1. Object.equals()를 재정의하지 않을 경우
  // 모든 객체는 오직 자기 자신과 동일하다.
  
  // 2. 객체 동일성이 아닌 논리적 동일성의 개념을 제공하기 위해서는
  // equals()를 재정의해야 한다.
  
  class Point {
    private int mX;
    private int mY;
  
    public Point(int x, int y) {
      this.mX = x;
      this.mY = y;
    }
  
    @Override
    public int hashCode() {
      final int prime = 31;
      int result = 1;
      result = prime * result + mX;
      result = prime * result + mY;
      return result;
    }
  
    @Override
    public boolean equals(Object obj) {
      // 1. 자기 자신인지 검사 - 성능
      if (this == obj) return true;
      // 2. null 인지 체크 (모든 객체는 null과 동치 관계가 있지 않다.)
      if (obj == null) return false;
      // 3. 인자의 자료형이 정확한지 검사.
      if (!(obj instanceof Point)) return false;
      // 4. 자료형 변환
      Point p = (Point) obj;
  
      // 5. 중요 필드 점검
      return mX == p.mX && mY == p.mY;
    }
  }
  
  
  class Unit {
    private Point position;
    private Point start;
  
    // 1. 객체에 대한 참조는 null이 될 수 있다.
    // 필드가 많아지면 Objects.equal을 고려하자.(Google Guava / 1.7)
  
  
    @Override
    public boolean equals(Object obj) {
      if (obj == this) return true;
      if (obj == null) return false;
      if (!(obj instanceof Unit)) return false;
  
      Unit p = (Unit) obj;
      // if (position == null) {
      // if (p.position != null) return false;
      // } else if (!position.equals(p.position)) return false;
      // return true;
  
      return Objects.equals(position, p.position) && Objects.equals(start, p.start);
    }
  }
  
  public class Example5 {
    public static void main(String[] args) {
      Point p1 = new Point(10, 20);
      Point p2 = new Point(10, 20);
  
      if (p1.equals(p2)) {
        System.out.println("Same");
      } else {
        System.out.println("Not Same");
      }
    }
  
  }
  

  
  - 2_BigDecimal, 배열 비교
  : 컴퓨터는 태생적으로 부동소수점을 정확히 표현할 수 없다.(2진수로 표현하기 때문에...)
  : float, double은 == 로 비교하면 안된다. -> BigDecimal 사용
  : 배열의 내용 비교 -> Arrays.equals()

  package kr.co.ioacademy; //iocademy 윤찬식 강사님
  
  import java.math.BigDecimal;
  import java.util.Arrays;
  
  // 1. float이나 double은 ==으로 비교하면 안된다.
  // 2. 정밀한 연산을 필요로 한다면 BigDecimal 을 사용해야 한다.
  public class Example6 {
    public static void main(String[] args) {
  
      double value1 = 2.0 - 1.1;
      double value2 = 0.9;
  
      // if (value1 == value2) {
      if (Math.abs(value1 - value2) < 0.001) {
        System.out.println("same");
      } else {
        System.out.println("not same");
      }
  
      BigDecimal v = new BigDecimal(2.0).subtract(new BigDecimal(1.1));
      System.out.println(v);;
  
      // 주의 사항 : BigDecimal(String)의 생성자를 사용해야 한다.
      BigDecimal v2 = new BigDecimal("2.0").subtract(new BigDecimal("1.1"));
      System.out.println(v2);;
  
      //-------------------------------------------------
      // 3. 배열 내용을 비교하려면 Object.equals() 가 아닌 Arrays.equals()
      //    사용해야 한다.
      int[] arr1 = new int[20];
      int[] arr2 = new int[20];
  
      System.out.println(arr1.equals(arr2));
  
      System.out.println(Arrays.equals(arr1, arr2));
    }
  }


- 3_hashCode
 : Google Guava를 사용하여 toString 재정의


package kr.co.ioacademy; //iocademy 윤찬식 강사님

import java.util.HashMap;
import java.util.Map;
import java.util.Objects;

import com.google.common.base.MoreObjects;


// 핵심 : 같은 객체는 동일한 해시 코드 값을 가져야 한다.
// 즉 equals를 재정의한 클래스는 반드시 hashCode도 재정의해야 한다.
// 그래야 HashMap, HashSet, HashTable 등 hash 기반 컬렉션과 함께 사용하면 오동작 하지 않는다.

public class Example7 {
  public static void main(String[] args) {
    Map<Person, String> m = new HashMap<>();

    m.put(new Person("Tom", 42), "Google");

    System.out.println(m.get(new Person("Tom", 42)));

    // toString()을 잘 만들어 놓으면 편리하다.
    System.out.println(new Person("IU", 42));
  }
}


class Person {
  private String name;
  private int age;

  public Person(String name, int age) {
    this.name = name;
    this.age = age;
  }

  @Override
  public String toString() {
    return MoreObjects.toStringHelper(this).add("name", name).add("age", age).toString();
  }

  @Override
  public int hashCode() {
    // equals 에 이용된 중요 필드를 이용해서 hash를 생성하면 된다.
    return Objects.hash(name, age);
  }

  @Override
  public boolean equals(Object o) {
    if (o == this) return true;
    if (o instanceof Person) {
      Person p = (Person) o;
      return Objects.equals(name, p.name) && age == p.age;
    }

    return false;
  }
}





• 객체 복제
  : 인자 전달 방식
   -> Call-by-Value vs. Call-by-Reference
  

  : 객체 복사 방식
   -> 얕은 복사(Shallow Copy) vs. 깊은 복사(Deep Copy)
  

  

  class Num {
  	public int num;
  	
  	public Num(int num) {
  		this.num = num;
  	}
  }
  
  public class CallBy {
  	
  	// 값을 복사해서 인자 전달
  	// value는 객체에 대한 레퍼런스 값, 프리미티브 타입의 값
  	public void callByValue(int a, int b) { 
  		System.out.println("callByValue in method: " + a + " " + b);
  		int swap = a;
  		a = b;
  		b = swap;
  		System.out.println("callByValue out method: " + a + " " + b);
  		
  	}
  	
  	// 해당 객체를 참조하는 객체를 복사해서 인자 전달(얕은 복사)
  	// 해당 객체의 주소값을 직접 넘기는 것이 아니라 객체를 가리키고 있는 또 다른 주소값을 만들어서 넘긴다
  	void callByReference(Num a, Num b) {
  		System.out.println("callByReference in method: " + a.num + " " + b.num);
  		Num swap = a;
  		a = b;
  		b = swap;
  		System.out.println("callByReference out method: " + a.num + " " + b.num);
  	}
  	
  	// 객체의 멤버 필드값에 대한 복사가 필요(깊은 복사)
  	void callByReference2(Num a, Num b) {
  		System.out.println("callByReference2 in method: " + a.num + " " + b.num);
  		int swap = a.num;
  		a.num = b.num;
  		b.num = swap;
  		System.out.println("callByReference2 out method: " + a.num + " " + b.num);
  	}
  	
  	public static void main(String[] args) {
  		CallBy call = new CallBy();
  		
  		int a = 5;
  		int b = 10;
  		
  		Num n1 = new Num(5);
  		Num n2 = new Num(10);
  		
  		call.callByValue(a, b);
  		System.out.println("callByValue main method: " + a + " " + b + "\n");
  		//callByValue in method: 5 10
  		//callByValue out method: 10 5
  		//callByValue main method: 5 10
  		
  		call.callByReference(n1, n2);
  		System.out.println("callByReference main method: " + n1.num + " " + n2.num + "\n");
  		//callByReference in method: 5 10
  		//callByReference out method: 10 5
  		//callByReference main method: 5 10
  		
  		call.callByReference2(n1, n2);
  		System.out.println("callByReference2 main method: " + n1.num + " " + n2.num);
  		//callByReference2 in method: 5 10
  		//callByReference2 out method: 10 5
  		//callByReference2 main method: 10 5
  		
  	}
  }
  

  
  - 1_clone, Cloneable
   : 객체에 대한 깊은 복사
   : 상속을 해주기 위한 클래스를 설계할 때, 잘 동작하는 protected clone 메소드를 그 클래스에 두지 않는다면 서브 클래스에서 Cloneable 인터페이스를 제대로 구현할 수 없다.
  

  package kr.co.ioacademy; //iocademy 윤찬식 강사님
  
  import com.google.common.base.MoreObjects;
  
  class Point implements Cloneable {
    private int x;
    private int y;
  
    public Point(int x, int y) {
      this.x = x;
      this.y = y;
    }
  
    public int getX() {
      return x;
    }
  
    public void setX(int x) {
      this.x = x;
    }
  
    public int getY() {
      return y;
    }
  
    public void setY(int y) {
      this.y = y;
    }
  
    @Override
    public String toString() {
      return "(" + x + ", " + y + ")";
    }
  
    @Override
    public Point clone() {
      try {
        return (Point) super.clone();
      } catch (CloneNotSupportedException e) {
        e.printStackTrace();
      }
  
      return null;
    }
  }
  
  // 객체 복제 하기
  // 1. clone() 함수를 오버라이드 한다. (protected -> public)
  // : 오버라이딩할 메소드는 부모의 접근 제한자와 같거나 접근하기 더 쉬워야 한다.
  
  // 2. Cloneable 인터페이스를 구현해야 한다.
  // : 어떤 객체가 복제를 허용한다는 사실을 알리는데 쓰이는 용도이다.
  
  
  // 객체가 Cloneable 인터페이스를 구현하고 있으면, Object.clone() 은
  // 객체가 가지고 있는 모든 멤버를 복사한다.
  class Unit implements Cloneable {
    private String name;
    private int age;
  
    private Point position;
    // 중요 : 변경 가능 객체에 대한 참조를 가지고 있으면 문제가 발생한다.
  
    public Unit(String name, int age, Point pos) {
      this.name = name;
      this.age = age;
      this.position = pos;
    }
  
    public void setPos(int x, int y) {
      position.setX(x);
      position.setY(y);
    }
  
    
    // public Object clone() {
    // 공변 반환형 : 재정의 메소드의 리턴 타입은 재정의 되는 메소드의
    // 리턴 타입의 하위 클래스가 될 수 있다.(1.5)
    //  @Override
    //  public Unit clone() {
    //    try {
    //      return (Unit) super.clone();
    //    } catch (CloneNotSupportedException e) {
    //      e.printStackTrace();
    //    }
    //
    //    return null;
    //  }
  
    @Override
    public Unit clone() {
      try {
        // 1. 전체 복사 후
        Unit result = (Unit) super.clone();
  
        // 2. 변경 가능 객체 복제
        result.position = position.clone();
        return result;
  
      } catch (CloneNotSupportedException e) {
        e.printStackTrace();
      }
  
      return null;
    }
  
    @Override
    public String toString() {
      return MoreObjects.toStringHelper(this).add("name", name).add("age", age)
          .add("pos", position).toString();
    }
  }
  
  
  public class Example8 {
    public static void main(String[] args) {
      Unit p1 = new Unit("Tom", 42, new Point(0, 0));
  
      // Unit p2 = (Unit) p.clone();
      Unit p2 = p1.clone();
  
      p2.setPos(10, 20); // !!!
  
      System.out.println(p1);
      System.out.println(p2);
    }
  }
  

  
  - 2_생성자 방어 복사
   : 접근자를 이용하여 클라이언트가 값을 변경할 수 있다. -> 캡슐화가 깨짐
   : 객체를 복사할 때 객체의 참조를 리턴하는 것이 아니라 객체의 복사본을 리턴한다. pos.setX(9999)로 x값을 변경해도 복사한 객체의 값을 바꾸므로 기존의 객체의 값은 그대로 유지된다.
  

  package kr.co.ioacademy; //iocademy 윤찬식 강사님
  
  import com.google.common.base.MoreObjects;
  
  public class Example9 {
    public static void main(String[] args) {
      
      // 1. 생성자 방어 복사가 필요하다.
      //  : 인자의 유효성을 검사하기 전에 복사하고 나서, 
      //    원본이 아닌 복사본의 유효성을 검사해야 한다.
      Point pos = new Point(100, 200);
      // Unit unit = new Unit(pos);
      
      
      String name = "Tom";
      Unit unit = new Unit(pos, name);
      
      pos.setX(9999);
      
      // 2. 접근자 메소드에서도 참조를 방어 복사하여 리턴해야 한다.
      pos = unit.position();
      pos.setX(9999);
  
      System.out.println(unit);
    }
  }
  
  
  class Unit {
    private Point position;
    private String name;
    
    public Unit(Point pos, String name) {
      position = pos.clone();
      // position = pos;
      this.name = name;
    }
  
    public String name() {
      return name;
    }
    
    public Point position() {
      return position.clone();
    }
  
    @Override
    public String toString() {
      return MoreObjects.toStringHelper(this)
          .add("pos", position).add("name", name).toString();
    }
  
  }
  
  
  class Point implements Cloneable {
    private int x;
    private int y;
  
    public Point(int x, int y) {
      this.x = x;
      this.y = y;
    }
  
    public int getX() {
      return x;
    }
  
    public void setX(int x) {
      this.x = x;
    }
  
    public int getY() {
      return y;
    }
  
    public void setY(int y) {
      this.y = y;
    }
  
    @Override
    public String toString() {
      return "(" + x + ", " + y + ")";
    }
  
    @Override
    public Point clone() {
      try {
        return (Point) super.clone();
      } catch (CloneNotSupportedException e) {
        e.printStackTrace();
      }
  
      return null;
    }
  }
  

  
  

• 1_명시적 자원 해지
  

  package kr.co.ioacademy; //iocademy 윤찬식 강사님
  
  import java.awt.Image;
  import java.io.IOException;
  import java.net.URL;
  
  import javax.imageio.ImageIO;
  
  // 핵심 : 객체 내부에서 비 메모리 자원을 사용한다면 명시적 종료 메소드를 제공해야 한다.
  // 이유
  // 1. 가비지 컬렉션은 메모리만 수집한다.
  // 2. 가비지 컬렉션이 수거하지 않는 비 메모리 자원에 대해서는
  // 프로그래머가 관리 해야 한다.
  
  // 3. finalize() - 종료자
  // 개념 : 더 이상 참조할 수 없는 객체의 메모리 공간을 회수 할 때 GC에 의해서 호출되는 메소드
  // 문제 : finalize()를 비 메모리 자원을 정리하는 용도로 사용하면 안된다.
  // 1. 즉시 실행된다는 보장이 없다.
  // 예) 종료자 안에서 파일 닫기. - JVM은 종료자를 천천히 실행하므로,
  // 열린 상태의 파일이 많이 남아 있을 수 있다.
  // 한번에 열 수 있는 파일의 개수에 제한이 있으므로 오류가 날 수 있다.
  // - 종료자의 실행 시점은 JVM의 구현에 의존한다.
  
  // 2. 반드시 실행된다는 보장도 없다.
  // - 자바 명세에는 종료자가 즉시 실행되어야 한다는 문구도 없지만,
  // 종료자가 반드시 실행되어야 한다는 문구도 없다.
  // 즉 종료자가 실행되지 않은 객체가 남은 상태로 프로그램이 종료할 수도 있다.
  // (동기화 객체 같은 것을 절대 종료자를 통해 반납하면 안된다)
  
  
  class WebPhoto {
    Image image;
  
    // 명시적인 종료 메소드 - OutputStream, InputStream, Socket 등
    public void release() {
      if (image != null) {
        image.flush();
      }
    }
  
    public WebPhoto(String imageUrl) {
      URL url;
      try {
        url = new URL(imageUrl);
        image = ImageIO.read(url);
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  }
  
  
  public class Example1 {
    public static void main(String[] args) throws InterruptedException {
      // WebPhoto가 더 이상 사용되지 않는다면, 객체 내부에서 사용하고 있는
      // 자원에 대해서 정리가 필요하다.
      WebPhoto photo = new WebPhoto("http://cfs7.tistory.com/image/14/tistory/2008/08/29/04/53/48b702410053a");
  
      // photo = null;
      // photo.release();
  
      // System.gc();
    }
  }
  




• 2_finalize

  package kr.co.ioacademy; //iocademy 윤찬식 강사님
  
  import java.awt.Image;
  import java.io.IOException;
  import java.net.URL;
  
  import javax.imageio.ImageIO;
  
  // finalize()의 용도
  // : 명시적 종료 메소드 호출을 잊은 경우의 안정망을 제공할 수 있다.
  
  // 1. 그런 자원을 발견한 경우 반드시 경고 메세지를 남겨야 한다. (클라이언트 코드에 버그가 있는 것이므로)
  // 2. 부모의 종료자를 명시적으로 호출해야 한다.
  
  class WebPhoto {
    Image image;
  
    /*
    @Override
    public void finalize() {
      if (image != null) {
        System.err.println("Explicit termination method 'release' is not called");
        release();
      }
    }
    */
    
    @Override
    public void finalize() throws Throwable {
      try {
        if (image != null) {
          System.err.println("Explicit termination method 'release' is not called");
          release();
        }
      } finally {
        super.finalize();
      }
    }
    
    // 명시적인 종료 메소드 - OutputStream, InputStream, Socket 등
    public void release() {
      if (image != null) {
        image.flush();
      }
    }
  
    public WebPhoto(String imageUrl) {
      URL url;
      try {
        url = new URL(imageUrl);
        image = ImageIO.read(url);
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  }
  
  
  public class Example2 {
    public static void main(String[] args) throws InterruptedException {
      WebPhoto photo = new WebPhoto("https://t1.daumcdn.net/cfile/tistory/2761F44856D7F79F2A");
      // System.gc();
    }
  }
  




• 3_finalize2

  package kr.co.ioacademy; //iocademy 윤찬식 강사님
  
  import java.awt.Image;
  import java.io.IOException;
  import java.net.URL;
  
  import javax.imageio.ImageIO;
  
  // 명시적 자원 해지가 필요한 클래스는 결국 중복된 코드를 작성해야 한다.
  
  // 종료자의 역활을 일반화한 클래스
  final class CloseGuard {
    public static CloseGuard get() {
      return new CloseGuard();
    }
  
    private CloseGuard() {}
  
    private Throwable site;
  
    public void open(String closer) {
      if (closer == null) throw new NullPointerException("closer == null");
  
      String message = "Explicit termination method '" + closer + "' not called";
      site = new Throwable(message);
    }
  
    public void close() {
      site = null;
    }
  
    public void warnIfOpen() {
      if (site == null) return;
  
      System.err.println(site.toString());
    }
  }
  
  
  class WebPhoto {
    private Image image;
  
    // Surface.java
    private final CloseGuard mCloseGuard = CloseGuard.get();
  
    @Override
    public void finalize() throws Throwable {
      try {
        if (mCloseGuard != null) mCloseGuard.warnIfOpen();
        release();
  
      } finally {
        super.finalize();
      }
    }
  
    public void release() {
      if (image != null) {
        image.flush();
      }
  
      if (mCloseGuard != null) mCloseGuard.close();
    }
  
    public WebPhoto(String imageUrl) {
      URL url;
      try {
        url = new URL(imageUrl);
        image = ImageIO.read(url);
  
        mCloseGuard.open("release");
  
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  }
  
  
  public class Example3 {
    public static void main(String[] args) {
      WebPhoto photo = new WebPhoto("https://t1.daumcdn.net/cfile/tistory/2761F44856D7F79F2A");
      // System.gc();
    }
  }
  




• 4_finalize3
  : Finalizer Guardian Idiom(종료자 보호 패턴)
  : Image를 상속 받은 클래스(MyImage)의 객체 생성 -> 상위 클래스 Image 객체도 생성 -> MyImage 객체가 GC에 의해 해지 당할 때 하 상위 클래스(Image)의 guardian이란 멤버 변수도 해지 대상이 되고, 여기서 finalize() 호출

  package kr.co.ioacademy; //iocademy 윤찬식 강사님
  
  
  class Image {
  
    public void release() {
      System.out.println("Image 자원 해지");
    }
  
  //  @Override
  //  protected void finalize() throws Throwable {
  //    try {
  //      System.out.println("Image finalize!");
  //      release();
  //    } finally {
  //      super.finalize();
  //    }
  //  }
  
    // 하위 클래스가 부모 클래스의 finalize()를 잊는 문제를
    // 방지하는 방법. - (종료자 보호 패턴)Finalizer Guardian Idiom
    @SuppressWarnings("unused")
    private final Object guardian = new Object() {
      @Override
      protected void finalize() throws Throwable {
        release();
      }
    };
  }
  
  class MyImage extends Image {
  
    @Override
    protected void finalize() throws Throwable {
      System.out.println("MyImage finalize!");
      // 잊었다.!!!
      // super.finalize();
    }
  }
  
  
  public class Example4 {
    public static void main(String[] args) throws InterruptedException {
      MyImage image = new MyImage();
      image = null;
  
      System.gc();
  
      Thread.sleep(10000);
    }
  }
  

• Spring-Test 사용하기

junit을 java에서 사용하기 위해서는 2가지 라이브러리가 필요하다.

junit.jar와 hamcrest-core.jar가 필요하다. 다운은 https://github.com/junit-team/junit/wiki/Download-and-Install 여기서 받을 수 있고, junit 공식 사이트는 http://junit.org/

junit 사용법을 설명하기 전에 Printer 예제를 만들어보았다. 

Printer 예제는 git소스를 참고하고 설명은 하지 않겠다. 사실 junit 사용법만 익히기 위해서 Printer 예제는 볼 필요없다. 아래 설명한 어노테이션만 잘 숙지하면 된다.

아래는 Printer를 테스트하는 테스트 코드이다.

• @Before : @Test 메소드가 있는 클래스는 @Test 메소드가 실행 될 때마다 객체가 생성되고 실행된다. 쉽게 말해서 @Test 메소드가 2개라면 2번 실행하기 위해 객체 생성을 2번한다는 말이다. @Before 메소드는 @Test 메소드가 실행되기 전에 반드시 실행되게한다. @Test 메소드가 마다 공통으로 사용하는 데이터를 @Before 메소드에서 실행하는 것인데, 여기서 공통으로 사용하는 데이터를 fixture라고 한다.
• @BeforeClass : @Before에서 설명 했듯이 @Test 메소드 실행 할 때마다 객체를 생성한다고 설명했는데, 이때 생성되는 객체가 최초에 한번만 실행되는 어노테이션이다.
• @After : @Test 메소드가 실행된 후 실행된다. 
• @AfterClass : 객체가 최초 한번 생성 된 후 실행된다.
• @Test : @Test 메소드는 테스트를 수행하는 메소드다. 아래 예제에 expected가 붙은 @Test가 있는데 이는 예외 상황을 테스트 하기 위한 기능이다.
• @Ignore : 테스트를 실행하지 않게 한다. @Test가 붙어 있지만, @Ignore가 붙어 있는 메소드라면 테스트 대상 메소드가 아니다.

• 1_생성자

  package kr.co.ioacademy; //iocademy 윤찬식 강사님
  
  // 객체를 생성하는 방법.
  // 1. 생성자
  //  a. 생성자 메소드의 이름은 클래스의 이름과 같다.
  //  b. 생성자의 오버로딩은 한계가 있다.
  class RandomIntGenerator {
  	final int min;
  	final int max;
  	
  	public RandomIntGenerator(int min, int max) {
  		this.min = min;
  		this.max = max;
  	}
  
  	public RandomIntGenerator(int min) {
  		this.min = min;
  		this.max = Integer.MAX_VALUE;
  	}
  	
  	// 1. 동일한 인자를 받는 다른 형태의 객체 생성 방법을 제공할 수 없다.
  	// public RandomIntGenerator(int max) {}
  }
  
  public class Example1 {
  	public static void main(String[] args) {
  		// 2. 객체를 생성하는 코드를 통해서 어떤 객체가 생성되는지를 절대 알 수 없다.
  		RandomIntGenerator obj1 = new RandomIntGenerator(0, 100);
  		RandomIntGenerator obj2 = new RandomIntGenerator(0);
  	}
  }
  



• 2_정적 팩토리 메소드(static factory method)

  package kr.co.ioacademy; //iocademy 윤찬식 강사님
  
  // 2. 객체를 생성하는 방법 2. 
  //  : 정적 팩토리 메소드(static factory method)
  //   정의 : 객체를 생성할 때 생성자가 아닌 정적 메소드를 통해 생성하자.
  
  //  단점
  //  1. 상속을 통한 기능 변경이 불가능하다. (테스트가 힘들다)
  //  2. 이름을 잘 지어야 한다. 
  
  class RandomIntGenerator {
  	final int min;
  	final int max;
  
  	// private 이므로 외부에서 접근이 불가능하다.
  	private RandomIntGenerator(int min, int max) {
  		this.min = min;
  		this.max = max;
  	}
  
  	// 객체를 생성하는 다양한 정적 메소드를 제공하자.
  	// 장점 1. 정적 팩토리 메소드는 결국 메소드 이므로 이름에 제한이 없다.
  	public static RandomIntGenerator between(int min, int max) {
  		return new RandomIntGenerator(min, max);
  	}
  
  	public static RandomIntGenerator biggerThan(int min) {
  		return new RandomIntGenerator(min, Integer.MAX_VALUE);
  	}
  
  	public static RandomIntGenerator smallerThan(int max) {
  		return new RandomIntGenerator(Integer.MIN_VALUE, max);
  	}
  
  	// 장점 3. 생성자처럼 매번 생성할 필요가 없다.
  	// Integer.valueOf(3), Long.valueOf(3)
  	private static final RandomIntGenerator INSTANCE 
  	 = new RandomIntGenerator(Integer.MIN_VALUE, Integer.MAX_VALUE);
  	public static RandomIntGenerator getInstance() {
  		return INSTANCE;
  	}
  }
  
  public class Example2 {
  	public static void main(String[] args) {
  		// 장점 2. 라이브러리 사용자들은 객체가 어떤 정책을 가지고 생성되는지
  		// 이름을 통해 쉽게 이해할 수 있다.
  		RandomIntGenerator obj1 = RandomIntGenerator.between(0, 100);
  		RandomIntGenerator obj2 = RandomIntGenerator.smallerThan(100);
  		RandomIntGenerator obj3 = RandomIntGenerator.biggerThan(0);
  	}
  }
  




• 3_불필요한 객체 생성
  : Junit test 결과 testLong2() 는 오토박싱을 통해 객체를 계속 생성한다. -> testLong()에 비해 현저히 느리다.

   
   package kr.co.ioacademy; //iocademy 윤찬식 강사님
  
  import org.junit.Test;
  
  public class Example3 {
  	public static void main(String[] args) {
  
  		// 불필요한 객체가 생성된다.
  		String s1 = new String("hello");
  
  		String s2 = "hello";
  		// 같은 가상 머신에서 실행되는 모든 코드가 해당 객체를 재사용한다.
  		// 불변 객체 ( Immutable object ): 불변객체는 생성 후에는 변하지 않는 object 로, 언제든 재사용이 가능
  		// 불변객체의 불필요한 객체 생성을 막으려면 생성자보다는 static 팩토리 메소드를 사용하는 것이 좋습니다. ( Factory 에서 관리 )
  
  		Boolean b1 = new Boolean(true);
  		Boolean b2 = Boolean.TRUE;
  	}
  
  	@Test
  	public void testLong2() {
  		Long sum = 0L;
  		for (long i = 0; i < Integer.MAX_VALUE; ++i)
  			sum += i;
  		
  		System.out.println(sum);
  	}
  	
  	@Test
  	public void testLong() {
  		long sum = 0L;
  		for (long i = 0; i < Integer.MAX_VALUE; ++i)
  			sum += i;
  		
  		System.out.println(sum);
  	}
  }
  




• 4_싱글톤(Singleton)

  package kr.co.ioacademy; //iocademy 윤찬식 강사님
  
  // 싱글톤(Singleton)
  // 개념 : 하나의 인스턴스만 생성되는 클래스
  
  // 장점 : 어디에서든 동일한 방법으로 동일한 객체를 얻을 수 있다.
  // 단점 : 테스트 용이성 낮다.
  //       객체와 객체간의 결합도가 높아진다.
  
  // 자바에서 가장 많이 사용하는 싱글톤의 형태
  // -> 자바 5 이상에서는 스레드 안전성도 보장된다.
  class Cursor {
  	// 방법 1. private 생성자
  	private Cursor() {
  	}
  
  	// 방법 2.
  	// public static final Cursor INSTANCE1 = new Cursor();
  
  	// private static final Cursor INSTANCE = new Cursor();
  	private static final ThreadLocal<Cursor> INSTANCE
  		= new ThreadLocal<Cursor>() {
  		@Override
  		protected Cursor initialValue() {
  			return new Cursor();
  		}
  	};
  
  	public static Cursor getInstance() {
  		return INSTANCE.get();
  	}
  }
  
  public class Example4 {
  	public static void main(String[] args) {
  		System.out.println(Cursor.getInstance());
  		new Thread(new Runnable() {			
  			@Override
  			public void run() {
  				System.out.println(Cursor.getInstance());
  			}
  		}).start();
  	
  	}
  }
  



• 5_enum을 이용한 싱글톤
  : Serialize()는 객체를 쓰고, 읽어도 하나의 객체로 유지된다.
  : Refelction()는 객체가 생성되지 않는다.

  package kr.co.ioacademy; //iocademy 윤찬식 강사님
  
  import java.io.FileInputStream;
  import java.io.FileOutputStream;
  import java.io.ObjectInput;
  import java.io.ObjectInputStream;
  import java.io.ObjectOutputStream;
  import java.io.Serializable;
  import java.lang.reflect.Constructor;
  
  import org.junit.Test;
  
  // 아래의 싱글톤은 두 가지 경우에 객체가 두개이상 생성될 수 있습니다.
  // 1. Reflection
  // 2. 직렬화
  //class Cursor implements Serializable {
  //	private Cursor() {
  //	}
  //	
  //	private Object readResolve() {
  //		return INSTANCE;
  //	}
  //	
  //	private static final Cursor INSTANCE = new Cursor();
  //
  //	public static Cursor getInstance() {
  //		return INSTANCE;
  //	}
  //}
  
  // 위의 문제점을 해결하기 위해 새롭게 제안된 싱글톤
  //  원소가 하나뿐인 enum 을 이용하자.
  // 리플렉션을 통해 생성하는 것도 하는 것 불가능하고
  // 직렬화에 의한 객체 생성도 자동적으로 처리해준다.
  enum Cursor {
  	INSTANCE;
  	
  	public static Cursor getInstance() {
  		return INSTANCE;
  	}
  }
  
  public class Example5 {
  	@Test
  	public void Serialize() throws Exception {
  		String filename = "cursor.dat";
  		
  		FileOutputStream fos = new FileOutputStream(filename);
  		ObjectOutputStream oos = new ObjectOutputStream(fos);
  		oos.writeObject(Cursor.getInstance());
  		
  		fos.close();
  		oos.close();
  		
  		FileInputStream fis = new FileInputStream(filename);
  		ObjectInputStream ois = new ObjectInputStream(fis);
  		
  		Cursor c = (Cursor) ois.readObject();
  		
  		System.out.println(c);
  		System.out.println(Cursor.getInstance());
  	}
  	
  	
  	@Test
  	public void Refelction() throws Exception {
  		Constructor<?> con = Cursor.class.getDeclaredConstructors()[0];
  		con.setAccessible(true);
  
  		Cursor c = (Cursor) con.newInstance();
  
  		System.out.println(c);
  		System.out.println(Cursor.getInstance());
  	}
  
  }
  




• 6_지연된 초기화
  

  package kr.co.ioacademy; //iocademy 윤찬식 강사님
  
  // 자바의 싱글톤은 객체가 클래스 로더에 의해 로딩될 때 생성된다.
  // : 객체의 생성 비용이 크거나, 객체를 사용하지 않을 경우 리소스 낭비가 심하다.
  //  (싱글톤은 가비지 컬렉션의 대상이 아니다.)
  
  // 지연된 초기화의 필요성
  // 1. 메모리 낭비 제거
  // 2. 애플리케이션의 로딩 속도 개선
  
  class Cursor {
  	public static final Cursor INSTANCE = new Cursor();
  	private Cursor() {
  		System.out.println("Cursor created!");
  	}
  	
  	public static void foo() {
  		System.out.println("foo");
  	}
  }
  
  public class Example6 {
  	public static void main(String[] args) {
  		Cursor.foo();
  	}
  }
  




• 7_지연된 초기화2
  : DCLP(Double Checked Locking Pattern)
  : IODH(Initialization On Demand Holder) - 클래스가 최초로 초기화 되는 시점

  package kr.co.ioacademy; //iocademy 윤찬식 강사님
  
  class Cursor {
  	// private static Cursor instance = null;
  
  	private Cursor() {
  		System.out.println("Cursor");
  	};
  
  	// public static Cursor getInstance() {
  	// if (instance == null)
  	// instance = new Cursor();
  	//
  	// return instance;
  	// }
  
  	// 위의 지연된 초기화는 스레드 안전성이 없습니다.
  	// 해결해야 합니다.
  	// 1. 엄격한 동기화
  	// public synchronized static Cursor getInstance() {
  	// if (instance == null)
  	// instance = new Cursor();
  	//
  	// return instance;
  	// }
  
  	// 2. 위의 코드는 계속 동기화를 수행하기 때문에 느립니다.
  	// 생성 시점에만 동기화를 적용하고, 생성 이후에는 동기화를 제거하는 방법.
  	// DCLP(Double Checked Locking Pattern)
  //	public static Cursor getInstance() {
  //		if (instance == null) {
  //			synchronized (Cursor.class) {
  //				if (instance == null)
  //					instance = new Cursor();
  //			}
  //		}
  //		return instance;
  //	}
  
  	// 3. IODH(Initialization On Demand Holder)
  	// 클래스가 최초로 초기화 되는 시점
  	// 1) 클래스 T의 인스턴스가 생성될 때
  	// 2) 클래스 T의 정적 메소드가 호출되었을 때
  	// 3) 클래스 T의 정적 필드에 값이 할당 되었을 때     *
  	// 4) 클래스 T의 정적 필드가 상수 필드가 아니고 사용되었을 때  *
  	private static class Singleton {
  		private static final Cursor INSTANCE = new Cursor();
  	}
  	
  	public static Cursor getInstance() {
  		return Singleton.INSTANCE;
  	}
  		
  	public static void foo() {
  		System.out.println("foo");
  	}
  }
  
  public class Example7 {
  	public static void main(String[] args) {
  		Cursor.foo();
  		Cursor.getInstance();
  	}
  }
  




• 8_정적필드 초기화
  

  package kr.co.ioacademy; //iocademy 윤찬식 강사님
  
  import java.util.Calendar;
  
  // 정적 필드는 위에서부터 아래로 차근차근 초기화 합니다.
  // 사용하기 전에 초기화 할 수 있도록 앞에 배치해야 합니다.
  class Person {
  	public static final Person INSTANCE = new Person();
  	private final int weight;
  
  	public static final int CURRENT_YEAR = Calendar.getInstance().get(Calendar.YEAR);
  	
  	private Person() {
  		weight = CURRENT_YEAR - 1984;
  	}
  
  	public int weight() {
  		return weight;
  	}
  }
  
  public class Example8 {
  	public static void main(String[] args) {
  		System.out.println(Person.INSTANCE.weight());
  		System.out.println(Person.INSTANCE.CURRENT_YEAR);
  	}
  }
  




• 9_정적필드 초기화2
  : isTeenager()는 메소드 호출 당 Calendar, TimeZone, Date 2개의 객체가 생성된다.
  

  package kr.co.ioacademy; //iocademy 윤찬식 강사님
  
  import java.util.Calendar;
  import java.util.Date;
  import java.util.TimeZone;
  
  import org.junit.Test;
  
  class Person {
  	private final Date birthDate;
  
  	public Person(Date b) {
  		this.birthDate = b;
  	}
  
  	// 아래 메소드가 호출될 때마다 생성되는 객체는 다음과 같다.
  	// 1. Calendar
  	// 2. TimeZone
  	// 3. Date 2개
  	public boolean isTeenager() {
  		Calendar gmtCal = Calendar.getInstance(TimeZone.getTimeZone("GMT"));
  		gmtCal.set(1996, Calendar.JANUARY, 1, 0, 0, 0);
  		Date start = gmtCal.getTime();
  
  		gmtCal.set(2005, Calendar.JANUARY, 1, 0, 0, 0);
  		Date end = gmtCal.getTime();
  
  		return birthDate.compareTo(start) >= 0 && birthDate.compareTo(end) < 0;
  	}
  
  	private static final Date START;
  	private static final Date END;
  
  	static {
  		Calendar gmtCal = Calendar.getInstance(TimeZone.getTimeZone("GMT"));
  		gmtCal.set(1996, Calendar.JANUARY, 1, 0, 0, 0);
  		START = gmtCal.getTime();
  
  		gmtCal.set(2005, Calendar.JANUARY, 1, 0, 0, 0);
  		END = gmtCal.getTime();
  	}
  
  	public boolean isTeenager2() {
  		return birthDate.compareTo(START) >= 0 && birthDate.compareTo(END) < 0;
  	}
  }
  
  public class Example9 {
  	@Test
  	public void test_isTeen() {
  		Calendar c = Calendar.getInstance();
  		c.set(1995, Calendar.MAY, 5);
  
  		Person p = new Person(c.getTime());
  
  		for (int i = 0; i < 100000000; ++i) {
  			p.isTeenager();
  		}
  	}
  
  	@Test
  	public void test_isTeen2() {
  		Calendar c = Calendar.getInstance();
  		c.set(1995, Calendar.MAY, 5);
  
  		Person p = new Person(c.getTime());
  
  		for (int i = 0; i < 100000000; ++i) {
  			p.isTeenager2();
  		}
  	}
  }
  




• 10_StringBuilder
  : + 연산자에 대한 오버로딩은 문자열만 제공. 
  : 매번 String 인스턴스를 생성하는 방식이라 성능 이슈 발생. 이를 개선하기 위해 JDK 1.5 버전 이후에는 컴파일 단계에서 StringBuilder로 컴파일 되도록 변경되었다. 그래서 JDK 1.5 이후부터는 +를 활용해도 성능상에 큰 이슈는 없다.

  package kr.co.ioacademy; //iocademy 윤찬식 강사님
  
  // + 연산자에 대한 오버로딩은 문자열만 제공하고 있다.
  // : '+' 연산자는 피연산자로 문자열이 있을 때만 문자열 연결 연산을 수행합니다.
  //      문자열이 없으면 그냥 덧셈을 수행합니다.
  public class Example10 {
  	public static void main(String[] args) {
  		System.out.print("H" + "A");
  		// System.out.print('H' + 'A');
  		
  		// 문자를 연결하는 방법 1.
  		StringBuilder sb = new StringBuilder();
  		sb.append('H').append('A');
  		
  		System.out.print(sb);
  		
  		// 방법 2.
  		System.out.println("" + 'H' + 'A');
  		
  		// 방법 3.
  		System.out.printf("%c%c", 'H', 'A');
  	}
  }
  




• 11_부호확장, 제로 확장
  : 부호확장은 상위 비트를 부호에 따라 0이나 으로 채우는 것
  : 제로확장은 상위 비트를 0으로 채우는 것  
  

  
  

   
  package kr.co.ioacademy; //iocademy 윤찬식 강사님
  
  // int, long, byte : signed
  // char : unsigned
  
  // 변환되는 자료형에 상관없이 원래 부호가 있는 타입이면 부호 확장이 일어나고,
  // char 자료형이면 0의 확장이 일어난다.
  
  public class Example11 {
  	public static void main(String[] args) {
  		System.out.println((int)(char)(byte)-1);
  		// int(4byte) -> byte(1byte) -> char(2byte) -> int(4byte)
  		
  		// -1 -> (byte) -1
  		// ff ff ff ff -> ff
  		
  		// -> (char)(byte) -1
  		// 부호 확장
  		// ff -> ff ff 
  		
  		// -> (int)(char)(byte) -1
  		// 제로 확장
  		// ff ff -> 00 00 ff ff
  	}
  }
  

출처 : http://d2.naver.com/helloworld/329631

Java의 가비지 컬렉터(Garbage Collector)는 그 동작 방식에 따라 매우 다양한 종류가 있지만 공통적으로 크게 다음 2가지 작업을 수행한다고 볼 수 있습니다.

1. 힙(heap) 내의 객체 중에서 가비지(garbage)를 찾아낸다.
2. 찾아낸 가비지를 처리해서 힙의 메모리를 회수한다.

최초의 Java에서는 이들 가비지 컬렉션(Garbage Collection, 이하 GC) 작업에 애플리케이션의 사용자 코드가 관여하지 않도록 구현되어 있었습니다. 그러나 위 2가지 작업에서 좀 더 다양한 방법으로 객체를 처리하려는 요구가 있었습니다. 이에 따라 JDK 1.2부터는 java.lang.ref 패키지를 추가해 제한적이나마 사용자 코드와 GC가 상호작용할 수 있게 하고 있습니다.

java.lang.ref 패키지는 전형적인 객체 참조인 strong reference 외에도 soft, weak, phantom 3가지의 새로운 참조 방식을 각각의 Reference 클래스로 제공합니다. 이 3가지 Reference 클래스를 애플리케이션에 사용하면 앞서 설명하였듯이 GC에 일정 부분 관여할 수 있고, LRU(Least Recently Used) 캐시 같이 특별한 작업을 하는 애플리케이션을 더 쉽게 작성할 수 있습니다. 이를 위해서는 GC에 대해서도 잘 이해해야 할 뿐 아니라, 이들 참조 방식의 동작도 잘 이해할 필요가 있습니다.

GC와 Reachability

Java GC는 객체가 가비지인지 판별하기 위해서 reachability라는 개념을 사용한다. 어떤 객체에 유효한 참조가 있으면 'reachable'로, 없으면 'unreachable'로 구별하고, unreachable 객체를 가비지로 간주해 GC를 수행한다. 한 객체는 여러 다른 객체를 참조하고, 참조된 다른 객체들도 마찬가지로 또 다른 객체들을 참조할 수 있으므로 객체들은 참조 사슬을 이룬다. 이런 상황에서 유효한 참조 여부를 파악하려면 항상 유효한 최초의 참조가 있어야 하는데 이를 객체 참조의 root set이라고 한다.

JVM에서 메모리 영역인 런타임 데이터 영역(runtime data area)의 구조를 그림으로 그리면 다음과 같다.

그림 1 런타임 데이터 영역(Oracle HotSpot VM 기준)

런타임 데이터 영역은 위와 같이 스레드가 차지하는 영역들과, 객체를 생성 및 보관하는 하나의 큰 힙, 클래스 정보가 차지하는 영역인 메서드 영역, 크게 세 부분으로 나눌 수 있다. 위 그림에서 객체에 대한 참조는 화살표로 표시되어 있다.

힙에 있는 객체들에 대한 참조는 다음 4가지 종류 중 하나이다.

• 힙 내의 다른 객체에 의한 참조
• Java 스택, 즉 Java 메서드 실행 시에 사용하는 지역 변수와 파라미터들에 의한 참조
• 네이티브 스택, 즉 JNI(Java Native Interface)에 의해 생성된 객체에 대한 참조
• 메서드 영역의 정적 변수에 의한 참조

이들 중 힙 내의 다른 객체에 의한 참조를 제외한 나머지 3개가 root set으로, reachability를 판가름하는 기준이 된다.

reachability를 더 자세히 설명하기 위해 root set과 힙 내의 객체를 중심으로 다시 그리면 다음과 같다.

그림 2 Reachable 객체와 Unreachable 객체

위 그림에서 보듯, root set으로부터 시작한 참조 사슬에 속한 객체들은 reachable 객체이고, 이 참조 사슬과 무관한 객체들이 unreachable 객체로 GC 대상이다. 오른쪽 아래 객체처럼 reachable 객체를 참조하더라도, 다른 reachable 객체가 이 객체를 참조하지 않는다면 이 객체는 unreachable 객체이다.

이 그림에서 참조는 모두 java.lang.ref 패키지를 사용하지 않은 일반적인 참조이며, 이를 흔히 strong reference라 부른다.

Soft, Weak, Phantom Reference

java.lang.ref는 soft reference와 weak reference, phantom reference를 클래스 형태로 제공한다. 예를 들면, java.lang.ref.WeakReference 클래스는 참조 대상인 객체를 캡슐화(encapsulate)한 WeakReference 객체를 생성한다. 이렇게 생성된 WeakReference 객체는 다른 객체와 달리 Java GC가 특별하게 취급한다(이에 대한 내용은 뒤에서 다룬다). 캡슐화된 내부 객체는 weak reference에 의해 참조된다.

다음은 WeakReference 클래스가 객체를 생성하는 예이다.

WeakReference<Sample> wr = new WeakReference<Sample>( new Sample());  
Sample ex = wr.get();  
...
ex = null;  

위 코드의 첫 번째 줄에서 생성한 WeakReference 클래스의 객체는 new() 메서드로 생성된 Sample 객체를 캡슐화한 객체이다. 참조된 Sample 객체는 두 번째 줄에서 get() 메서드를 통해 다른 참조에 대입된다. 이 시점에서는 WeakReference 객체 내의 참조와 ex 참조, 두 개의 참조가 처음 생성한 Sample 객체를 가리킨다.

그림 3 Weak Reference 예 1

위 코드의 마지막 줄에서 ex 참조에 null을 대입하면 처음 생성한 Sample 객체는 오직 WeakReference 내부에서만 참조된다. 이 상태의 객체를 weakly reachable 객체라고 하는데, 이에 대한 자세한 내용은 뒤에서 다룬다.

그림 4 Weak Reference 예 2

Java 스펙에서는 SoftReference, WeakReference, PhantomReference 3가지 클래스에 의해 생성된 객체를 "reference object"라고 부른다. 이는 흔히 strong reference로 표현되는 일반적인 참조나 다른 클래스의 객체와는 달리 3가지 Reference 클래스의 객체에 대해서만 사용하는 용어이다. 또한 이들 reference object에 의해 참조된 객체는 "referent"라고 부른다. Java 스펙 문서를 참조할 때 이들 용어를 명확히 알면 좀 더 이해하기 쉽다. 위의 소스 코드에서 new WeakReference() 생성자로 생성된 객체는 reference object이고, new Sample() 생성자로 생성된 객체는 referent이다.

Reference와 Reachability

앞에서 설명한 것처럼, 원래 GC 대상 여부는 reachable인가 unreachable인가로만 구분하였고 이를 사용자 코드에서는 관여할 수 없었다. 그러나 java.lang.ref 패키지를 이용하여 reachable 객체들을 strongly reachable, softly reachable, weakly reachable, phantomly reachable로 더 자세히 구별하여 GC 때의 동작을 다르게 지정할 수 있게 되었다. 다시 말해, GC 대상 여부를 판별하는 부분에 사용자 코드가 개입할 수 있게 되었다.

두 번째 그림에서 몇몇 객체들을 WeakReference로 바꾸어서 예를 들어보면 다음과 같다.

그림 5 Reachable, Unreachable, Weakly Reachable 예제

녹색으로 표시한 중간의 두 객체는 WeakReference로만 참조된 weakly reachable 객체이고, 파란색 객체는 strongly reachable 객체이다. GC가 동작할 때, unreachable 객체뿐만 아니라 weakly reachable 객체도 가비지 객체로 간주되어 메모리에서 회수된다. root set으로부터 시작된 참조 사슬에 포함되어 있음에도 불구하고 GC가 동작할 때 회수되므로, 참조는 가능하지만 반드시 항상 유효할 필요는 없는 LRU 캐시와 같은 임시 객체들을 저장하는 구조를 쉽게 만들 수 있다.

위 그림에서 WeakReference 객체 자체는 weakly reachable 객체가 아니라 strongly reachable 객체이다. 또한, 그림에서 A로 표시한 객체와 같이 WeakReference에 의해 참조되고 있으면서 동시에 root set에서 시작한 참조 사슬에 포함되어 있는 경우에는 weakly reachable 객체가 아니라 strongly reachable 객체이다.

GC가 동작하여 어떤 객체를 weakly reachable 객체로 판명하면, GC는 WeakReference 객체에 있는 weakly reachable 객체에 대한 참조를 null로 설정한다. 이에 따라 weakly reachable 객체는 unreachable 객체와 마찬가지 상태가 되고, 가비지로 판명된 다른 객체들과 함께 메모리 회수 대상이 된다.

Strengths of Reachability

앞에서 설명한 것처럼 reachability는 총 5종류가 있고 이는 GC가 객체를 처리하는 기준이 된다. Java 스펙에서는 이들 5종류의 reachability를 "Strengths of Reachability"라 부른다. 앞의 예제 그림에서는 weakly reachable만 예를 들었기 때문에 WeakReference만 표시하였으나, SoftReference, PhantomReference 등을 이용하여 여러 가지 방식으로 reachability를 지정할 수 있고 이에 따라 각 객체들의 GC 여부는 다양하게 달라지게 된다. 하나의 객체에 대한 참조의 개수나 참조 형태에는 아무런 제한이 없으므로, 하나의 객체는 여러 strong reference, soft reference, weak reference, phantom reference의 다양한 조합으로 참조될 수 있다.

Java GC는 root set으로부터 시작해서 객체에 대한 모든 경로를 탐색하고 그 경로에 있는 reference object들을 조사하여 그 객체에 대한 reachability를 결정한다. 다양한 참조 관계의 결과, 하나의 객체는 다음 5가지 reachability 중 하나가 될 수 있다.

• strongly reachable: root set으로부터 시작해서 어떤 reference object도 중간에 끼지 않은 상태로 참조 가능한 객체, 다시 말해, 객체까지 도달하는 여러 참조 사슬 중 reference object가 없는 사슬이 하나라도 있는 객체
• softly reachable: strongly reachable 객체가 아닌 객체 중에서 weak reference, phantom reference 없이 soft reference만 통과하는 참조 사슬이 하나라도 있는 객체
• weakly reachable: strongly reachable 객체도 softly reachable 객체도 아닌 객체 중에서, phantom reference 없이 weak reference만 통과하는 참조 사슬이 하나라도 있는 객체
• phantomly reachable: strongly reachable 객체, softly reachable 객체, weakly reachable 객체 모두 해당되지 않는 객체. 이 객체는 파이널라이즈(finalize)되었지만 아직 메모리가 회수되지 않은 상태이다.
• unreachable: root set으로부터 시작되는 참조 사슬로 참조되지 않는 객체

다음 예의 경우 객체 B의 reachability는 softly reachable이다.

그림 6 Softly Reachable

root set으로부터 바로 SoftReference를 통해서 B를 참조할 수 있기 때문이다. 만약 root set의 SoftReference에 대한 참조가 없다면(즉, 왼쪽 아래 화살표를 삭제한다면), 객체 B는 phantomly reachable이 된다.

Softly Reachable과 SoftReference

softly reachable 객체, 즉 strong reachable이 아니면서 오직 SoftReferencce 객체로만 참조된 객체는 힙에 남아 있는 메모리의 크기와 해당 객체의 사용 빈도에 따라 GC 여부가 결정된다. 그래서 softly reachable 객체는 weakly reachable 객체와는 달리 GC가 동작할 때마다 회수되지 않으며 자주 사용될수록 더 오래 살아남게 된다. Oracle HotSpot VM에서는 softly reachable 객체의 GC를 조절하기 위해 다음 JVM 옵션을 제공한다.

-XX:SoftRefLRUPolicyMSPerMB=<N>

이 옵션의 기본값은 1000이다.

softly reachable 객체의 GC 여부는 위 옵션의 에 설정한 숫자에 따라 다음 수식에 의해 결정된다.

(마지막 strong reference가 GC된 때로부터 지금까지의 시간) > (옵션 설정값 N) * (힙에 남아있는 메모리 크기)

어떤 객체가 사용된다는 것은 strong reference에 의해 참조되는 것이므로 위 수식의 좌변은 해당 객체가 얼마나 자주 사용되는지를 의미한다. 옵션 설정값이 1000이고 남아 있는 메모리가 100MB이면, 수식의 우변은 1,000ms/MB * 100MB = 100,000ms = 100sec, 즉 100초가 된다(옵션 이름 마지막이 MSPerMB로 끝나므로 옵션 설정값의 단위는 ms/MB임을 알 수 있다). 따라서 softly reachable 객체가 100초 이상 사용되지 않으면 GC에 의해 회수 대상이 된다. 힙에 남아있는 메모리가 작을수록 우변의 값이 작아지므로, 힙이 거의 소진되면 대부분의 softly reachable 객체는 모두 메모리에서 회수되어 OutOfMemoryError를 막게 될 것이다.

softly reachable 객체를 GC하기로 결정되면 앞서 설명한 WeakReference 경우와 마찬가지로 참조 사슬에 존재하는 SoftReference 객체 내의 softly reachable 객체에 대한 참조가 null로 설정되며, 이후 이 softly reachable객체는 unreachable 객체와 마찬가지가 되어 GC의해 메모리가 회수된다.

Weakly Reachable과 WeakReference

weakly reachable 객체는 특별한 정책에 의해 GC 여부가 결정되는 softly reachable 객체와는 달리 GC를 수행할 때마다 회수 대상이 된다. 앞서 설명한 것처럼 WeakReference 내의 참조가 null로 설정되고 weakly reachable 객체는 unreachable 객체와 마찬가지 상태가 되어 GC에 의해 메모리가 회수된다. 그러나 GC가 실제로 언제 객체를 회수할지는 GC 알고리즘에 따라 모두 다르므로, GC가 수행될 때마다 반드시 메모리까지 회수된다고 보장하지는 않는다. 이는 softly reachable 객체는 물론 unreachable 객체도 마찬가지이다. GC가 GC 대상인 객체를 찾는 작업과 GC 대상인 객체를 처리하여 메모리를 회수하는 작업은 즉각적인 연속 작업이 아니며, GC 대상 객체의 메모리를 한 번에 모두 회수하지도 않는다.

LRU 캐시와 같은 애플리케이션에서는 softly reachable 객체보다는 weakly reachable 객체가 유리하므로 LRU 캐시를 구현할 때에는 대체로 WeakReference를 사용한다. softly reachable 객체는 힙에 남아 있는 메모리가 많을수록 회수 가능성이 낮기 때문에, 다른 비즈니스 로직 객체들을 위해 어느 정도 비워두어야 할 힙 공간이 softly reachable 객체에 의해 일정 부분 점유된다. 따라서 전체 메모리 사용량이 높아지고 GC가 더 자주 일어나며 GC에 걸리는 시간도 상대적으로 길어지는 문제가 있다.

ReferenceQueue

phantomly reachable 객체의 동작과 PhantomReference를 설명하기 전에 java.lang.ref 패키지에서 제공하는 ReferenceQueue 클래스에 대해 설명할 필요가 있다.

SoftReference 객체나 WeakReference 객체가 참조하는 객체가 GC 대상이 되면 SoftReference 객체, WeakReference 객체 내의 참조는 null로 설정되고 SoftReference 객체, WeakReference 객체 자체는 ReferenceQueue에 enqueue된다. ReferenceQueue에 enqueue하는 작업은 GC에 의해 자동으로 수행된다. ReferenceQueue의 poll() 메서드나 remove() 메서드를 이용해 ReferenceQueue에 이들 reference object가 enqueue되었는지 확인하면 softly reachable 객체나 weakly reachable 객체가 GC되었는지를 파악할 수 있고, 이에 따라 관련된 리소스나 객체에 대한 후처리 작업을 할 수 있다. 어떤 객체가 더 이상 필요 없게 되었을 때 관련된 후처리를 해야 하는 애플리케이션에서 이 ReferenceQueue를 유용하게 사용할 수 있다. Java Collections 클래스 중에서 간단한 캐시를 구현하는 용도로 자주 사용되는 WeakHashMap 클래스는 이 ReferenceQueue와 WeakReference를 사용하여 구현되어 있다.

SoftReference와 WeakReference는 ReferenceQueue를 사용할 수도 있고 사용하지 않을 수도 있다. 이는 이들 클래스의 생성자 중에서 ReferenceQueue를 인자로 받는 생성자를 사용하느냐 아니냐로 결정한다. 그러나 PhantomReference는 반드시 ReferenceQueue를 사용해야만 한다. PhantomReference의 생성자는 단 하나이며 항상 ReferenceQueue를 인자로 받는다.

ReferenceQueue<Object> rq = new ReferenceQueue<Object>(); PhantomReference<Object> pr = new PhantomReference<Object>(referent, rq);  

SoftReference, WeakReference는 객체 내부의 참조가 null로 설정된 이후에 ReferenceQueue에 enqueue되지만, PhantomReference는 객체 내부의 참조를 null로 설정하지 않고 참조된 객체를 phantomly reachable 객체로 만든 이후에 ReferenceQueue에 enqueue된다. 이를 통해 애플리케이션은 객체의 파이널라이즈 이후에 필요한 작업들을 처리할 수 있게 된다. 더 자세한 내용은 다음 절에서 설명한다.

Phantomly Reachable과 PhantomReference

softly reachable과 weakly reachable, phantomly reachable은 많이 다르다. 이를 설명하기 위해서는 먼저 GC 동작을 설명해야 한다. GC 대상 객체를 찾는 작업과 GC 대상 객체를 처리하는 작업이 연속적이지 않 듯이, GC 대상 객체를 처리하는 작업과 할당된 메모리를 회수하는 작업도 연속된 작업이 아니다. GC 대상 객체를 처리하는 작업, 즉 객체의 파이널라이즈 작업이 이루어진 후에 GC 알고리즘에 따라 할당된 메모리를 회수한다.

GC 대상 여부를 결정하는 부분에 관여하는 softly reachable, weakly reachable과는 달리, phantomly reachable은 파이널라이즈와 메모리 회수 사이에 관여한다. strongly reachable, softly reachable, weakly reachable에 해당하지 않고 PhantomReference로만 참조되는 객체는 먼저 파이널라이즈된 이후에 phantomly reachable로 간주된다. 다시 말해, 객체에 대한 참조가 PhantomReference만 남게 되면 해당 객체는 바로 파이널라이즈된다. GC가 객체를 처리하는 순서는 항상 다음과 같다.

1. soft references
2. weak references
3. 파이널라이즈
4. phantom references
5. 메모리 회수

즉, 어떤 객체에 대해 GC 여부를 판별하는 작업은 이 객체의 reachability를 strongly, softly, weakly 순서로 먼저 판별하고, 모두 아니면 phantomly reachable 여부를 판별하기 전에 파이널라이즈를 진행한다. 그리고 대상 객체를 참조하는 PhantomReference가 있다면 phantomly reachable로 간주하여 PhantomReference를 ReferenceQueue에 넣고 파이널라이즈 이후 작업을 애플리케이션이 수행하게 하고 메모리 회수는 지연시킨다.

앞서 설명한 것처럼 PhatomReference는 항상 ReferenceQueue를 필요로 한다. 그리고 PhantomReference의 get() 메서드는 SoftReference, WeakReference와 달리 항상 null을 반환한다. 따라서 한 번 phantomly reachable로 판명된 객체는 더 이상 사용될 수 없게 된다. 그리고 phantomly reachable로 판명된 객체에 대한 참조를 GC가 자동으로 null로 설정하지 않으므로, 후처리 작업 후에 사용자 코드에서 명시적으로 clear() 메서드를 실행하여 null로 설정해야 메모리 회수가 진행된다.

이와 같이, PhantomReference를 사용하면 어떤 객체가 파이널라이즈된 이후에 할당된 메모리가 회수되는 시점에 사용자 코드가 관여할 수 있게 된다. 파이널라이즈 이후에 처리해야 하는 리소스 정리 등의 작업이 있다면 유용하게 사용할 수 있다. 그러나 개인적으로는 PhantomReference를 사용하는 코드를 거의 본 적이 없으며, 그 효용성에 대해서는 의문이 있다.

마치며

Java의 Reference는 그 선후 관계와 용어가 복잡해서 글로 쉽게 풀어쓰기가 어려워 본문이 꽤 장황해졌다. 본문의 내용을 간단히 요약하면 다음과 같다.

• Java GC는 GC 대상 객체를 찾고, 대상 객체를 처리(finalization)하고, 할당된 메모리를 회수하는 작업으로 구성된다.
• 애플리케이션은 사용자 코드에서 객체의 reachability를 조절하여 Java GC에 일부 관여할 수 있다.
• 객체의 reachability를 조절하기 위해서 java.lang.ref 패키지의 SoftReference, WeakReference, PhantomReference, ReferenceQueue 등을 사용한다.

개인적으로는 내부 캐시 등을 구현하고자 하는 대부분의 애플리케이션에서는 WeakReference 혹은 이를 이용한 WeakHashMap만으로도 충분하다고 생각한다. 다른 애플리케이션에서는 가끔 SoftReference를 사용하는 경우도 있지만, PhantomReference는 거의 예제가 없으며 그만큼 불필요할 것이다. 이들 Java Reference들과 관련된 GC 동작을 잘 이해하면 Java의 heap 메모리 문제에서 더욱 유연한 애플리케이션 작성에 크게 도움이 될 것이다.

• JAVA의 객체가 garbage collection 대상이 되는 순간은?
  1. reference가 영원히 영역을 벗어남 (ex. 지역 변수로 선언한 객체의 메소드의 영역을 벗어남)
  2. reference에 다른 객체를 대입
  3. reference를 직접 'null'로 설정
  but, 위 방법 외에 참조를 약하게 만들어 GC 대상이 되도록 만들 수 있다.
  
  

Strong Reference > Soft Reference > Weak Reference > Phantom Reference

• Strong Reference
  : 일반적으로 new를 통해서 객체를 생성하게 되면 생기게 되는 참조.
  : 참조에 대해서 해지하지 않는다면 그 메모리는 절대 수거되지 않는다.
  
  
• Soft Reference
  : GC에 의해 수거될 수도 있고, 수거되지 않을 수도 있다.
  : 메모리 상태에 따라 결정
  
  
• Weak Reference
  : GC가 발생하기 전까지는 참조를 유지한다.
  : GC가 발생하는 순간 무조건 수거된다.
  : 객체 캐시에 유용 (안드로이드에서 그림이 포함된 listView 등)
  
  
• Phantom Reference
  : 가장 약한 참조
  : GC가 발생 전 메모리에서 정리된다. (finalize() 호출 후)
  : 내부적으로 유지하고 있지만, 객체를 다시 꺼내오면 null 이다 
  
  - ReferenceTest.java

  package kr.co.ioacademy; //iocademy 윤찬식 강사님
  
  import java.lang.ref.SoftReference;
  import java.lang.ref.WeakReference;
  import java.util.LinkedList;
  import java.util.List;
  
  // 강한 참조(Strong Reference)
  // 일반적으로 new를 통해서 객체를 생성하게 되면 생기게 되는 참조.
  
  // 강한 참조를 통해 참조되고 있는 객체는 절대 가비지 컬렉션의 대상에서
  // 제외된다.
  // 자바에서 아무리 자동적으로 메모리가 수거된다고 하지만, 
  // 참조에 대해서 해지하지 않는 다면 그 메모리는 절대 수거되지 않는다.
  //  (참조 = null , 참조 = 다른객체)
  
  // OutOfMemory를 방지하기 위해서는 약한 형태의 참조를 사용해야 한다.
  //  SoftReference<>, WeakReference<>
  
  // Soft Reference
  // 생성 방법 : SoftReference<Data> r
              // = new SoftReference<Data>(new Data);
  // 동작 : 강한 참조와 다르게 GC에 의해 수거될 수도 있고, 수거되지 않을 수도 있다.
  //  메모리에 충분한 여유가 있다면 GC가 수행되고 있다고 하더라도 수거되지 않는다.
  //  하지만 out of memory의 시점이 가깝다면, 수거될 확률이 높다.
  
  // Weak Reference
  //생성 방법 : WeakReference<Data> r
  // = new WeakReference<Data>(new Data);
  
  // WeakReference에 의해 참조된 객체는 가비지 컬렉션이 발생하기 전까지는 참조를 유지
  // 하지만 GC가 발생하는 순간 무조건 수거된다.
  // WeakReference가 사라지는 시점이 GC의 실행 주기와 일치한다.
  // 이를 이용하면 짧은 주기에 자주 사용되는 객체를 캐시할 때 유용하다.
  // => WeakHashMap
  // WeakHashMap<K,V>
  
  // PhantomReference
  
  class BigData {
  	private int[] array = new int[5000]; // 20000byte, 20K
  }
  
  public class ReferenceTest {
  
  	private List<WeakReference<BigData>> refs = new LinkedList<>();
  
  	public void referenceTest() {
  		try {
  			for (int i = 0; true; i++) {
  				refs.add(new WeakReference<BigData>(new BigData()));
  			}
  		} catch (OutOfMemoryError ofm) { // Strong일 경우 out of memory 발생
  			System.out.println("out of memory!");
  		}
  	}
  
  	public static void main(String[] args) {
  		System.out.println("run");
  		// Thread.sleep(10 * 1000);
  		ReferenceTest test = new ReferenceTest();
  		test.referenceTest();
  		System.out.println("finish");
  	}
  	
  }
  

  
  - WeakSingleton.java

  package kr.co.ioacademy; //iocademy 윤찬식 강사님
  import java.lang.ref.WeakReference;
  
  public class WeakSingleton {
  	private static WeakReference<WeakSingleton> instance
  	 = new WeakReference<WeakSingleton>(null);
  
  	public static WeakSingleton getInstance()
  	{
  		WeakSingleton m = instance.get();
  		if (m != null)
  			return m;
  		
  		synchronized (WeakSingleton.class) {	
  			
  			System.out.println("Create new instance");
  			
  			m = new WeakSingleton();
  			instance = new WeakReference<WeakSingleton>(m);		
  		}
  		
  		return m;
  	}
  	
  	public static void main(String[] args) {
  		WeakSingleton w = WeakSingleton.getInstance();
  		
  		// System.gc();
  		
  		w = WeakSingleton.getInstance();
  	}
  }
  

• Protocol Buffers
  
  : 하나의 언어만으로 서버를 구성하는 것은 한계가 있다. 특히, java와 C#등으로 패킷을 만드는 것은 굉장히 불편하다.
  : 이런 언어적인 차이를 해결해주는 구글의 오픈소스 Protocol Buffers가 있다. 
  : 프로토콜 자체를 언어 독립적으로 구현할 수 있다.
  : node.js에는 npm
  - https://developers.google.com/protocol-buffers/

• Snappy
  : 패킷을 만드는 것 만큼 패킷의 양을 줄이는 것도 중요하다. 특히 모바일에서는 패킷의 양을 줄이는데 신경써야한다.
  : 패킷을 줄이려면 압축과 압축해제를 해야하는데 이 과정에서 속도도 중요하다.
  : 구글 오픈소스 Snappy
  - https://google.github.io/snappy/
  

• IOCP
  : Input/Ouptput Completion Port
  : Proactor 방식의 고성능 I/O Notification Model로 asynchronous I/O 지원
  : Windows OS가 직접 효율적인 스레드 풀링 제공으로 context switching을 줄임
  : Overlapped I/O를 확장 시킨 개념으로 커널영역과 유저영역의 버퍼 공유 (memory page-locking)
  

   
  
  - 기본 동작 구조 (출처: http://www.slideshare.net/sm9kr/windows-registered-io-rio)
   : I/O initiation -> I/O processing -> I/O completion
  
  
  
  
  
  

  - 1_IOCP
   : worker thread 도입
  

   
  #pragma comment(linker, "/subsystem:console")
  
  #define WIN32_LEAN_AND_MEAN  
  #include <stdio.h>
  #include <WinSock2.h> 
  #include <Windows.h>  
  #pragma comment(lib, "ws2_32.lib") 
  
  #pragma comment(linker, "/subsystem:console")
  
  // Overlapped 작업의 종료를 대기할 스레드
  DWORD __stdcall EchoThread( void* p )
  {
  	// 여기서 비동기작업의 종료를 대기하면 됩니다.
  	// 즉 WSAWait....()
  }
  
  int main()
  {
  	WSADATA w;
  	int ret = WSAStartup( MAKEWORD(2,2), &w);    
  	
  	//-------------------------------------------
  	// 1. Overlapped io를 위한 소켓 생성
  	// 표준 C 네트워크 함수 : 소문자()
  	// WSAxxxx() 함수들 : windows socket 2.0 부터 지원되는
  	//					windows만의 개념들..
  	int listen_sock = WSASocket( PF_INET, SOCK_STREAM,
  								0, 0, 0,
  								WSA_FLAG_OVERLAPPED);
  								
  
  
  
  	// 2. 소켓에 주소 지정(bind)
  	SOCKADDR_IN addr; 
  
  	addr.sin_family = AF_INET;
  	addr.sin_port   = htons(4000);
  	addr.sin_addr.s_addr = INADDR_ANY; 
  	
  	bind( listen_sock, (struct sockaddr*)&addr, sizeof addr);
  
  
  	listen(listen_sock,  5); 
  
  	while(1)
  	{
  		struct sockaddr_in addr2;
  		int sz = sizeof addr2;
  
  
  		int link_sock = accept( listen_sock, 
  							  (struct sockaddr*)&addr2, &sz);
  
  		printf("클라이언트가 접속되었습니다\n");
  
  		// Overlapped로 수신 하는 코드
  		WSAEVENT ev = WSACreateEvent();
  		WSAOVERLAPPED ov = {0};
  		ov.hEvent = ev;
  
  		// 수신 버퍼..
  		char s[1024] = {0};
  		WSABUF buf;
  		buf.buf = s;
  		buf.len = 1024;
  		DWORD flag = 0;
  		DWORD recvBytes = 0;
  
  		int n = WSARecv( link_sock,
  						 &buf, 1,  // 버퍼와 버퍼 갯수
  						 &recvBytes, // 받을 data 크기
  						 &flag,
  						 &ov, // overlapped 구조체
  						 0);
  		// 새로운 스레드를 생성해서 비동기 작업의 완료를 대기한다.
  		CreateThread( 0, 0, EchoThread, (void*)ev, 0, 0);
  	}
  
  
  	closesocket( link_sock);
  	//------------------------------
  	WSACleanup(); 
  }
  

  
  - 2_IOCP
   : worker thread 구현
   : IOCP 생성
  

   
  #pragma comment(linker, "/subsystem:console")
  
  #define WIN32_LEAN_AND_MEAN  
  #include <stdio.h>
  #include <WinSock2.h> 
  #include <Windows.h>  
  #pragma comment(lib, "ws2_32.lib")
  
  DWORD __stdcall EchoThread( void* p )
  {
  	HANDLE hPort = (HANDLE)p;
  	WSAOVERLAPPED* pov; 
  	DWORD bytes, key;
  
  	while( 1 )
  	{
  		// IOCP에 있는 완료큐에 작업이 들어올때를 대기한다.
  		GetQueuedCompletionStatus( hPort, &bytes, &key,
  				&pov, INFINITE);
  
  		printf("비동기 작업 완료 : %d bytes,  key : %d\n",
  					bytes, key);
  	}
  	return 0;
  }
  
  int main()
  {
  	WSADATA w;
  	int ret = WSAStartup( MAKEWORD(2,2), &w);    
  	
  
  	//--------------------
  	// 1. 입출력 완료 포트(IOCP)를 생성합니다.
  	HANDLE hPort = CreateIoCompletionPort( 
  						(HANDLE)-1, // IOCP에등록할 파일(소켓)
  						0, // 이미 존재 하는 IOCP핸들
  						0, // 완료키
  						2);// IOCP에서 비동기작업을 대기할 스레드
  						// 갯수 (CPU의 갯수만큼이 가장좋다.)
  
  	// 2. 비동기 작업이 완료 될때를 처리할 스레드 생성
  	HANDLE h1 = CreateThread( 0, 0, EchoThread, (void*)hPort,
  							0, 0);
  	HANDLE h2 = CreateThread( 0, 0, EchoThread, (void*)hPort, 0, 0);
  
  
  	//-------------------------------------------
  	int listen_sock = WSASocket( PF_INET, SOCK_STREAM,
  								0, 0, 0,
  								WSA_FLAG_OVERLAPPED);
  	SOCKADDR_IN addr; 
  	addr.sin_family = AF_INET;
  	addr.sin_port   = htons(4000);
  	addr.sin_addr.s_addr = INADDR_ANY; 
  	
  	bind( listen_sock, (struct sockaddr*)&addr, sizeof addr);
  	listen(listen_sock,  5); 
  
  	int cnt = 0;
  	while(1)
  	{
  		struct sockaddr_in addr2;
  		int sz = sizeof addr2;
  		int link_sock = accept( listen_sock, 
  							  (struct sockaddr*)&addr2, &sz);
  
  		// Client와 연결된 소켓의 핸들을 IOCP에 등록한다.
  		// IOCP를 만들때와 IOCP에 장치(파일)을 등록할때 모두 
  		// 아래 함수를 사용합니다.
  		CreateIoCompletionPort( (HANDLE)link_sock,
  								hPort, 
  								cnt++,
  								2);
  
  
  
  		printf("클라이언트가 접속되었습니다\n");
  
  		// Overlapped로 수신 하는 코드
  		WSAEVENT ev = WSACreateEvent();
  		WSAOVERLAPPED ov = {0};
  		ov.hEvent = ev;
  
  		// 수신 버퍼..
  		char s[1024] = {0};
  		WSABUF buf;
  		buf.buf = s;
  		buf.len = 1024;
  		DWORD flag = 0;
  		DWORD recvBytes = 0;
  
  		int n = WSARecv( link_sock,
  						 &buf, 1,  // 버퍼와 버퍼 갯수
  						 &recvBytes, // 받을 data 크기
  						 &flag,
  						 &ov, // overlapped 구조체
  						 0);
  	}
  	//------------------------------
  	WSACleanup(); 
  }
  

  
  - 3_IOCP
   : overlapped 구조체 확장 -> 입출력당 1개의 자료 구조
  

   
  #pragma comment(linker, "/subsystem:console")
  
  #define WIN32_LEAN_AND_MEAN  
  #include <stdio.h>
  #include <WinSock2.h> 
  #include <Windows.h>  
  #include <stdlib.h>  
  #pragma comment(lib, "ws2_32.lib")
  
  #define READ_MODE  1
  #define WRITE_MODE 2
  
  // OVERLAPPED 구조체는 보통 확장해서 사용하게 됩니다.
  // 입출력당 1개의 자료 구조
  struct IO_DATA
  {
  	WSAOVERLAPPED ov;
  	WSABUF        wsaBuf;
  	char          buff[1024];
  	int           mode;
  };
  
  DWORD __stdcall EchoThread( void* p )
  {
  	HANDLE hPort = (HANDLE)p;
  	WSAOVERLAPPED* pov; 
  	DWORD bytes, key;
  
  	while( 1 )
  	{
  		// IOCP에 있는 완료큐에 작업이 들어올때를 대기한다.
  		GetQueuedCompletionStatus( hPort, &bytes, &key,
  				&pov, INFINITE);
  
  		printf("비동기 작업 완료 : %d bytes,  key : %d\n",
  					bytes, key);
  
  		IO_DATA* ioData = (IO_DATA*)pov;
  
  		printf("수신된 data : %s\n", ioData->buff);
  
  		CloseHandle( ioData->ov.hEvent);
  		free(ioData);
  	}
  	return 0;
  }
  
  int main()
  {
  	WSADATA w;
  	int ret = WSAStartup( MAKEWORD(2,2), &w);    
  	
  
  	//--------------------
  	// 1. 입출력 완료 포트(IOCP)를 생성합니다.
  	HANDLE hPort = CreateIoCompletionPort( 
  						(HANDLE)-1, // IOCP에등록할 파일(소켓)
  						0, // 이미 존재 하는 IOCP핸들
  						0, // 완료키
  						2);// IOCP에서 비동기작업을 대기할 스레드
  						// 갯수 (CPU의 갯수만큼이 가장좋다.)
  
  	// 2. 비동기 작업이 완료 될때를 처리할 스레드 생성
  	HANDLE h1 = CreateThread( 0, 0, EchoThread, (void*)hPort,
  							0, 0);
  	HANDLE h2 = CreateThread( 0, 0, EchoThread, (void*)hPort, 0, 0);
  
  
  	//-------------------------------------------
  	int listen_sock = WSASocket( PF_INET, SOCK_STREAM,
  								0, 0, 0,
  								WSA_FLAG_OVERLAPPED);
  	SOCKADDR_IN addr; 
  	addr.sin_family = AF_INET;
  	addr.sin_port   = htons(4000);
  	addr.sin_addr.s_addr = INADDR_ANY; 
  	
  	bind( listen_sock, (struct sockaddr*)&addr, sizeof addr);
  	listen(listen_sock,  5); 
  
  	int cnt = 0;
  	while(1)
  	{
  		struct sockaddr_in addr2;
  		int sz = sizeof addr2;
  		int link_sock = accept( listen_sock, 
  							  (struct sockaddr*)&addr2, &sz);
  
  		// Client와 연결된 소켓의 핸들을 IOCP에 등록한다.
  		// IOCP를 만들때와 IOCP에 장치(파일)을 등록할때 모두 
  		// 아래 함수를 사용합니다.
  		CreateIoCompletionPort( (HANDLE)link_sock,
  								hPort, 
  								cnt++,
  								2);
  
  
  
  		printf("클라이언트가 접속되었습니다\n");
  
  		// IO작업당 아래 구조체를 만들어서 사용한다.
  		IO_DATA* ioData = (IO_DATA*)malloc(sizeof(IO_DATA));
  
  		memset(ioData, 0, sizeof(IO_DATA));
  
  
  		ioData->wsaBuf.buf = ioData->buff;
  		ioData->wsaBuf.len = 1024;
  		ioData->mode = READ_MODE;
  		ioData->ov.hEvent = WSACreateEvent();
  
  
  		DWORD flag = 0;
  		DWORD recvBytes = 0;
  
  		int n = WSARecv( link_sock,
  						 &(ioData->wsaBuf), 1,  // 버퍼와 버퍼 갯수
  						 &recvBytes, // 받을 data 크기
  						 &flag,
  						 (WSAOVERLAPPED*)ioData, // overlapped 구조체
  						 0);
  	}
  	//------------------------------
  	WSACleanup(); 
  }
  

  
  - 4_IOCP
   : 소켓 구조체 구현 
   : write 구현 -> WSASend 도 완료되면 GetQueuedCompletionStatus로 통보된다.
  

   
  #pragma comment(linker, "/subsystem:console")
  
  #define WIN32_LEAN_AND_MEAN  
  #include <stdio.h>
  #include <WinSock2.h> 
  #include <Windows.h>
  #include <stdlib.h>  
  #pragma comment(lib, "ws2_32.lib") 
  
  #define READ_MODE  1
  #define WRITE_MODE 2
  
  // 클라이언트와 연결된 소켓정보를 관리하는 구조체
  struct SOCKET_DATA
  {
  	int sock;
  	SOCKADDR_IN addr;
  };
  
  // OVERLAPPED 구조체는 보통 확장해서 사용하게 됩니다.
  // 입출력당 1개의 자료 구조
  struct IO_DATA
  {
  	WSAOVERLAPPED ov;
  	WSABUF        wsaBuf;
  	char          buff[1024];
  	int           mode;
  };
  
  DWORD __stdcall EchoThread( void* p )
  {
  	HANDLE hPort = (HANDLE)p;
  	WSAOVERLAPPED* pov; 
  	DWORD bytes, key;
  
  	while( 1 )
  	{
  		GetQueuedCompletionStatus( hPort, &bytes, &key,
  				&pov, INFINITE);
  
  		printf("비동기 작업 완료 : %d bytes,  key : %d\n",
  					bytes, key);
  
  		SOCKET_DATA* pSock = (SOCKET_DATA*)key;
  
  		IO_DATA* ioData = (IO_DATA*)pov;
  
  		if ( ioData->mode == READ_MODE )
  		{
  			printf("수신된 data : %s\n", ioData->buff);
  
  			// 수신에 사용한 버퍼를 사용해서 송신한다.
  			// 수신중에 overlapped 구조체의 내용은 변경되어 있게됩니다
  			memset( &(ioData->ov), 0, sizeof(WSAOVERLAPPED));
  
  			strcat( ioData->buff, " from server");
  			ioData->mode = WRITE_MODE;
  			//-----------------------------------
  			WSASend( pSock->sock, 
  				 &(ioData->wsaBuf), 1,
  				 &bytes, 0, &(ioData->ov), 0);
  			//-----------------------------
  		}
  		else
  		{
  			closesocket(pSock->sock);
  			free( pSock	);
  			CloseHandle( ioData->ov.hEvent);
  			free(ioData);
  		}
  	}
  	return 0;
  }
  
  int main()
  {
  	WSADATA w;
  	int ret = WSAStartup( MAKEWORD(2,2), &w);    
  	
  
  	//--------------------
  	// 1. 입출력 완료 포트(IOCP)를 생성합니다.
  	HANDLE hPort = CreateIoCompletionPort( 
  						(HANDLE)-1, // IOCP에등록할 파일(소켓)
  						0, // 이미 존재 하는 IOCP핸들
  						0, // 완료키
  						2);// IOCP에서 비동기작업을 대기할 스레드
  						// 갯수 (CPU의 갯수만큼이 가장좋다.)
  
  	// 2. 비동기 작업이 완료 될때를 처리할 스레드 생성
  	HANDLE h1 = CreateThread( 0, 0, EchoThread, (void*)hPort,
  							0, 0);
  	HANDLE h2 = CreateThread( 0, 0, EchoThread, (void*)hPort, 0, 0);
  
  
  	//-------------------------------------------
  	int listen_sock = WSASocket( PF_INET, SOCK_STREAM,
  								0, 0, 0,
  								WSA_FLAG_OVERLAPPED);
  	SOCKADDR_IN addr; 
  	addr.sin_family = AF_INET;
  	addr.sin_port   = htons(4000);
  	addr.sin_addr.s_addr = INADDR_ANY; 
  	
  	bind( listen_sock, (struct sockaddr*)&addr, sizeof addr);
  	listen(listen_sock,  5); 
  
  	int cnt = 0;
  	while(1)
  	{
  		struct sockaddr_in addr2;
  		int sz = sizeof addr2;
  
  		int link_sock = accept( listen_sock, 
  							  (struct sockaddr*)&addr2, &sz);
  
  
  		// 소켓당 하나의 구조체
  		SOCKET_DATA* pSock = (SOCKET_DATA*)malloc(
  									sizeof(SOCKET_DATA));
  		pSock->sock = link_sock;
  		pSock->addr = addr2;
  
  
  		// Client와 연결된 소켓의 핸들을 IOCP에 등록한다.
  		// IOCP를 만들때와 IOCP에 장치(파일)을 등록할때 모두 
  		// 아래 함수를 사용합니다.
  		CreateIoCompletionPort( (HANDLE)link_sock,
  								hPort, 
  								(ULONG_PTR)pSock,
  								2);
  
  
  
  		printf("클라이언트가 접속되었습니다\n");
  
  		// IO작업당 아래 구조체를 만들어서 사용한다.
  		IO_DATA* ioData = (IO_DATA*)malloc(sizeof(IO_DATA));
  
  		memset(ioData, 0, sizeof(IO_DATA));
  
  
  		ioData->wsaBuf.buf = ioData->buff;
  		ioData->wsaBuf.len = 1024;
  		ioData->mode = READ_MODE;
  		ioData->ov.hEvent = WSACreateEvent();
  
  
  		DWORD flag = 0;
  		DWORD recvBytes = 0;
  
  		int n = WSARecv( link_sock,
  						 &(ioData->wsaBuf), 1,  // 버퍼와 버퍼 갯수
  						 &recvBytes, // 받을 data 크기
  						 &flag,
  						 (WSAOVERLAPPED*)ioData, // overlapped 구조체
  						 0);
  	}
  	//------------------------------
  	WSACleanup(); 
  }

  
  - PAGE_LOCKING (참고: http://www.slideshare.net/sm9kr/windows-registered-io-rio, http://ozt88.tistory.com/26)
   
   : 완벽한 통지모델로 보이는 IOCP에도 문제는 있다.
   : 하나의 I/O operation마다 버퍼 영역에 대한 page-lock/unlock
    -> 특정 메모리에 대한 pin/unpin은 많은 CPU cycle 요구
    -> 그래서 RECV를 posting 할 때, page-locking을 피하여 CPU cycle을 줄이기 위해 zero-byte recv로 최소화
   : 하나의 I/O operation마다 시스템콜 호출
    -> 유저모드-커널모드 전환 발생
  

  
  

   ■ Zero Byte Recv?
    : 실제 수행을 시작하는 때를 감지할 수 있다면 이 문제를 해결할 수 있다.
    : 비동기 작업을 명령하기 전에 먼저 0바이트를 읽는 Recv작업을 요청하는 것이다. 0바이트 읽는 작업이므로 필요한 버퍼도 0바이트, 그러므로 PAGE_LOCKING이 발생하지 않는다. 비동기 명령 프로세서를 사용하기 때문에 이 명령이 요청된 시점에는 작업이 바로 가능한지 불확실하지만, 이 명령이 완료된 시점에는 다음 작업을 바로 시작할 수 있을 가능성이 매우 높다. 그러니까 이때부터 본격적인(큰 용량의 버퍼를 사용하는) 작업을 요청하는 것이다. 이렇게 하면 최대한 쓸데없이 LOCKING된 메모리를 줄일 수 있다.
  
  

   ■ SO_RCVBUF 옵션
    이 옵션은 소켓 버퍼의 크기를 설정하는 옵션이다. 이 옵션을 사용하여 버퍼 크기를 0으로 설정하는 경우, 커널이 따로 소켓버퍼(send, recv 버퍼)를 사용하지않고 직접 유저가 설정한 버퍼(메모리)에 직접 I/O를 때려박는다. 필자는 Memory-mapped file같은 느낌이라고 이해하고 있다. 0으로 설정하면 커널 버퍼를 거치지 않고 직접 유저의 버퍼에 데이터가 저장되기 때문에, 불필요해 보이는 복사가 수행되지 않아서 성능상에 이점이 있다. 위에서 살짝 언급한것처럼 가상메모리의 영역이 하드웨어 메모리 영역과 깊은 커플링을 맺게되면서, PAGE_LOCKING의 원인이 된다. 그렇다면 유저는 복사를 하지 않는 성능 이점과 PAGE_LOCKING의 이슈를 저울질 하여 옵션을 선택해야 할 것이다.

  
  

• 이벤트 모델
  - 1_event

  // 현재 프로젝트는 GUI 프로그램이 아니라고 링커에게 알려주는것
  #pragma comment(linker, "/subsystem:console")
  #include <stdio.h>
  #include <Windows.h>
  #include <conio.h>
  
  // 윈도우 "event"개념은 linux 의 "conditional variable"가 거의
  // 유사합니다. 
  
  // 실제로 포팅할때 서로 대응되는 개념입니다. 
  
  
  DWORD __stdcall foo( void* p )
  {
  	HANDLE h = (HANDLE)p;
  
  	// 이벤트이 signal 상태 조사하기
  	DWORD ret = WaitForSingleObject( h, 0);
  
  	if ( ret == WAIT_OBJECT_0)
  		printf("시그널 상태(1) 입니다.\n");
  	else
  		printf("시그널이 아닙니다.\n");
  
  	// 시그널 될때까지 대기하는 방법
  	ret = WaitForSingleObject( h, INFINITE); // 시간(무한)
  
  	if ( ret == WAIT_OBJECT_0)
  		printf("시그널 상태(1) 입니다.\n");
  	else
  		printf("시그널이 아닙니다.\n");
  
  	return 0;
  }
  
  int main()
  {
  	HANDLE hEvent = CreateEvent( 0, 0, FALSE, // 초기 signal을
  								0);			  // 0으로
  
  	CreateThread( 0, 0, foo, (void*)hEvent, 0, 0);
  	getch();
  
  	SetEvent( hEvent); // event의 signal을 1로 변경한다.
  
  	getch();
  }
  

  
  - 2_event
   ■ WSAAsyncSelect
     : non-blocking, 비동기 통지방식 (통지 방식으로 윈도우 메시지를 사용하므로 윈도우 프로시저에서만 사용할 수 있다.)
     : 커널에게 미리 등록만 해두면 유저는 따로 커널에게 확인하여 동기화하지 않더라도 알아서 메시지가 날아온다.
     : 내부적으로 따로 체크하는 것이 아니라 운영체제가 I/O 상황이 될때 인터럽트를 사용하는 방식으로 구현되기 때문에 운영체제 수준에서도 연산량이 많이 줄어든다. 대신 다른 운영체제에서 지원하지 않는 기능이기 때문에, 다른 구동환경에서 같은 프로세스를 사용할 수가 없다는 단점은 있다.
  
   ■  WSAEventSelect
     : 이 통지방식은 다소 애매한 구석이 있다. 우선 이벤트 오브젝트를 사용하여 signal을 체크한다는 점이 동기랑 비슷한 점이 있어보인다. 그리고 wait함수로 이벤트가 발생할 때까지 대기한다는점이 blocking같기도 하다. 하지만 select나 epoll처럼 유저가 리소스를 사용하여 체크하는 것이 아니라 Wait함수를 사용하여 이벤트가 발생할 때 활성화 된다는 점이 비동기 방식에 가깝다고 생각한다.
     : WSAWaitForMultipleEvent() 함수에서 timeout 옵션이 있기 때문에 select나 epoll 처럼 어떻게 사용하느냐에 따라 blocking 방식으로 사용할 수도 non-blocking 방식으로 사용할 수도 있다.
     : 하지만 다른 점이 있다면, blocking 방식을 사용해도 멀티플렉싱이 가능하다는 점이다. 하나의 Wait에서 여러개의 I/O를 동시에 감지하고 있기 때문에, 쓰레드 하나만 wait를 통해 blocking한 상태에서 대기시키면 멀티플렉싱이 가능하다. 결과적으로는 Blocking 이면서 Non-Blocking이기도 하다.

  #pragma comment(linker,"/subsystem:console")
  
  #define WIN32_LEAN_AND_MEAN  
  #include <stdio.h>
  #include <WinSock2.h>
  #include <Windows.h>
  #include <conio.h>
  #pragma comment(lib, "ws2_32.lib") 
  
  int main()
  {
  	WSADATA w;
  	int ret = WSAStartup( MAKEWORD(2,2), &w);    
  
  	int listen_sock = socket( PF_INET,  
  						SOCK_STREAM, 
  						0);
  
  	SOCKADDR_IN addr; 
  	addr.sin_family = AF_INET;
  	addr.sin_port   = htons(4000);
  	addr.sin_addr.s_addr = INADDR_ANY; 
  	
  	bind( listen_sock, (struct sockaddr*)&addr, sizeof addr);
  
  	listen(listen_sock,  5); 
  	//------------------
  	WSAEVENT ev = WSACreateEvent(); // CreateEvent()의 네트워크
  									// 버전.
  	// 소켓을 비동기 소켓으로 변경한다.
  	WSAEventSelect( listen_sock, ev, FD_ACCEPT);
  	//-----------------------------
  
  	// 모든 소켓 핸들과 이벤트 핸들을 배열에 보관해야 합니다.
  	int sockArr[256] = { listen_sock };
  	WSAEVENT evArr[256] = { ev };
  
  	int cnt = 1;
  
  	while( 1 )
  	{
  		int pos = WSAWaitForMultipleEvents( cnt, evArr,  // event배열이름
  						FALSE, // 하나라도 signal 되면
  						WSA_INFINITE,0);
  
  
  		// 배열의 몇번째 요소인지 조사한다
  		int idx = pos - WSA_WAIT_EVENT_0;
  
  		printf("%d 번째 이벤트가 signal\n", idx);
  
  
  		WSANETWORKEVENTS netEv;
  		WSAEnumNetworkEvents( sockArr[idx], evArr[idx], &netEv);
  
  		
  		if ( netEv.lNetworkEvents & FD_READ )
  		{
  			char s[1024] = {0};
  			int n = recv( sockArr[idx], s, 1024, 0);
  			printf("도착한 data : %s\n", s);
  			strcat( s, " from Server");
  			send( sockArr[idx], s, 1024, 0);
  
  		}
  
  
  		if ( netEv.lNetworkEvents & FD_CLOSE )
  		{
  			closesocket( sockArr[idx]);
  			WSACloseEvent( evArr[idx]);
  
  			// 배열에서 제거 해야 합니다.
  			sockArr[idx] = sockArr[cnt-1];
  			evArr[idx] = evArr[cnt-1];
  
  			--cnt;
  			printf("Client 접속 끊어짐\n");
  			continue;
  		}
  
  
  
  
  		if ( netEv.lNetworkEvents & FD_ACCEPT)
  		{
  			printf("접속요청\n");
  
  
  			SOCKADDR_IN caddr;
  			int sz = sizeof caddr;
  
  			int link_sock = accept( listen_sock, 
  							(SOCKADDR*)&caddr, &sz);
  
  			WSAEVENT ev2 = WSACreateEvent();
  			WSAEventSelect( link_sock, ev2, 
  								FD_READ | FD_CLOSE);
  			
  			sockArr[cnt] = link_sock;
  			evArr[cnt] = ev2;
  			++cnt;
  
  			printf("클라이언트 접속 : %s\n", 
  						inet_ntoa( caddr.sin_addr));
  		}
  	}
  	//------------------------------
  	WSACleanup(); 
  }
  




• Overlapped IO
  : 중첩 입출력 모델
  : non-blocking, asynchronous I/O (비동기적 완료 통보)
  : 데이터 입출력이 진행되는 동안에도 다른일을 할 수 있다.
  : 원리는 리눅스의 I/O multiplexing, RTS과 비슷하다.
  
   
  : 리눅스의 I/O multiplexing, RTS와 다른점은 모드 변환이 발생하지 않는다. (user <-> kernel 여러번 데이터 복사 x)
  
  
  

  #pragma comment(linker, "/subsystem:console")
  
  #define WIN32_LEAN_AND_MEAN  
  #include <stdio.h>
  #include <WinSock2.h> 
  #include <Windows.h>  
  
  #pragma comment(lib, "ws2_32.lib") 
  
  int main()
  {
  	WSADATA w;
  	int ret = WSAStartup( MAKEWORD(2,2), &w);    
  	
  	//-------------------------------------------
  	// 1. Overlapped io를 위한 소켓 생성
  	// 표준 C 네트워크 함수 : 소문자()
  	// WSAxxxx() 함수들 : windows socket 2.0 부터 지원되는
  	//					windows만의 개념들..
  	int listen_sock = WSASocket( PF_INET, SOCK_STREAM,
  								0, 0, 0,
  								WSA_FLAG_OVERLAPPED);
  								
  
  
  
  	// 2. 소켓에 주소 지정(bind)
  	SOCKADDR_IN addr; 
  
  	addr.sin_family = AF_INET;
  	addr.sin_port   = htons(4000);
  	addr.sin_addr.s_addr = INADDR_ANY; 
  	
  	bind( listen_sock, (struct sockaddr*)&addr, sizeof addr);
  
  
  
  	listen(listen_sock,  5); 
  	struct sockaddr_in addr2;
  	int sz = sizeof addr2;
  
  
  	int link_sock = accept( listen_sock, 
  						  (struct sockaddr*)&addr2, &sz);
  
  	printf("클라이언트가 접속되었습니다\n");
  
  
  	closesocket(listen_sock); // 대기 소켓은 이제 필요없다.
  
  	// Overlapped로 수신 하는 코드
  	WSAEVENT ev = WSACreateEvent();
  	WSAOVERLAPPED ov = {0};
  	ov.hEvent = ev;
  
  
  	// 수신 버퍼..
  	char s[1024] = {0};
  	WSABUF buf;
  	buf.buf = s;
  	buf.len = 1024;
  
  	DWORD flag = 0;
  	DWORD recvBytes = 0;
  
  	int n = WSARecv( link_sock,
  					 &buf, 1,  // 버퍼와 버퍼 갯수
  					 &recvBytes, // 받을 data 크기
  					 &flag,
  					 &ov, // overlapped 구조체
  					 0);
  
  	if ( n == SOCKET_ERROR ) // -1 
  	{
  		if ( WSAGetLastError() == WSA_IO_PENDING )
  		{
  			printf("data 를 수신하고 있는 중입니다.\n");
  
  			// 비동기의 종료를 대기 해야 합니다.
  			// 비동기 IO의 종료시에는 overlapped구조체 안에 있는
  			// event가 signal 됩니다.
  			WSAWaitForMultipleEvents( 1, &ev, TRUE, 
  								WSA_INFINITE, 0);
  
  			printf("비동기 IO로 수신 완료\n");
  		}
  	}
  	else 
  		printf("data를 동기적으로 수신 : %d\n", n); 
  
  	printf("수신된 data : %s\n", buf.buf);
  
  	closesocket( link_sock);
  	//------------------------------
  	WSACleanup(); 
  }

참고: http://ozt88.tistory.com/22