Hellow world!!

[git] user.name과 user.gmail 설정하기

주뇬 — Tue, 22 Oct 2024 10:48:13 +0900

✅ [git] user.name과 user.gmail 설정하기

전체 저장소의 user name과 user email 설정하기

$ git config --global user.name "My Name"
$ git config --global user.email "abc@gmail.com"

특정 저장소(프로젝트)에 user name과 user email 설정하기

- 특정 저장소(프로젝트의 디렉토리)에 가서 아래의 커맨드 입력

$ git config user.name "My Name"
$ git config user.email "abc@gmail.com"

설정된 user.name과 user.email 확인하기

$ git config user.name
$ git config user.email

디자인 패턴

주뇬 — Fri, 18 Oct 2024 19:25:02 +0900

✅ 디자인 패턴이란?

디자인 패턴은 소프트웨어 설계에서 자주 발생하는 문제들을 해결하기 위해 개발된, 검증된 재사용 가능한 설계 구조입니다.

디자인 패턴은 객체 지향 설계 원칙 SOLID을 기반으로 하며, 소프트웨어의 유지보수성과 확장성을 높이는 데 도움이 됩니다. 각 디자인 패턴은 특정 상황에서 어떻게 클래스를 구성하고 상호작용해야 하는지에 대한 명확한 방법을 제시합니다.

디자인 패턴은 크게 생성, 구조, 행위로 분류됩니다.

1. 생성 패턴 (Creational Patterns)

생성 패턴은 객체 생성 메커니즘에 중점을 두어, 객체 생성 과정에서의 복잡성을 숨기고, 유연성을 제공하는 패턴입니다. 객체를 어떻게 생성하고 관리할 것인가에 대한 방법을 다룹니다.

싱글턴 패턴 (Singleton Pattern): 클래스의 인스턴스를 하나만 생성하고, 그 인스턴스를 어디서든지 접근할 수 있도록 하는 패턴.
팩토리 메서드 패턴 (Factory Method Pattern): 객체 생성의 책임을 서브클래스에 위임하여, 어떤 클래스의 인스턴스를 생성할지 서브클래스가 결정하도록 하는 패턴.
추상 팩토리 패턴 (Abstract Factory Pattern): 서로 관련된 객체들의 군을 생성할 수 있는 인터페이스를 제공하는 패턴.
빌더 패턴 (Builder Pattern): 복잡한 객체의 생성 과정을 단계별로 분리하여, 객체의 생성과정을 더 유연하게 하는 패턴.
프로토타입 패턴 (Prototype Pattern): 객체를 새로 생성하는 대신 이미 존재하는 객체를 복제하여 새로운 객체를 생성하는 패턴.

2. 구조 패턴 (Structural Patterns)

구조 패턴은 클래스와 객체 간의 관계를 정의하여, 더 큰 구조를 형성하는 패턴입니다. 객체와 클래스의 구성 방식을 다루어, 그들의 관계와 구조를 쉽게 변경할 수 있게 합니다.

어댑터 패턴 (Adapter Pattern): 클래스의 인터페이스를 다른 인터페이스로 변환하여, 호환되지 않는 인터페이스를 가진 클래스들이 함께 동작할 수 있도록 하는 패턴.
데코레이터 패턴 (Decorator Pattern): 객체에 동적으로 새로운 기능을 추가할 수 있는 패턴으로, 기존의 객체를 수정하지 않고도 기능을 확장할 수 있음.
프록시 패턴 (Proxy Pattern): 실제 객체에 대한 대리 객체를 제공하여, 객체에 접근을 제어하는 패턴.
브리지 패턴 (Bridge Pattern): 추상화와 구현을 분리하여 각각 독립적으로 변화할 수 있도록 설계하는 패턴.
컴포지트 패턴 (Composite Pattern): 객체들을 트리 구조로 구성하여 부분-전체 계층을 표현하는 패턴. 클라이언트가 개별 객체와 복합 객체를 동일하게 다룰 수 있음.
퍼사드 패턴 (Facade Pattern): 복잡한 서브 시스템에 대한 단순화된 인터페이스를 제공하는 패턴.

3. 행위 패턴 (Behavioral Patterns)

행위 패턴은 객체 간의 상호작용을 정의하고, 객체들 간의 통신과 책임 분담을 설계하는 패턴입니다. 객체들 간의 협력 방식이나 흐름을 다룹니다.

옵저버 패턴 (Observer Pattern): 한 객체의 상태 변화가 있을 때, 의존하는 다른 객체들에게 자동으로 알림을 보내는 패턴. 주로 이벤트 시스템에서 사용됨.
전략 패턴 (Strategy Pattern): 행위의 알고리즘을 각각 별도의 클래스로 정의하고, 런타임에 행위의 알고리즘을 선택할 수 있도록 하는 패턴.
상태 패턴 (State Pattern): 객체의 내부 상태에 따라 행동을 달리하는 패턴으로, 상태의 변화에 따라 객체의 행위가 달라짐.
템플릿 메서드 패턴 (Template Method Pattern): 상위 클래스에서 알고리즘의 구조를 정의하고, 하위 클래스에서 구체적인 단계를 구현하는 패턴.
커맨드 패턴 (Command Pattern): 요청을 캡슐화하여 객체로 만들고, 요청을 저장하거나 로깅하는 등의 작업을 수행할 수 있게 하는 패턴.
미디에이터 패턴 (Mediator Pattern): 객체들이 직접 통신하지 않고 **중재자(Mediator)**를 통해 소통하게 하는 패턴. 객체들 간의 결합도를 줄일 수 있음.
메멘토 패턴 (Memento Pattern): 객체의 상태를 저장하고 복원할 수 있는 패턴으로, 객체의 이전 상태를 복구할 수 있도록 함.

✅ 디자인 패턴의 장/단점

장점

재사용성 향상: 검증된 해결책을 제공하여 유사한 문제에 코드를 재사용할 수 있게 합니다.
유지보수성 개선: 코드의 구조화와 가독성을 높여 유지보수가 쉬워집니다.
확장성 제공: 기존 코드 수정 없이 새로운 기능을 추가하거나 변경할 수 있습니다.
코드 품질 향상: 구조화된 접근 방식으로 코드의 전반적인 품질이 개선됩니다.
개발자 간 의사소통 개선: 공통 어휘를 제공하여 개발자 간 의사소통을 원활하게 합니다.

단점

과도한 사용 위험: 필요 이상으로 사용하면 시스템이 불필요하게 복잡해질 수 있습니다
성능 저하 가능성: 일부 패턴은 추가적인 추상화 레이어로 인해 성능에 부정적 영향을 줄 수 있습니다
학습 곡선: 패턴을 이해하고 적절히 적용하는 데 시간과 노력이 필요합니다
코드 복잡성 증가: 일부 패턴은 추가적인 클래스와 인터페이스를 도입하여 코드 복잡성을 높일 수 있습니다
오버엔지니어링 위험: 간단한 문제에 복잡한 패턴을 적용하면 불필요한 복잡성이 생길 수 있습니다

모든 문제의 해결책들이 디자인패턴에 꼭 정답이 있는게 아닙니다. 상황에 맞게 적절히 사용해야 하며 각 패턴의 장단점을 이해하고, 문제의 특성과 요구사항을 고려하여 신중하게 적용해야 합니다.

객체 지향 설계 원칙 SOLID

주뇬 — Fri, 18 Oct 2024 18:12:32 +0900

✅ 객체 지향 설계 원칙 SOLID

객체지향 설계 5대 원칙(SOLID)들은 코드의 유지보수성, 확장성, 재사용성을 높이고 결합도는 낮추며 응집도는 높이는 것을 목표로 합니다. 이를 통해 변경에 유연하고 견고한 애플리케이션을 만들수 있습니다.

1. 단위 책임 원칙 - SRP (Single Responsibility Principle)

하나의 클래스는 하나의 책임만 가져야 한다.
클래스는 하나의 기능 또는 역할을 가져야 하며, 그 외의 다른 책임을 맡지 않아야 한다는 원칙입니다. 이 원칙을 따름으로써 클래스가 명확한 목적을 가지게 되고, 변화가 필요한 부분이 생기면 한 곳만 수정할 수 있어 유지보수가 쉬워집니다.

사용자의 로그인과 데이터베이스의 처리를 동시에 담당하는 클래스 대신, 각각의 역할을 담당하는 loginService와 DatabaseService클래스를 분리하는 것이 좋습니다.

2. 개방 폐쇄 원칙 - OCP (Open-Closed Principle)

클래스는 확장에는 열려 있어야 하고, 수정에는 닫혀 있어야 한다.
새로운 기능이 추가될 때 기존 코드를 수정하지 않고, 확장하여 사용할 수 있어야 한다는 원칙입니다. 이를 통해 기존 코드가 변경되지 않기 때문에 버그가 발생할 확률을 줄일 수 있습니다.

새로운 기능이 필요할 때 기존 클래스를 수정하는 대신, 기존 클래스를 상속하거나 인터페이스를 구현하여 새로운 기능을 추가하는 방법입니다.

3. 리스코프 치환 원칙 - LSP (Liskov Substitution Principle)

서브 타입은 언제나 기반 타입으로 교체할 수 있어야 한다.
자식 클래스는 언제나 부모 클래스를 대체할 수 있어야 하며, 자식 클래스가 부모 클래스의 행위를 변경하지 않아야 한다는 원칙입니다. 이를 통해 상속 구조에서 일관성을 유지하고 예측 가능한 코드 동작을 보장할 수 있습니다.

4. 인터페이스 분리 원칙 - ISP (Interface Segregation Principle)

클라이언트는 자신이 사용하지 않는 메서드에 의존하지 않아야 한다.
하나의 큰 인터페이스 대신 여러 개의 작은 인터페이스로 분리하여, 사용하지 않는 메소드를 구현하지 않도록 해야 한다는 원칙입니다. 이를 통해 인터페이스는 더 명확하고, 필요하지 않은 기능 때문에 코드가 복잡해지는 것을 방지할 수 있습니다.

동물 행동 인터페이스에 fly(), swim(), walk() 메소드를 모두 포함하기보다, 각각 Flyable, Swimmable, Walkable 인터페이스로 나눠서 필요한 행동만 구현하도록 하는 것이 더 바람직합니다.

5. 의존 역전 원칙 - DIP (Dependency Inversion Principle)

고수준 모듈은 저수준 모듈에 의존해서는 안 되며, 둘 다 추상화에 의존해야 한다.
구체적인 구현보다 인터페이스나 추상 클래스에 의존하도록 설계하여, 모듈 간의 결합도를 낮추는 원칙입니다. 이를 통해 코드 변경 시 서로 영향을 주지 않고 쉽게 확장하거나 교체할 수 있습니다.

서비스 클래스가 직접 MySQLDatabase 클래스에 의존하기보다, Database라는 추상 인터페이스에 의존하게 함으로써 OracleDatabase로 쉽게 교체할 수 있게 설계하는 것이 좋습니다.

Java 8~21 버전별 차이점

주뇬 — Fri, 18 Oct 2024 14:13:41 +0900

✅ Java 8~21 버전별 차이점

https://www.java.com/releases/

JDK Releases

The release information on this page covers the JDK releases that were widely distributed or significant to the development of Java. It does not cover patch releases or other one-off releases.

www.java.com

Java 8 (2014년 출시)

Java 8은 Java 언어에 큰 변화를 가져온 버전으로, 이후의 많은 기능들이 Java 8의 기능에 기반하고 있습니다.

32비트를 지원하는 공식적인 마지막 버전
람다 표현식 (Lambda Expressions): 함수형 프로그래밍을 도입하여 코드 간결화.
스트림 API (Stream API): 컬렉션 데이터를 처리하기 위한 선언형 API로, 필터링, 매핑, 축소(reduction) 등의 작업을 더 쉽게 수행.
인터페이스의 디폴트 메서드 (Default Methods): 인터페이스에 메서드 구현을 제공할 수 있도록 허용.
Optional 클래스: NullPointerException 방지를 위해 사용되는 객체 래핑 클래스.
새로운 날짜 및 시간 API: java.time 패키지를 통해 더 나은 날짜 및 시간 처리를 제공.
Perm Gem 영역삭제 (참고 : https://johngrib.github.io/wiki/java8-why-permgen-removed/)

1. 람다표현식

public class ExampleLambda {
	public static void main(String[] args) {
    	List<String> names = Arrays.asList("Park", "Kim", "Choi", "Lee");
        
        // 람다 표현식
        names.forEach(name -> System.out.println(name));
    }
}

2. 스트림API

public class ExampleStream {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // 스트림을 이용한 필터링과 출력
        numbers.stream()
               .filter(n -> n % 2 == 0) // 짝수만 필터링
               .forEach(System.out::println);
    }
}

3. 인터페이스의 디폴트 메소드

interface MyInterface {
    default void defaultMethod() {
        System.out.println("This is a default method");
    }
}

public class DefaultMethodExample implements MyInterface {
    public static void main(String[] args) {
        DefaultMethodExample obj = new DefaultMethodExample();
        obj.defaultMethod(); // 디폴트 메소드 호출
    }
}

4. 새로운 날짜와 시간 API

public class ExampleDateTime {
    public static void main(String[] args) {
        LocalDate date = LocalDate.now();
        System.out.println("현재 날짜: " + date);

        LocalTime time = LocalTime.now();
        System.out.println("현재 시간: " + time);

        LocalDateTime dateTime = LocalDateTime.now();
        System.out.println("현재 날짜와 시간: " + dateTime);

        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String formattedDateTime = dateTime.format(formatter);
        System.out.println("형식화된 날짜와 시간: " + formattedDateTime);
    }
}

5. Optional클래스

public class ExampleOptional {
    public static void main(String[] args) {
        String name = "John";
        Optional<String> optionalName = Optional.ofNullable(name);
        
        System.out.println("이름 길이: " + optionalName.map(String::length).orElse(0));
        
        String nullName = null;
        Optional<String> optionalNullName = Optional.ofNullable(nullName);
        
        System.out.println("Null 이름 길이: " + optionalNullName.map(String::length).orElse(0));
    }
}

Java 9 (2017년 출시)

Java 9에서는 주요한 시스템적인 변화가 있었으며, 특히 모듈 시스템 도입이 큰 변화였습니다.

모듈 시스템 (Project Jigsaw): 대규모 애플리케이션을 모듈화할 수 있는 module-info.java 도입.
JShell: 인터랙티브한 REPL(Read-Eval-Print Loop) 도구로, Java 코드를 바로 실행할 수 있게 함.
스트림 API 개선: takeWhile(), dropWhile(), iterate() 등의 메서드 추가.
HTTP/2 클라이언트: 비동기 HTTP/2 호출을 지원하는 새 HTTP 클라이언트 API 도입.

1. 모듈 시스템

// module-info.java 파일을 프로젝트 루트에 생성
module mymodule {
    exports com.example.mymodule;
}

// 모듈사용예시
package com.example.mymodule;

public class MyModuleClass {
    public static void sayHello() {
        System.out.println("Hello from mymodule!");
    }
}

// 모듈을 통해서 서로 다른 패키지 간 의존성을 관리하고 접근 범위를 제어할수 있습니다.

2. 인터페이스의 private메소드

- Java9부터 인터페이스에 private메소드를 정의할수 있어서 코드 재사용이 더 용이해짐

interface MyInterface {
    default void method1() {
        System.out.println("Method 1");
        commonMethod();
    }

    default void method2() {
        System.out.println("Method 2");
        commonMethod();
    }

    // private 메소드 정의
    private void commonMethod() {
        System.out.println("This is a common method");
    }
}

public class PrivateMethodInInterfaceExample implements MyInterface {
    public static void main(String[] args) {
        PrivateMethodInInterfaceExample obj = new PrivateMethodInInterfaceExample();
        obj.method1();
        obj.method2();
    }
}

3. Stream API 개선

- Java 9에서는 takeWhile, dropWhile, iterate 등의 새로운 메소드가 Stream API에 추가되었습니다.

public class StreamAPIExample {
    public static void main(String[] args) {
        // takeWhile 예제
        Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
              .takeWhile(n -> n < 5) // 조건이 true인 동안만 요소를 가져옴
              .forEach(System.out::println);

        // dropWhile 예제
        Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
              .dropWhile(n -> n < 5) // 조건이 true인 동안은 건너뛰고 나머지를 가져옴
              .forEach(System.out::println);
    }
}

4. Optional 클래스 개선

- ifPresentOrElse, or, stream 등의 새로운 메소드가 추가

public class OptionalExample {
    public static void main(String[] args) {
        Optional<String> optionalValue = Optional.of("Hello");

        // ifPresentOrElse 메소드
        optionalValue.ifPresentOrElse(
            System.out::println, 
            () -> System.out.println("Value is absent")
        );

        // stream 메소드
        optionalValue.stream()
                     .forEach(System.out::println);
    }
}

5. try-with-resources 개선

public class TryWithResourcesExample {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new FileReader("test.txt"));

        // 이미 선언된 리소스를 try-with-resources에서 사용
        try (reader) {
            System.out.println(reader.readLine());
        }
    }
}

Java 10 (2018년 출시)

Java 10은 짧은 릴리스 주기로 제공되었으며, 주로 성능 향상 및 개발자 경험 개선에 초점을 맞췄습니다.

지역 변수 타입 추론 (var): 컴파일러가 자동으로 변수 타입을 추론하여 개발자가 명시적으로 타입을 선언할 필요가 없음.
Garbage Collector 개선: G1 GC를 기본 GC로 지정하고 성능 최적화.

1. var키워드를 통한 지역변수 타입 추론

public class ExampleVar {
    public static void main(String[] args) {
        // var 키워드를 사용하여 타입 추론
        var message = "Hello, Java 10!";
        System.out.println(message);

        var numbers = List.of(1, 2, 3, 4, 5);
        System.out.println("List: " + numbers);

        var list = new ArrayList<String>();
        list.add("Java");
        list.add("10");
        System.out.println("ArrayList: " + list);
    }
}

2. List.copyOf(), Set.copyOf(), Map.copyOf() 메소드

- 컬렉션을 복사하여 불변 컬렉션을 생성하는 메소드가 추가

public class CopyOfExample {
    public static void main(String[] args) {
        // 기존 리스트 복사하여 불변 리스트 생성
        List<Integer> originalList = List.of(1, 2, 3);
        List<Integer> copyList = List.copyOf(originalList);
        System.out.println("List.copyOf: " + copyList);

        // 기존 셋 복사하여 불변 셋 생성
        Set<String> originalSet = Set.of("A", "B", "C");
        Set<String> copySet = Set.copyOf(originalSet);
        System.out.println("Set.copyOf: " + copySet);

        // 기존 맵 복사하여 불변 맵 생성
        Map<String, Integer> originalMap = Map.of("one", 1, "two", 2);
        Map<String, Integer> copyMap = Map.copyOf(originalMap);
        System.out.println("Map.copyOf: " + copyMap);
    }
}

3. Optional.orElseThrow() 메소드

public class OptionalExample {
    public static void main(String[] args) {
        Optional<String> optional = Optional.of("Hello, Java 10!");

        // 값이 없을 때 NoSuchElementException을 던짐
        String value = optional.orElseThrow();
        System.out.println(value);
    }
}

4. Collectors.toUnmodifiableList(), Collectors.toUnmodifiableSet(), Collectors.toUnmodifiableMap()

- Java 10에서는 스트림 처리 중 결과를 불변 컬렉션으로 수집하는 새로운 Collectors 메소드가 추가되었습니다. 이를 통해 수집된 컬렉션을 변경할 수 없도록 할 수 있습니다.

public class UnmodifiableCollectorsExample {
    public static void main(String[] args) {
        // 스트림을 불변 리스트로 수집
        List<String> unmodifiableList = Stream.of("A", "B", "C")
                                              .collect(Collectors.toUnmodifiableList());

        System.out.println("Unmodifiable List: " + unmodifiableList);

        // 리스트에 요소를 추가하려고 하면 UnsupportedOperationException 발생
        // unmodifiableList.add("D"); // 실행 시 예외 발생
    }
}

5. G1 가비지 컬렉터의 향상된 메모리 관리

- G1 가비지 컬렉터가 기본 가비지 컬렉터로 설정되었으며, 전체 힙 영역을 동적으로 할당하는 기능이 추가되었습니다. 이로 인해 메모리 사용이 더욱 효율적이게 되었습니다.

Java 11 (2018년 출시, LTS)

Java 11은 장기 지원(Long-Term Support, LTS) 버전으로, 안정성과 기능을 제공하여 많은 기업에서 널리 사용됩니다.

Open JDK와 Oracle JDK 통합
람다 지역 변수 사용 방법 변경 (var)
새로운 HTTP 클라이언트 API (HTTP/2 지원): HTTP/2 및 WebSocket을 지원하는 새 클라이언트 API가 정식으로 도입됨.
- 버전11 부터 Java Http Client API는 최신 HTTP 표준 클라이언트를 구현하여 동기 및 비동기 프로그래밍 모델인 HTTP/1.1 및 HTTP/2를 지원함
새로운 String 메서드: isBlank(), lines(), repeat(), strip() 등의 유용한 String 메서드 추가.
표준화된 런타임 로드 가능성: Java 런타임에서 dynamic 클래스 파일을 로드할 수 있는 기능 추가.
응용 프로그램의 일부로 포함할 수 있는 Java 런타임: 기존의 java --add-modules로 여러 모듈을 조합 가능.

1. var를 사용한 람다 표현식의 지역 변수 타입 추론

public class LambdaVarExample {
    public static void main(String[] args) {
        BiFunction<Integer, Integer, Integer> add = (var a, var b) -> a + b;
        System.out.println(add.apply(10, 20));  // 출력: 30
    }
}

2. 새로운 String 메소드

public class StringMethodsExample {
    public static void main(String[] args) {
        String str = "  Hello Java 11!  ";

        // isBlank() 메소드
        System.out.println("".isBlank());  // 출력: true

        // strip() 메소드
        System.out.println("[" + str.strip() + "]");  // 출력: [Hello Java 11!]

        // lines() 메소드
        String multiLineStr = "Hello\nJava 11\n!";
        multiLineStr.lines().forEach(System.out::println);  
        // 출력:
        // Hello
        // Java 11
        // !

        // repeat() 메소드
        String repeated = "Hello ".repeat(3);
        System.out.println(repeated);  // 출력: Hello Hello Hello 
    }
}

3. HTTP Client 표준화

public class HttpClientExample {
    public static void main(String[] args) throws IOException, InterruptedException {
        // HttpClient 생성
        HttpClient client = HttpClient.newHttpClient();

        // 요청 생성
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://postman-echo.com/get"))
                .build();

        // 응답 받기
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

        // 응답 내용 출력
        System.out.println(response.body());
    }
}

4. 파일 읽기 및 쓰기 간소화

public class FileReadWriteExample {
    public static void main(String[] args) throws IOException {
        Path filePath = Path.of("example.txt");

        // 파일에 문자열 쓰기
        Files.writeString(filePath, "Hello, Java 11!");

        // 파일에서 문자열 읽기
        String content = Files.readString(filePath);
        System.out.println(content);  // 출력: Hello, Java 11!
    }
}

5. Optional 클래스의 isEmpty() 메소드 추가

public class OptionalExample {
    public static void main(String[] args) {
        Optional<String> optional = Optional.ofNullable(null);

        // isEmpty() 메소드 사용
        if (optional.isEmpty()) {
            System.out.println("Optional is empty!");  // 출력: Optional is empty!
        }
    }
}

6. Java EE와 CORBA 모듈 제거

- 11에서는 자바 EE 및 CORBA 관련 모듈이 더 이상 포함되지 않으며, 자바 스크립트 엔진 사용도 중단되었습니다. 이런 모듈들은 자주 사용되지 않으며, 필요할 경우 외부 라이브러리로 대체 가능

Java 12 (2019년 출시)

Java 12는 성능 및 새로운 기능들을 실험적으로 도입한 버전입니다.

Switch Expressions (미리보기 기능): switch 문을 표현식으로 사용 가능.
Garbage Collector 개선: G1 GC에 대한 성능 개선 및 Shenandoah GC 추가.

1. switch 표현식 (Switch Expressions) - 프리뷰 기능

public class SwitchExpressionExample {
    public static void main(String[] args) {
        int day = 2;

        // Java 12의 switch 표현식
        String dayName = switch (day) {
            case 1 -> "Sunday";
            case 2 -> "Monday";
            case 3 -> "Tuesday";
            case 4 -> "Wednesday";
            case 5 -> "Thursday";
            case 6 -> "Friday";
            case 7 -> "Saturday";
            default -> throw new IllegalArgumentException("Invalid day: " + day);
        };

        System.out.println("Day " + day + " is " + dayName);
    }
}

2. Collectors.teeing() 메소드

public class TeeingCollectorExample {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // 평균과 합을 동시에 계산
        var result = numbers.stream()
            .collect(Collectors.teeing(
                Collectors.summingInt(Integer::intValue),
                Collectors.averagingInt(Integer::intValue),
                (sum, avg) -> "Sum: " + sum + ", Average: " + avg
            ));

        System.out.println(result);  // 출력: Sum: 55, Average: 5.5
    }
}

3. 새로운 String 메소드 (indent, transform)

public class StringMethodsExample {
    public static void main(String[] args) {
        String text = "Hello\nJava 12!";

        // indent() 메소드
        String indented = text.indent(4);
        System.out.println("Indented Text: ");
        System.out.println(indented);

        // transform() 메소드
        String transformed = text.transform(str -> str.toUpperCase());
        System.out.println("Transformed Text: " + transformed);  // 출력: HELLO\nJAVA 12!
    }
}

4. 파일 및 프로세스 API 개선

public class FileMismatchExample {
    public static void main(String[] args) throws IOException {
        Path file1 = Files.writeString(Files.createTempFile("file1", ".txt"), "Hello Java 12");
        Path file2 = Files.writeString(Files.createTempFile("file2", ".txt"), "Hello Java 11");

        // 두 파일의 불일치 위치 찾기
        long mismatch = Files.mismatch(file1, file2);
        System.out.println("Mismatch at byte position: " + mismatch);  // 출력: Mismatch at byte position: 9
    }
}

5. Shenandoah 가비지 컬렉터

- 새로운 가비지 컬렉터인 Shenandoah가 실험적으로 도입되었습니다. Shenandoah는 짧은 GC 지연 시간에 중점을 둔 가비지 컬렉터입니다. 이 예제는 Shenandoah GC를 직접 보여주지 않지만, GC를 활성화하는 방법은 다음과 같습니다.

6. JVM 개선 사항

- JVM에 몇 가지 중요한 개선 사항이 추가되었습니다. 그 중 하나는 JEP 346: Promptly Return Unused Committed Memory입니다. 이 기능은 JVM이 더 이상 사용하지 않는 메모리를 시스템에 빠르게 반환할 수 있게 해줍니다. 이 기능은 특히 메모리 효율성을 높이는데 유용합니다

Java 13 (2019년 출시)

Java 13은 간단한 개선 사항들을 도입했습니다.

텍스트 블록 (Text Blocks, 미리보기): 여러 줄의 문자열을 더욱 가독성 있게 작성할 수 있는 기능.
Switch Expressions (미리보기): Switch 표현식이 더욱 간결하게 개선됨.

1. 텍스트 블록 (Text Blocks) - 프리뷰 기능

public class TextBlockExample {
    public static void main(String[] args) {
        String textBlock = """
                Hello, Java 13!
                This is a text block.
                It makes multi-line strings easier to write.
                """;

        System.out.println(textBlock);
    }
}

2. switch 표현식의 정식 도입

public class SwitchExpressionExample {
    public static void main(String[] args) {
        int day = 2;

        // Java 13의 switch 표현식
        String dayName = switch (day) {
            case 1 -> "Sunday";
            case 2 -> "Monday";
            case 3 -> "Tuesday";
            case 4 -> "Wednesday";
            case 5 -> "Thursday";
            case 6 -> "Friday";
            case 7 -> "Saturday";
            default -> throw new IllegalArgumentException("Invalid day: " + day);
        };

        System.out.println("Day " + day + " is " + dayName);
    }
}

3. yield를 사용한 switch 표현식

public class YieldInSwitchExample {
    public static void main(String[] args) {
        int score = 85;

        // Java 13의 switch 표현식에서 yield 사용
        String grade = switch (score / 10) {
            case 10, 9 -> "A";
            case 8 -> "B";
            case 7 -> "C";
            case 6 -> "D";
            default -> {
                // 여러 줄의 복잡한 로직이 있을 때 yield 사용 가능
                System.out.println("Failing grade.");
                yield "F";
            }
        };

        System.out.println("Grade: " + grade);  // 출력: Grade: B
    }
}

4. ZGC (Z Garbage Collector) 개선
5. 힙 영역 확장 (Dynamic CDS Archives)

Java 14 (2020년 출시)

Java 14는 생산성 향상을 위한 몇 가지 흥미로운 기능을 도입했습니다.

Pattern Matching for instanceof (미리보기): instanceof와 타입 캐스팅을 결합하여 코드 간소화.
Record 타입 (미리보기): 불변 데이터 구조를 간결하게 정의할 수 있는 Record 타입 추가.
NPE 개선: NullPointerException 발생 시 더 구체적인 정보를 제공하도록 개선.

1. switch 표현식의 개선 (Switch Expressions) - 정식 도입

- switch 표현식이 정식 기능으로 도입되었습니다. 이 기능은 yield를 사용하여 결과를 반환할 수 있으며, 기존의 switch 문보다 간결한 코드를 작성할 수 있습니다.

2. NullPointerException의 상세 메시지 개선

- NullPointerException의 메시지를 더 상세하게 표시할 수 있게 되었습니다. 이제 어디에서 null이 발생했는지 정확한 정보를 얻을 수 있습니다.

3. 레코드 (Records) - 프리뷰 기능

// 레코드 정의
public record Person(String name, int age) {}

public class RecordExample {
    public static void main(String[] args) {
        // 레코드 인스턴스 생성
        Person person = new Person("John", 25);

        // 자동 생성된 메소드 사용
        System.out.println(person.name());  // 출력: John
        System.out.println(person.age());   // 출력: 25
        System.out.println(person);         // 출력: Person[name=John, age=25]
    }
}

4. 패턴 매칭을 이용한 instanceof

- instanceof 구문에서 타입 캐스팅을 더 간결하게 할 수 있는 패턴 매칭 기능이 추가되었습니다. 이제 instanceof로 타입을 확인한 후, 바로 해당 타입으로 변환할 수 있습니다.

public class InstanceofPatternMatchingExample {
    public static void main(String[] args) {
        Object obj = "Hello, Java 14!";

        // 패턴 매칭을 사용한 instanceof
        if (obj instanceof String s) {
            System.out.println(s.toUpperCase());  // 출력: HELLO, JAVA 14!
        }
    }
}

5. helpful NullPointerExceptions 옵션

- NullPointerException에 대한 유용한 정보가 포함된 상세 메시지를 제공하는 helpful NullPointerExceptions 옵션이 추가되었습니다. 이를 통해 디버깅이 훨씬 쉬워집니다. JVM을 실행할 때 다음과 같은 옵션을 추가할 수 있습니다.

java -XX:+ShowCodeDetailsInExceptionMessages MyApp.jar

6. JEP 367: ZGC on macOS and Windows

- ZGC(Z Garbage Collector)가 macOS와 Windows에서도 사용 가능하게 되었습니다. ZGC는 매우 짧은 지연 시간으로 동작하는 가비지 컬렉터입니다. 예제 코드로는 직접 확인하기 어렵지만, ZGC를 사용하는 방식은 다음과 같습니다

java -XX:+UseZGC -Xmx4g -Xms4g MyApp.jar

Java 15 (2020년 출시)

Java 15는 여러 실험적 기능들을 완성시키는 중요한 버전입니다.

텍스트 블록 (Text Blocks, 정식): 여러 줄 문자열을 쉽게 작성할 수 있도록 하는 기능이 정식으로 도입됨.
Sealed 클래스 (미리보기): 클래스 계층을 제한하는 기능으로, 특정 클래스만 상속할 수 있도록 허용.
Hidden 클래스: 런타임에서 생성되고 이후 다시 사용되지 않는 클래스들을 위한 기능.

1. 레코드 (Records) - 개선

2. Sealed Classes (봉인된 클래스) - 프리뷰 기능

// 봉인된 클래스 정의
public sealed class Shape permits Circle, Square {}

final class Circle extends Shape {
    double radius;
}

final class Square extends Shape {
    double side;
}

public class SealedClassExample {
    public static void main(String[] args) {
        Shape shape1 = new Circle();
        Shape shape2 = new Square();
        System.out.println("Shape1 is a " + shape1.getClass().getSimpleName());
        System.out.println("Shape2 is a " + shape2.getClass().getSimpleName());
    }
}

3. 텍스트 블록 (Text Blocks) - 정식 도입

4. 패턴 매칭을 이용한 instanceof의 개선

5. 숨겨진 클래스 (Hidden Classes)

- **숨겨진 클래스 (Hidden Classes)**라는 기능이 추가되었습니다. 이 클래스는 런타임에만 사용되고, 직접적으로 참조할 수 없는 클래스로, 주로 프레임워크에서 동적으로 클래스를 생성할 때 유용합니다. 예제 코드로는 다소 복잡하며, 프레임워크 수준에서 주로 사용됩니다.

Java 16 (2021년 출시)

Java 16은 성능과 생산성 향상에 초점을 맞췄습니다.

Record (정식): Record 타입이 정식 기능으로 도입되어 불변 객체의 선언이 간소화됨.
패턴 매칭 for instanceof (정식): instanceof와 함께 사용 가능한 패턴 매칭이 정식으로 도입됨.
Stream.toList(): 스트림을 리스트로 쉽게 변환할 수 있는 새로운 메서드 추가.

1. 레코드 (Records) - 정식 기능

2. 패턴 매칭을 이용한 instanceof - 정식 도입

3. Stream API 개선

4. 프록시의 직렬화 기능 개선

5. Vector API (Incubator)

public class VectorAPIExample {
    public static void main(String[] args) {
        // Int 벡터 연산 예제
        VectorSpecies<Integer> SPECIES = IntVector.SPECIES_256;
        int[] a = {1, 2, 3, 4, 5, 6, 7, 8};
        int[] b = {1, 2, 3, 4, 5, 6, 7, 8};
        int[] c = new int[8];

        var av = IntVector.fromArray(SPECIES, a, 0);
        var bv = IntVector.fromArray(SPECIES, b, 0);
        var cv = av.add(bv);
        cv.intoArray(c, 0);

        for (int value : c) {
            System.out.println(value);  // 출력: 2 4 6 8 10 12 14 16
        }
    }
}

6. Sealed Classes (봉인된 클래스) - 프리뷰 기능 (계속 개선)

Java 17 (2021년 출시, LTS)

Java 17은 Java 11 이후의 두 번째 장기 지원(LTS) 버전으로, 많은 새로운 기능과 안정성 개선이 포함되었습니다.

Sealed 클래스 (정식): 서브클래스를 제한하는 기능이 정식으로 도입됨.
Pattern Matching for switch (미리보기): switch 문에서 패턴 매칭을 사용할 수 있음.
Foreign Function & Memory API (미리보기): 외부 메모리 접근과 외부 함수 호출을 보다 효율적으로 할 수 있는 API 추가.

1. 패턴 매칭을 이용한 switch 표현식

public class PatternMatchingSwitchExample {
    public static void main(String[] args) {
        Object obj = "Hello, Java 17!";

        // 패턴 매칭을 이용한 switch 표현식
        String result = switch (obj) {
            case Integer i -> "Integer: " + i;
            case String s -> "String: " + s;
            case null -> "Null value";
            default -> "Unknown type";
        };

        System.out.println(result);  // 출력: String: Hello, Java 17!
    }
}

2. 레코드 (Records)와 Sealed Classes의 조합

public sealed interface Shape permits Circle, Rectangle {}

public record Circle(double radius) implements Shape {}

public record Rectangle(double width, double height) implements Shape {}

public class SealedRecordExample {
    public static void main(String[] args) {
        Shape shape = new Circle(5.0);

        String description = switch (shape) {
            case Circle c -> "Circle with radius: " + c.radius();
            case Rectangle r -> "Rectangle with width: " + r.width() + " and height: " + r.height();
        };

        System.out.println(description);  // 출력: Circle with radius: 5.0
    }
}

3. 강력한 Random구현

public class RandomExample {
    public static void main(String[] args) {
        // RandomGenerator 인터페이스를 이용한 랜덤 숫자 생성기
        RandomGenerator generator = RandomGeneratorFactory.of("Xoshiro256PlusPlus").create();

        for (int i = 0; i < 5; i++) {
            System.out.println(generator.nextInt(100));  // 0부터 100 사이의 난수 출력
        }
    }
}

Java 18 (2022년 출시)

Java 18은 주로 성능과 개발자 경험 향상에 초점을 맞춘 버전입니다.

Simple Web Server: 간단한 개발 및 테스트용 웹 서버 추가.
UTF-8 기본 문자 인코딩: 모든 플랫폼에서 UTF-8을 기본 인코딩으로 사용하도록 표준화.

1. Simple Web Server

public class SimpleWebServerExample {
    public static void main(String[] args) throws IOException {
        // HTTP 서버 생성
        HttpServer server = HttpServer.create(new InetSocketAddress(8080), 0);

        // 요청에 대해 간단한 응답 작성
        server.createContext("/", exchange -> {
            String response = "Hello, Java 18!";
            exchange.sendResponseHeaders(200, response.getBytes().length);
            exchange.getResponseBody().write(response.getBytes());
            exchange.close();
        });

        // 서버 시작
        server.start();
        System.out.println("Server started at http://localhost:8080");
    }
}

2. Code Snippets in JavaDoc (JEP 413)

/**
 * 이 클래스는 Java 18의 JavaDoc 코드 스니펫 기능을 보여줍니다.
 * {@snippet :
 *  // JavaDoc에 코드 예시 삽입
 *  System.out.println("Hello, JavaDoc Snippets!");
 * }
 */
public class JavadocSnippetExample {
    public static void main(String[] args) {
        System.out.println("Hello, Java 18!");
    }
}

Java 19 (2022년 출시)

Java 19는 새로운 기능을 실험적으로 도입했습니다.

Virtual Threads (미리보기): Java의 동시성 모델을 개선하여 더 많은 스레드를 효율적으로 처리할 수 있도록 지원.
Structured Concurrency (미리보기): 여러 스레드 작업을 구조화하여 처리하는 API.

Java 20 (2023년 출시)

Java 20에서는 주로 이전에 도입된 기능을 확장하거나 실험적 기능들을 개선했습니다.

Virtual Threads (확장된 미리보기): 가벼운 스레드로 성능 최적화 및 개선.
Pattern Matching for switch (확장된 미리보기): switch 문에서 더 강력한 패턴 매칭 가능.

Java 21 (2023년 출시, LTS)

Java 21은 새로운 LTS 버전으로 장기적으로 지원되며, 많은 주요 기능을 정식으로 도입했습니다.

Virtual Threads (정식): 동시성 프로그래밍을 쉽게 할 수 있도록 돕는 가벼운 스레드 기능이 정식으로 추가됨.
Pattern Matching for switch (정식): switch 문에서 더 복잡한 패턴 매칭이 가능하게 되었음.
Record Patterns (정식): record와 함께 사용할 수 있는 패턴 매칭 지원.
Sequenced Collections: 순서를 보장하는 새로운 컬렉션 인터페이스 도입.

1. Virtual Threads (가상 스레드) - 정식 기능

public class VirtualThreadExample {
    public static void main(String[] args) throws InterruptedException {
        // 가상 스레드를 사용하는 ExecutorService 생성
        try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 0; i < 10; i++) {
                executor.submit(() -> {
                    System.out.println("Running on virtual thread: " + Thread.currentThread());
                });
            }
        }
    }
}

2. Pattern Matching for switch - 정식 기능

public class PatternMatchingSwitchExample {
    public static void main(String[] args) {
        Object obj = "Java 21";

        // 패턴 매칭을 사용하는 switch 표현식
        String result = switch (obj) {
            case Integer i -> "Integer: " + i;
            case String s -> "String: " + s.toUpperCase();
            case null -> "Null value";
            default -> "Unknown type";
        };

        System.out.println(result);  // 출력: String: JAVA 21
    }
}

3. Sequenced Collections

public class SequencedCollectionExample {
    public static void main(String[] args) {
        SequencedCollection<String> sequencedList = new LinkedList<>();
        sequencedList.addFirst("First");
        sequencedList.addLast("Last");

        System.out.println("First element: " + sequencedList.getFirst());
        System.out.println("Last element: " + sequencedList.getLast());
    }
}

4. String Templates - 프리뷰 기능

public class StringTemplateExample {
    public static void main(String[] args) {
        int age = 25;
        String name = "Alice";

        // 문자열 템플릿을 사용한 간결한 표현
        String result = STR."Hello, \{name}! You are \{age} years old.";
        System.out.println(result);  // 출력: Hello, Alice! You are 25 years old.
    }
}

5. Unnamed Classes and Instance Main Methods - 프리뷰 기능

public class MainExample {
    void main() {
        System.out.println("Instance Main Method");
    }

    public static void main(String[] args) {
        new MainExample().main();  // 출력: Instance Main Method
    }
}

6. Foreign Function & Memory API - 정식 기능

public class ForeignFunctionMemoryExample {
    public static void main(String[] args) {
        try (MemorySegment segment = MemorySegment.allocateNative(JAVA_INT)) {
            segment.set(JAVA_INT, 0, 42);
            int value = segment.get(JAVA_INT, 0);
            System.out.println("Value from native memory: " + value);  // 출력: 42
        }
    }
}

결론

Java 8: 람다, 스트림 API, 새로운 날짜 및 시간 API 등.
Java 9~10: 모듈 시스템과 var 타입 추론 등.
Java 11: LTS 버전으로 HTTP 클라이언트 API와 새로운 String 메서드.
Java 12~15: Switch 표현식, 텍스트 블록, 패턴 매칭 등의 실험적 기능.
Java 16~17: Record와 Sealed 클래스 정식 도입, 패턴 매칭 기능 강화.
Java 18~21: Virtual Threads, Pattern Matching for switch 등의 동시성 및 패턴 매칭 기능 개선.

각 버전마다 Java 언어와 런타임에 중요한 개선 사항들이 도입되었으며, 특히 Java 8, 11, 17, 21은 LTS 버전으로 장기적인 지원을 제공합니다.

JAVA (JDK, JRE, JVM 차이점)

주뇬 — Fri, 18 Oct 2024 13:36:57 +0900

✅ JAVA (JVM, JRE, JDK과 버전 명명법)

1. JVM (Java Virtual Machine)

정의: JVM은 Java Virtual Machine으로, Java 애플리케이션을 실행하는 가상 머신입니다. Java는 플랫폼 독립적인 언어로 설계되었기 때문에, JVM은 운영체제에 따라 Java 애플리케이션을 실행할 수 있도록 도와줍니다.
역할: 컴파일된 바이트코드(.class 파일)를 읽고, 이를 각 운영체제에 맞게 실행하는 역할을 합니다.
특징:
- 운영체제와 상관없이 Java 애플리케이션이 실행될 수 있게 함.
- 메모리 관리 및 가비지 컬렉션(Garbage Collection)을 수행.
- 바이트코드를 해석하여 네이티브 코드로 변환.
플랫폼 독립성: 한 번 작성된 Java 코드가 여러 운영체제에서 실행될 수 있는 "Write Once, Run Anywhere" 개념을 지원합니다.

2. JRE (Java Runtime Environment)

정의: JRE는 Java Runtime Environment로, Java 애플리케이션을 실행하기 위해 필요한 환경입니다. JVM과 함께 Java의 핵심 라이브러리 및 리소스를 포함합니다.
역할: JVM을 포함하고, Java 애플리케이션이 실행되기 위해 필요한 라이브러리, 클래스 파일 등을 제공합니다. JRE는 Java 애플리케이션을 실행하는 데 필요한 모든 것들을 갖추고 있습니다.
구성 요소:
- JVM: 애플리케이션을 실행하는 가상 머신.
- 라이브러리: Java 애플리케이션이 필요로 하는 표준 클래스 라이브러리(rt.jar).
- 기타 리소스: 클래스 파일 및 구성 파일.
사용 시기: JRE는 Java 애플리케이션을 실행만 하고자 할 때 사용됩니다. 개발 도구는 포함되어 있지 않으므로, 코드를 작성하거나 컴파일할 수는 없습니다.

3. JDK (Java Development Kit)

정의: JDK는 Java Development Kit으로, Java 애플리케이션을 개발하고 실행하는 데 필요한 도구 모음입니다. JRE와 개발 도구(컴파일러 등)가 포함되어 있습니다.
역할: JDK는 Java 애플리케이션을 개발하고, 컴파일하고, 디버깅하고, 패키징하는 데 필요한 도구들을 제공합니다. JDK에는 JRE와 더불어 개발에 필요한 도구들이 추가되어 있습니다.
구성 요소:
- JRE: Java 애플리케이션 실행을 위한 런타임 환경.
- Javac: Java 컴파일러로, .java 파일을 .class 파일(바이트코드)로 변환.
- 디버거 및 기타 도구: Java 애플리케이션을 개발하고 디버깅하는 데 필요한 도구들(javap, jdb 등).
사용 시기: JDK는 Java 애플리케이션을 개발할 때 필요합니다. 개발 도구와 실행 환경(JRE)을 모두 포함하고 있기 때문에, 애플리케이션을 개발하고 실행할 수 있습니다.

JAVA버전 JAVA1.8 or JAVA8 로 부르게 된 이유

Java8 이전에는 다음과 같은 형태로 표시 하였습니다.
- Java SE 5 → 1.5.0
- Java SE 6 → 1.6.0
- Java SE 7 → 1.7.0
- Java SE 8 → 1.8.0
JAVA SE 9 이후 부터는 앞의 1을 없애고, 주 버전 번호만 사용하는 방식으로 변했습니다.
- Java 9 → 9
- Java 10 → 10
- Java 11 → 11
- Java 17 → 17
상세 버전 정보를 말할때는 11.0.8 이렇게 표현하기 도 합니다.

소프트웨어 아키텍처란?

주뇬 — Mon, 14 Oct 2024 01:23:43 +0900

✅ 소프트웨어 아키텍처란?

소프트웨어 시스템을 구성하는 컴포넌트들, 그들의 관계, 상호작용 방식, 그리고 이를 지배하는 원칙들을 정의한 것.

무엇이 어디에 위치하고

무엇이 무엇과 연결되어 있으며

어떻게 통신하고 협력하며

변화에 어떻게 대응할 수 있는지 를 설계

✅ 왜 중요한가?

확장성: 트래픽이 늘어도 잘 버틸 수 있도록
유지보수성: 수정/추가가 쉬워야 하고
재사용성: 중복 없는 코드 구조를 만들기 위해
배포 유연성: 부분 배포, 롤백 등이 가능하도록
이해도: 팀원 누구든 시스템을 쉽게 이해하고 동작시킬 수 있어야 함

✅ 핵심 구성 요소

요소	설명
컴포넌트(Component)	독립적인 기능 단위 (ex. 사용자 서비스, 결제 서비스 등)
모듈(Module)	컴포넌트를 구성하는 코드 묶음 (ex. 도메인, 애플리케이션 등)
인터페이스(Interface)	컴포넌트 간 통신 방법 (ex. REST API, 메시지 큐)
데이터 흐름(Data Flow)	데이터가 시스템 안에서 어떻게 이동하고 처리되는지
구성(Configuration)	외부 시스템, 설정값, 배포 전략 등

✅ 대표적인 아키텍처 스타일

아키텍처 스타일	특징
Monolithic	하나의 큰 애플리케이션으로 구성, 배포가 쉽지만 확장성이 낮음
Layered (계층형)	프레젠테이션, 서비스, 도메인, 인프라 등으로 나누는 전통적 구조
Hexagonal (Ports & Adapters)	의존성 방향을 도메인 중심으로 역전시켜 유연성과 테스트 용이성 확보
Microservices (MSA)	작은 서비스 단위로 분리, 독립 배포 가능, 복잡도와 운영 비용 증가
Event-driven	이벤트 중심, 비동기 메시지 기반으로 느슨한 결합 구현

✅ 좋은 소프트웨어 아키텍처의 특징

SOLID 원칙을 잘 반영
의존성 방향이 명확
도메인과 기술을 분리
테스트 가능성과 확장성
비즈니스 요구 변화에 유연하게 대응

리눅스 htop 시스템 모니터링

주뇬 — Fri, 11 Oct 2024 15:33:40 +0900

✅ 리눅스 htop 시스템 모니터링

top 으로 리소스 사용량 모니터링 체크를 할수도있지만 자세히 보고 싶을경우 htop을 이용하자 시각적으로도 좋다

설치

# ubuntu
sudo apt-get install htop
# macbook
brew install htop

특징

htop 화면을 살펴보면 왼쪽 상단에 CPU, swap메모리,메모리 사용률이 표현되어 있으며, 하단에는 모니터링되고 있는 프로세스가 보이며 1초에 한 번씩 갱신됩니다
선택된 프로세스를 죽이거나, 우선순위를 변경할 수 있습니다.특정 프로세스 이름으로 검색, 필터링하여 현황을 볼 수 있습니다.
pstree와 top을 함께 보는 기능이 있습니다.
cpu의 코어 갯수를 확인해서 각 프로세스의 정보를 top보다 더 디테일하게 모니터링이 가능합니다.

시스템 전체 CPU 사용률

최상단 왼쪽에 CPU/코어별 사용률이 보이는데 게이지바의 색깔이 의미하는 바는 다음과 같습니다.

파랑: 우선 순위가 낮은 프로세스(nice > 0)
초록: 일반(사용자) 프로세스
빨강: 커널 프로세스
노랑: IRQ time
자주: Soft IRQ time
회색: IO Wait time

시스템 전체 메모리 사용률

CPU 사용률 아래에 메모리와 스왑 사용량이 보이는데 게이지바의 색깔이 의미하는 바는 다음과 같습니다.

초록: 사용 중인 메모리 페이지
파랑: 버퍼 페이지
노랑: 캐쉬 페이지

평균 부하율(Load average)

일정 시간 동안의 평균 부하율로 top이나 uptime과 마찬가지로 1, 5, 15분 간격으로 평균 수치가 나옵니다. 싱글 코어 CPU일 때 1.0이면 사용률이 100% 임을 의미합니다. 쿼드 코어라면 4.0이 100%입니다. 다만 이때 1.0을 넘을 수도 있는데 이는 CPU를 할당받기 위해 프로세스들이 기다려야 함을 뜻합니다.

프로세스 정보

PID: 프로세스의 프로세스 ID 번호
USER: 프로세스의 소유자
PR: 프로세스의 우선순위
NI: 우선순위에 영향을 주는 프로세스의 nice 값
VIRT: 프로세스가 사용 중인 가상 메모리 양
RES: 프로세스가 사용 중인 물리 RAM의 양(단위는 킬로바이트)
SHR: 프로세스가 사용 중인 공유 메모리 양
S: 프로세스의 현재 상태(zombied, sleeping, running, uninterruptedly sleeping, traced)
%CPU: 프로세스가 프로세서를 사용한 시간의 백분율
%MEM : 프로세스가 사용 중인 물리 RAM의 백분율
TIME+: 프로세스가 프로세서를 사용한 시간
COMMAND: 프로세스 시작에 사용한 명령어

단축키 설명

F1 : htop의 도움말을 볼 수 있으며, 단축키의 기능을 알 수 있습니다.
F2 : 설정, 설정에서는 상단에 보여줄 CPU. 메모리에 대한 정보를 추가/제거 할 수 있으며, 디스플레이 옵션 설정도 가능합니다.
F3 : “/” 눌러 해당 프로세스를 검색할 수 있습니다.
F4 : 원하는 프로세스만 모니터링
F5 : 프로세스의 부모 자식 관계를 트리 형태로 보여주는 기능
F6 : 프로세스 정렬
F7, F8: 프로세스의 우선 순위을 바꾸는 단축키.
F9 : htop에서 해 당 프로세스를 선택 후 F9 또는 “k”키를 입력하여 해당 프로세스를 종료
F10 : htop을 종료 합니다.
l : 그 프로세스가 열고 있는 파일들을 볼 수 있습니다.
u : 특정 사용자의 프로세스만 보기
k: 현재 또는 선택된 프로세스를 종료
M 메모리 사용량으로 프로세스를 정렬
P: CPU 사용량으로 프로세스를 정렬

리눅스 netstat 열린 포트 확인(LISTEN)

주뇬 — Fri, 11 Oct 2024 15:17:18 +0900

✅ 리눅스 netstat 열린 포트 확인(LISTEN)

서버의 열린 포트를 확인 할때 자주 사용하는 명령어

옵션
-n : 호스트명, 포트명을 lookup하지 않고 그대로 IP, Port번호로 보여준다.
-a : 모든 네트웍 상태를 보여준다.
-l : LINTEN 상태인 서비스 포트를 보여준다.
-t : TCP 프로토콜만 보여준다.
-u : UDP 프로토콜만 보여준다.
-p : 해당 포트를 사용하는 프로그램과 프로세스ID(PID)를 보여준다.
-r : 라우팅 테이블 출력
-s : 프로토콜별(IP, ICMP, TCP, UDP 등)로 통계를 보여준다
-c : 1초 단위로 결과값을 연속적으로 보여준다.

netstat -antp

vim 단축키

주뇬 — Tue, 8 Oct 2024 14:28:50 +0900

✅ vim 단축키

카테고리	단축키	설명
삽입모드	i	현재 커서 앞에 삽입
	I	현재 커서 행 시작에 삽입
	a	현재 커서 뒤에 삽입
	A	현재 커서 행 끝에 삽입
	o	현재 커서 행 아래에 새 행을 삽입
	O	현재 커서 행 위에 새 행을 삽입
	Ctrl + h	이전 문자 제거
	Ctrl + w	이전 단어 제거
	Ctrl + j	한 줄 바꿈
	Ctrl + t	한 탭 들여쓰기
	Ctrl + d	한 탭 내어쓰기
	Ctrl + n	다음 단어 탐색 (자동완성)
	Ctrl + p	이전 단어 탐색 (자동완성)
	Ctrl + rx	레지스터 x의 내용 삽입
	Esc	삽입모드 종료
편집모드	r	한 글자 바꾸기
	J	현재 행과 다음 행 연결
	gJ	현재 행과 다음 행 연결 (공백무시)
	gwip	단락 리플로우
	g~	커서 이동으로 대·소문자 전환
	gu	커서 이동으로 소문자 전환
	gU	커서 이동으로 대문자 전환
	cc	한 행 전체 새로 쓰기
	C	한 행 끝까지 새로 쓰기
	c$	한 행 끝까지 새로 쓰기
	ciw	한 단어 전체 새로 쓰기
	cw	한 단어 끝까지 새로 쓰기
	s	한 문자 새로 쓰기
	S	한 행 전체 새로 쓰기 (cc와 동일)
	xp	잘라내고 붙여넣기
	u	실행취소
	U	최근 수정한 줄 복원(실행취소)
	Ctrl + r	다시실행
	.	최근 명령어 반복
선택모드(비주얼모드)	v	비주얼 모드
	V	비주얼 라인
	o	선택 영역 반대쪽 끝으로 점프
	Ctrl + v	비주얼 블록
	O	블록의 반대쪽 모서리로 이동
	aw	단어 선택
	ab	소괄호() 구간 선택
	aB	중괄호{} 구간 선택
	at	태그<> 구간 선택
	ib	소괄호() 내부 선택
	iB	중괄호{} 내부 선택
	it	태그<> 내부 선택
	Esc	선택 모드 종료
레지스터	>	선택 행 들여쓰기
	<	선택 행 내어쓰기
	y	선택 구간 복사
	d	선택 구간 삭제
	~	대소문자 반전
	u	선택 구간 소문자 전환
	U	선택 구간 대문자 전환
	:reg[isters]	레지스터 내용 확인
	"xy	레지스터 x 복사
	"xp	레지스터 x 붙여넣기
	"+y	클립보드 복사
	"+p	클립보드 붙여넣기
	0	최근 복사 레지스터
	"	최근 사용 레지스터
	%	현재 파일명
	#	대체 파일명
	*	클립보드 (X11 primary)
	+	클립보드 (X11 clipboard)
	/	최근 검색 패턴
	:	최근 Vim 명령줄
	.	최근 삽입 텍스트
	-	최근 제거 문자
	=	표현식 레지스터
	_	블랙홀 레지스터
마킹	:marks	마킹 항목 표시
	ma	현재 위치를 a로 마킹
	`a	마크 a로 점프
	y`a	마크 a까지 복사
	`0	종료 전 커서위치로 점프
	`"	최근 편집한 커서 위치로 점프
	`.	최근 변경한 커서 위치로 점프
	``	최근 점프 전 위치로 점프
	:ju[mps]	점프목록
	Ctrl + i	이전 점프목록 위치로 점프
	Ctrl + o	다음 점프목록 위치로 점프
	:changes	변경목록
	g,	이전 변경목록 위치로 점프
	g;	다음 변경목록 위치로 점프
	Ctrl + ]	커서가 가리키는 태그로 점프
매크로	qa	매크로 a 기록 시작
	q	매크로 기록 중지
	@a	매크로 a 실행
	@@	최근 매크로 재실행
잘라내기 붙여넣기	yy	한 행 복사하기
	2yy	2줄 복사하기
	yw	다음 단어까지 복사하기
	y$	한 행 끝까지 복사하기
	p	커서 뒤에 붙여넣기
	P	커서 앞에 붙여넣기
	dd	한 행 잘라내기
	2dd	2줄 잘라내기
	dw	다음 단어까지 잘라내기
	D	한 행 끝까지 잘라내기
	d$	한 행 끝까지 잘라내기
	x	한 문자 잘라내기
문단모양	>>	한 탭 들여쓰기
	<<	한 탭 내어쓰기
	>%	중·소괄호 구간 들여쓰기
	>ib	소괄호 내부 들여쓰기
	>at	태그 구간 들여쓰기
	3==	3줄 자동정렬
	=%	중·소괄호 구간 자동정렬
	#NAME?	중괄호 내부 자동정렬
	gg=G	전체 버퍼 자동정렬
	]p	붙여쓰고 현재 행 들여쓰기
검색 바꾸기	/pattern	패턴 검색 (순방향)
	?pattern	패턴 검색 (역방향)
	\vpattern	특수 매직 패턴
	n	다음 검색항목으로 점프
	N	이전 검색항목으로 점프
	:%s/old/new/g	모든 old를 new로 바꾸기
	:%s/old/new/gc	모든 old를 new로 확인하며 바꾸기
	:noh[lsearch]	검색 하이라이트 제거

세로모드 수정하기

Ctrl + v를 눌러 column mode에 진입
방향키를 이용하여 행 선택
Shift + i 입력 수정 모드 진입
수정하기 - 첫 줄에서만 수정하는 것 처럼 보임
ESC 2번 / 선택한 세로줄 수정 완료

python chromedriver Exec format error

주뇬 — Thu, 1 Aug 2024 09:36:40 +0900