오늘은 프로그래밍에서 많이 사용되는 디자인 패턴 중 하나인 Singleton 패턴에 대해 이야기해보려고 합니다.

Singleton 패턴은 객체 생성을 제한하여 하나의 인스턴스만을 사용하도록 하는 패턴으로, JAVA에서도 많이 활용되는데요.

이번 글에서는 Singleton 패턴의 응용과 JAVA에서의 사용법에 대해 자세히 알아보고자 합니다. 함께 공부해보시죠!

목차
1. Singleton 패턴의 이해
2. Singleton 패턴의 적용 시나리오
3. JAVA에서의 Singleton 패턴의 적용
4. Singleton 패턴의 코드 이해
5. Singleton 패턴의 싱글스레드 구현
6. Singleton 패턴의 멀티스레드 환경에서의 구현
7. Singleton 패턴의 장단점
8. Singleton 패턴 대안 방식 및 향상된 Singleton 패턴 이해
9. 실제 프로젝트에서의 Singleton 패턴의 활용 사례
10. JAVA에서 Singleton 패턴의 정상적인 활용을 위한 조언

1. Singleton 패턴의 이해
Singleton 패턴은 객체 지향 프로그래밍에서 중요한 개념 중 하나로, 특정 클래스의 인스턴스가 하나만 생성되도록 보장하는 디자인 패턴입니다. 이를 통해 객체를 공유하고, 자원의 낭비를 줄일 수 있습니다.

2. Singleton 패턴의 적용 시나리오
Singleton 패턴은 여러 가지 상황에서 유용하게 적용될 수 있습니다. 예를 들어, 데이터베이스 연결, 로그 라이터, 캐시 매니저 등 여러 곳에서 하나의 인스턴스만 필요한 경우에 Singleton 패턴을 적용할 수 있습니다.

3. JAVA에서의 Singleton 패턴의 적용
JAVA에서 Singleton 패턴을 적용하는 방법은 다양합니다. 가장 일반적으로 사용되는 방법은 클래스 내부에 private static 변수로 인스턴스를 선언하고, getInstance() 메서드를 통해 해당 인스턴스를 반환하는 방식입니다.

4. Singleton 패턴의 코드 이해
아래는 JAVA에서 Singleton 패턴을 구현하는 코드의 예시입니다.

public class Singleton {
    private static Singleton instance;

    private Singleton() {
    	// private 생성자
    }

    public static Singleton getInstance() {
        if(instance == null) {
        instance = new Singleton();
        }
        return instance;
    }
}

5. Singleton 패턴의 싱글스레드 구현
싱글스레드 환경에서는 위에서 소개한 코드와 같이 간단하게 Singleton 패턴을 구현할 수 있습니다. getInstance() 메서드에서 인스턴스가 null인 경우에만 인스턴스를 생성하면 됩니다.

6. Singleton 패턴의 멀티스레드 환경에서의 구현
멀티스레드 환경에서는 다수의 스레드가 동시에 getInstance() 메서드를 호출하면, 여러 개의 인스턴스가 생성되는 문제가 발생할 수 있습니다. 이를 해결하기 위해 동기화 처리를 해야 합니다. 예를 들어, getInstance() 메서드에 synchronized 키워드를 사용하거나, DCL(Double-Checked Locking) 방식을 적용할 수 있습니다.

7. Singleton 패턴의 장단점
Singleton 패턴은 다음과 같은 장단점이 있습니다.

장점:
- 하나의 인스턴스만 필요한 경우 유용하게 사용할 수 있습니다.
- 객체를 공유하여 자원을 효율적으로 활용할 수 있습니다.

단점:
- 단일 책임 원칙을 위배할 수 있습니다.
- 테스트가 어려울 수 있습니다.
- 의존성을 가질 경우 코드의 복잡성이 증가합니다.

8. Singleton 패턴 대안 방식 및 향상된 Singleton 패턴 이해
Singleton 패턴은 여러 대안 방식이 존재하며, 이를 통해 향상된 Singleton 패턴을 구현할 수 있습니다. 예를 들어, Enum을 이용한 Singleton 패턴, 초기화-on-demand holder idiom 등이 있습니다.

9. 실제 프로젝트에서의 Singleton 패턴의 활용 사례
실제 프로젝트에서 Singleton 패턴은 다양한 곳에서 활용됩니다. 예를 들어, 스프링 프레임워크에서는 Bean 객체들이 Singleton으로 관리되며, 전역적으로 공유되어 사용됩니다.

10. JAVA에서 Singleton 패턴의 정상적인 활용을 위한 조언
JAVA에서 Singleton 패턴을 정상적으로 활용하기 위해서는 다음과 같은 조언을 따를 수 있습니다.
- Lazy Initialization 방식을 적용하여 필요한 시점에 인스턴스를 생성하는 것이 좋습니다.
- 동기화 처리는 필요한 경우에만 적용해야 합니다.
- 의존성 주입(Dependency Injection)을 활용하여 유연한 코드를 작성할 수 있습니다.

이렇게 JAVA에서 Singleton 패턴을 이해하고 적용하는 방법에 대해 알아보았습니다.

Singleton 패턴은 객체 지향 프로그래밍에서 중요한 개념이므로, 다양한 상황에서 유용하게 활용할 수 있습니다.

인프런 강의 13일차.

 - 더 자바, Java 8 (백기선 강사님)

* Metaspace

 - JVM의 여러 메모리 영역 중에 PermGen 메모리 영역이 없어지고 Metaspace 영역이 생겼다.

* Heap 영역 구조

 - Young generation(=Eden)

• 객체 대부분이 생성될 때 이곳으로 들어간다.
• 이곳이 가득차면 minor gc가 발생한다.
• minor gc가 발생하면 살아있는 객체들만 체크하고 나머지는 다 없애버린다.
• 살아남은 객체들 중 더 오래 쓸 것 같은 것들은 tenured generation으로 옮긴다.

 - Old generation (=tenured generation)

• 이곳이 가득 차면 major gc가 발생한다.
• major gc는 minor gc보다 더 오래 걸린다.

 - Permanent generation

• Class의 Meta 정보나 Method의 Meta 정보, Static 변수와 상수 정보들이 저장되는 공간으로 흔히 메타데이터 저장 영역이라고도 한다. 이 영역은 Java 8 부터는 Native 영역으로 이동하여 Metaspace 영역으로 변경되었다.
• 다만, 기존 Perm 영역에 존재하던 Static Object는 Heap 영역으로 옮겨져서 GC의 대상이 최대한 될 수 있도록 하였다

# 기본적인 JVM 구조
+---------+-----+-----+-------------------+ +------+
| Eden    | S 0 | S 1 |      Tenured      | | Perm |
+---------+-----+-----+-------------------+ +------+
<- Young Generation -> <- Old Generation ->
<---------------- Total Heap Size -------->

* Java 7 Hotsop JVM 구조

# Java 7 Hotspot JVM 구조
<---- Java Heap ------> < Permanent Heap > < Native Memory  >
+------+---+---+-------+------------------+--------+--------+
| Eden | S | S |  Old  |     Permanent    | C Heap | Thread |
|      | 0 | 1 |       |                  |        | Stack  |
+------+---+---+-------+------------------+--------+--------+

* Java 8 Hotspot JVM 구조

# Java 8 Hotspot JVM 구조
<---- Java Heap ------> <--------- Native Memory ---------->
+------+---+---+-------+------------------+--------+--------+
| Eden | S | S |  Old  |     Metaspace    | C Heap | Thread |
|      | 0 | 1 |       |                  |        | Stack  |
+------+---+---+-------+------------------+--------+--------+

* Java Heap: JVM이 관리하는 영역
* Native Memory: OS에서 관리하는 영역

* GC 범위

+------+---+---+------------------+ +--------+
| Eden | S | S |     Tenured      | | Perm   |
|      | 0 | 1 |                  | |        |
+------+---+---+------------------+ +--------+
<- Young Gen -> <--- Old Gen ---->   <------->
    Minor GC         Full GC          Full GC

<-------------- GC 대상 범위 ---------------->

1. PermGen

 - permanent generation, 클래스 메타데이터를 담는 곳.

 - Heap 영역에 속함

 - 기본값으로 제한된 크기를 가지고 있음.

 - -XX:PermSize=N, PermGen 초기 사이즈 설정

 - -XX:MaxPermSize=N, PermGen 최대 사이즈 설정

2. Metaspace

 - 클래스 메타데이터를 담는 곳.

 - Heap 영역이 아니라, Native 메모리 영역이다.

 - 기본값으로 제한된 크기를 가지고 있지 않음. (필요한 만큼 계속 늘어난다)

 - Java 8부터는 PermGen 관련 java 옵션은 무시한다.

 - -XX:MetaspaceSize=N, Metaspace 초기 사이즈 설정

 - -XX:MaxMetaspaceSize=N, Metaspace 최대 사이즈 설정

인프런 강의 12일차.

 - 더 자바, Java 8 (백기선 강사님)

1. 배열 Parallel 정렬

 - Arrays.parallelSort()

   > Fork/Join 프레임워크를 사용해서 배열을 병렬로 정렬하는 기능을 제공한다.

2. 배열 정렬 알고리즘

 - 배열을 계속 둘로 쪼갠다.

 - 합치면서 정렬한다.

3. Sort()와 Parallel() 비교

package me.whiteship.java8to11;

import java.util.Arrays;
import java.util.Random;
import java.util.stream.IntStream;

public class App {

    public static <List> void main(String[] args) {
        int size = 1500;
        int[] numbers = new int[size];
        Random random = new Random();

        IntStream.range(0, size).forEach(i -> numbers[i] = random.nextInt());
        long start = System.nanoTime();
        Arrays.sort(numbers);           //sort는 쓰레드를 1개만 쓴다.(java는 퀵소트를 사용함)
        System.out.println("serial sorting took " + (System.nanoTime() - start));

        IntStream.range(0, size).forEach(i -> numbers[i] = random.nextInt());
        start = System.nanoTime();
        Arrays.parallelSort(numbers);   //반으로 쪼개고 소팅하고 합치는 과정 반복
        System.out.println("parallel sorting took " + (System.nanoTime() - start));
    }
}

 - serial sorting : 548957

 - parallel sorting : 364074

 - 알고리즘 시간복잡도는 같다 : O(n logN) 공간 O(n)