반응형

백준 감소하는 수(줄어드는 수)

https://www.acmicpc.net/problem/1174

https://www.acmicpc.net/problem/1038

접근 방식

최초엔 n까지 범위의 수를 생각했는데, 잘못 생각한 것이였고, 앞자리부터 점점 감소하는 수의 모든 경우의 수 중 몇번째인지 n으로 입력받아 찾는 문제


구현 방법

  • 감소하는 수에 대해 모든 조합을 찾은 후 정렬해 수행
  • 이 때 최대 수의 범위까지 1씩 더해가며 찾는 것이 아닌, 값이 들어갈 수 있는 범위에 대해서만 찾기

  • 9876543210 까지가 최대 수
  • 재귀에서 자릿수(depth)를 받아서 depth 범위만큼 foreach돈다.
  • 기본적으로 for문 돌 때 자기보다 낮은 수에 대해서만 수행
  • 재귀 안에서 count가 같으면 return - count는 static으로 갖고있기에 종료가능
  • for문이 다 돌면 재귀호출 시행

풀이

package Baekjoon.gold;

import java.io.*;
import java.util.*;
import java.util.stream.Collectors;

public class p1174 {

    static Stack<Long> st = new Stack<>();
    static ArrayList<Long> al = new ArrayList<>();

    static int count = 0;
    static int n;
    static StringBuilder sb = new StringBuilder();

    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        n = Integer.parseInt(br.readLine());

        /*
         0, 1, 2, 3, 4, 5, 6, 7, 8, 9
         10 | 20, 21 | 30, 31, 32 | 40, 41, 42, 43 | 50, 51, 52, 53, 54 |
         60, 61, 62, 63, 64, 65 | 70, 71, 72, 73, 74, 75, 76 |
         80, 81, 82, 83, 84, 85, 86, 87 | 90, 91, 92, 93, 94, 95, 96, 97, 98 |
         210 |320, 321, 310 | 410, 420, 421, 430, 431, 432
         */

        //9 -> 8 7 6 5 4 3 2 1 0
        //8 -> 7 6 5 4 3 2 1 0
        //7 -> 6 5 4 3 2 1 0
        //6 -> 5 4 3 2 1 0
        //5 -> 4 3 2 1 0
        //4 -> 3 2 1 0
        //3 -> 2 1 0
        //2 -> 1 0
        //1 -> 0

        // 10 20 21 30 31 32
        //9876543210 까지가 최대 수
        //재귀에서 자릿수(depth)를 받아서 depth 범위만큼 foreach돈다.
        //기본적으로 for문 돌 때 자기보다 낮은 수에 대해서만 수행
        //재귀 안에서 count가 같으면 return - count는 static으로 갖고있기에 종료가능
        //for문이 다 돌면 재귀호출 시행

        if(n <= 10){
            System.out.println(n-1);
            return;
        }
        recur(10);
        List<Long> list = al.stream().sorted().collect(Collectors.toList());

        long result = -1;
        if(list.size() >= n){
            result = list.get(n-1);
        }

        System.out.println(result);
    }

    private static void recur(long nowNum){
        for(long i = 0; i < nowNum; i++){
            count++;
            st.push(i);
            st.forEach(sb::append);
            al.add(Long.valueOf(sb.toString()));
            sb.setLength(0);
            recur(i);
            st.pop();
        }
    }
}

후기

최초에 문제를 잘못 읽었고, 이후엔 전체 탐색을 효율적으로 하기위한 노력(가지치기)을 하는 데 시간을 많이 썼음

반응형
반응형

AtomicInteger.class의 메서드를 탐방하다 발견하게 된 native 키워드 탐방

@IntrinsicCandidate
public final native boolean compareAndSetInt(Object o, long offset, int expected, int x);

native 키워드는 Java에서 네이티브 코드를 사용해 자바 코드로는 직접 수행하기 어려운 작업을 해결하기 위해 사용됨. Java는 기본적으로 플랫폼 독립성을 목표로 설계된 언어지만, 외부에 작업 수행을 맡기기도 한다.

native 키워드의 역할 및 특징

운영체제, 하드웨어 종속작업 처리

Java는 플랫폼 독립성을 가진 언어이지만, 운영 체제나 하드웨어에 종속적인 작업을 처리해야할 때 C/C++로 작성된 네이티브 코드를 호출해 운영 체제의 API나 하드웨어를 직접 제어해야 한다.

  • 예:
    • 파일 시스템 접근 (FileInputStream, FileOutputStream)
    • 네트워크 소켓 관리
    • 그래픽 처리를 위한 GUI 라이브러리 (AWT/Swing)
    • 시스템 시간 가져오기 (System.currentTimeMillis())
    • concurrent(동시성) 관련 코드

성능 최적화

Java는 일반적으로 JVM 위에서 동작하므로 C/C++로 작성된 네이티브 코드에 비해 약간의 오버헤드가 존재. 특히, 자바의 네이티브 메서드는 속도가 중요한 저수준 작업에서 성능을 극대화하기 위해 사용.

  • 예:
    • AtomicInteger와 같은 CAS (Compare-And-Swap) 연산은 C/C++로 구현된 네이티브 코드를 호출하여 고성능을 보장.
    • arraycopy()는 배열 복사를 네이티브 코드로 처리하여 높은 속도를 보장.

하드웨어 제어

Java는 추상화된 언어로, 하드웨어를 직접 제어하는 데 적합하지 않다. 하지만 네이티브 코드를 사용하면 Java 프로그램이 특정 하드웨어 장치를 제어하거나 센서 데이터를 읽을 수 있다.

  • 예:
    • 임베디드 시스템에서 Java와 네이티브 코드를 조합해 사용.
    • 특정 하드웨어 기능 호출.

멀티스레딩 및 동기화

Java는 스레드 관리와 동기화 관련 기능을 제공하지만, JVM의 성능을 극대화하거나 플랫폼 종속적인 동기화 메커니즘을 사용하기 위해 네이티브 메서드가 필요할 수 있다.

  • 예:
    • Thread.sleep()와 같은 메서드는 네이티브 코드를 통해 구현되어 운영 체제의 스레드 관리 기능을 호출.
    • AtomicIntegercompareAndSet() 같은 원자적 연산은 하드웨어 명령을 활용한 네이티브 코드로 구현.
반응형
반응형

멀티스레드 문제 예시 - 은행 계좌 잔액 갱신 문제

class BankAccount {
    private int balance = 100;

    public void withdraw(int amount) {
        if (balance >= amount) { // 조건 검사
            balance -= amount;  // 잔액 갱신
        }
    }
}

의도된 동작

  1. 스레드 A가 50을 출금.
  2. 스레드 B가 50을 출금.
  3. 결과적으로 잔액은 0이 되어야 함.

문제 상황

  • 스레드 A와 스레드 B가 동시에 withdraw(50) 메서드를 호출하면, 잔액 조건 검사와 갱신 작업이 중첩될 수 있음.
  • 이로 인해 두 스레드가 잔액 조건을 동시에 검사한 후, 동시에 출금을 진행.
  • 결과적으로, 잔액이 50으로 잘못 계산됨.

 

**정상적인 단일 스레드 실행**

-------
스레드 A 실행:
[검사] 잔액: 100 >= 50  -> True
[갱신] 잔액 -= 50       -> 잔액: 50

**멀티스레드에서의 충돌**
스레드 A 실행:                          스레드 B 실행:
[검사] 잔액: 100 >= 50  -> True        [검사] 잔액: 100 >= 50  -> True
[갱신] 잔액 -= 50       -> 잔액: 50    [갱신] 잔액 -= 50       -> 잔액: 50

결과: 두 스레드가 모두 출금을 완료했지만, 최종 잔액은 50으로 계산됨 (잘못된 결과).

멀티스레드 환경의 위험 요소

  1. Race Condition (경쟁 상태)
    • 여러 스레드가 동시에 동일한 자원에 접근하고 이를 수정할 때, 실행 순서에 따라 결과가 달라질 수 있음.
    • 예: 위의 은행 계좌 예제에서 스레드 간 동기화가 없을 경우 발생.
  2. Deadlock (교착 상태)
    • 두 스레드가 서로 자원을 기다리며 무한히 대기하는 상황.
    • 예: 스레드 A가 자원 1을 점유하고 자원 2를 기다리는 동안, 스레드 B는 자원 2를 점유하고 자원 1을 기다림.
  3. Data Corruption (데이터 손상)
    • 여러 스레드가 동일한 메모리 위치를 수정하면, 결과값이 예기치 않게 손상될 수 있음.
    • 예: 공유 데이터 구조의 상태가 불완전하거나 잘못된 상태로 유지됨.
  4. Thread Interleaving (스레드 중첩 실행)
    • 스레드가 실행 중에 문맥 교환(Context Switching)으로 인해 실행 흐름이 중첩됨.
    • 예: 스레드 A와 B가 교차 실행되며 연산이 중간 상태에서 중단됨.

해결 방법

1. 동기화 사용

  • synchronized 키워드: 공유 자원에 한 번에 하나의 스레드만 접근하도록 보장.
  • ReentrantLock: 더 세밀한 락 제어 가능.
public synchronized void withdraw(int amount) {
    if (balance >= amount) {
        balance -= amount;
    }
}

2. 원자적 연산 사용

  • Java의 AtomicInteger 또는 AtomicLong과 같은 클래스 사용.
  • 내부적으로 CAS(Compare-And-Swap)를 활용하여 동기화 문제를 해결.
import java.util.concurrent.atomic.AtomicInteger;

class BankAccount {
    private AtomicInteger balance = new AtomicInteger(100);

    public void withdraw(int amount) {
        balance.addAndGet(-amount); // 원자적 연산
    }
}

3. 동시성 제어 도구

  • CountDownLatch, Semaphore, CyclicBarrier 등 사용.
  • 특정 조건에서 스레드의 실행을 제어하여 동기화 문제를 방지.
반응형
반응형

AtomicInteger.class

Java에서 사용하는 클래스로 멀티 스레드 환경에서 안전하게 사용되기 위한 원자성을 보장받는 자료형이다

클래스의 주요 기능 및 특징

  • 원자적 연산
    • 다른 스레드가 해당 연산의 중간 상태를 볼 수 없음
  • 스레드 안전
    • 여러 스레드에서 동시에 접근하더라도 데이터 경합 없이 안전하게 값을 읽고 쓸 수 있음
  • 락 없이 동작
    • 기존의 동기화 방식(synchronized 키워드)은 락을 사용하지만, 아토믹 연산은 CPU가 제공하는 하드웨어 수준의 락-프리(Lock-Free) 매커니즘을 사용
  • CAS 알고리즘
    내부적으로 CAS(Compare-And-Swap) 알고리즘을 사용하여 값을 업데이트
    • 특정 메모리 위치 값이 예상값과 같은지 확인한 후, 같다면 새 값으로 교체
    • 이 과정에서 충돌을 감지

주요 메서드

  • get()
  • set(int newValue)
  • getAndIncrement()
    • 현재 값 반환 후 1 증가
  • incrementAndGet()
    • 값을 1 증가시키고 증가된 값 반환
  • compareAndSet(int expect, int update)
    • 현재 값이 expect와 같으면 update 값으로 변경 (CAS 연산)

사용 고려 시점

  • 동시성 프로그래밍에서 데이터를 안전하게 업데이트해야 하는 경우
    • 멀티 스레드 환경에서 카운터 증가
    • 통계 집계
  • 락 기반 동기화보다 가벼운 대안
  • 성능이 중요한 환경에서 데이터 무결성을 유지해야 할 때

❓CAS (Compare-And-Swap)

CAS는 값의 업데이트가 특정 조건에서만 이루어지도록 보장하는 하드웨어 지원 원자적 연산
따라서 자바에만 있는 것이 아니라, C 계열의 언어에서도 std::atmoic 클래스와 같이 사용되고 있음

CAS 작동 방식

  • 특정 메모리 위치에 대해, 세 값을 비교 및 업데이트
    • 현재 값 (current): 현재 메모리에 저장된 값
    • 기대 값 (expected): 우리가 예상하는 값
    • 새 값 (new): 우리가 저장하려는 값
  • CAS 연산의 과정
    • 메모리의 현재 값이 기대 값(expected)과 동일하면, 새 값으로 업데이트
    • 메모리의 현재 값이 기대 값과 다르면 실패를 반환

CAS 장점

  • 스케일링 가능성: 여러 스레드가 동시에 접근해도 성능 저하가 적다.
  • 스레드가 블로킹되지 않으므로 데드락 위험성이 없다

CAS 단점

  • Busy-waiting:
    • 실패할 경우 재시도하는 루프를 사용하므로 CPU 자원을 소비할 수 있다.
    • 특히 충돌이 빈번하면 성능 저하가 발생할 수 있다.
  • ABA 문제:
    • 메모리 값이 A -> B -> A로 변경된 경우, CAS는 값이 바뀌지 않았다고 판단할 수 있다.
    • 이 문제는 태그(tag) 또는 버전 관리를 통해 해결

코드 예시 - 과정만 참고

public final int incrementAndGet() {
    for (;;) {
        int current = get(); // 현재 값 읽기
        int next = current + 1; // 새로운 값 계산
        if (compareAndSet(current, next)) // CAS 연산
            return next; // 성공 시 반환
    }
}

CPU의 원자적 명령어

CPU는 CAS 연산을 지원하기 위해 특정 명령어(기계어)를 제공

  • x86 아키텍처 - CMPXCHG(Compare and Exchange)
  • ARM 아키텍처 - LDREX/STREX

메모리 값을 읽고 수정하는 작업을 한 번에 처리하므로, synchronized 키워드 없이 안전하게 업데이트


반응형

'호기심 천국 > Java' 카테고리의 다른 글

멀티스레드 문제 상황 예시 1  (1) 2025.01.20
StringBuilder vs String 문자열합치기  (0) 2023.09.19
반응형
  • 컨트롤러 테스트에서 사용한 기법

    • Mocking을 통해 Controller 단위 테스트 시행
    • 통합테스트가 아닌 단위 테스트를 진행할 때는 어노테이션에 주의해야합니다.
    • 이번 테스트에 사용된 UserControllerTest.java 파일에서 사용된 WebMvcTest를 명시해 사용하면, 컨트롤러 레이어의 단위테스트 형태를 갖출 수 있습니다
  • Mocking 기법 예시

    • Mocking을 통해 Controller 레이어의 단위테스트가 목적
    • 필요없는 내부동작을 임의로 동작한 것으로 치고 반환
    • Controller에서 필요없는 로직인 UserService안의 로직을 Mocking하여, Controller 레이어에서 사용되는 Request, Response, Valid 등을 테스트할 수 있음

@Slf4j
@WebMvcTest(UserController.class) // WebMvcTest는 컨트롤러 레이어만 테스트하기 위해 스프링의 WebMvc 관련 빈만 로드
@MockBean(JpaMetamodelMappingContext.class) // jpa동작하지않도록
@AutoConfigureMockMvc(addFilters = false) // 시큐리티 필터 제외
@ActiveProfiles("test")
class UserControllerTest {
    ...... 중략
    @Autowired
    private MockMvc mockMvc; //실제 서블릿 컨테이너 없이도 HTTP 요청과 응답을 테스트하기 위해 사용

    @Autowired
    private ObjectMapper objectMapper; // Response 매핑을 위한 객체

    @MockBean
    private UserService userService; // @MockBean을 활용하여 UserService를 Mocking


    private final User mockUser = User.builder()
                .id(UUID.randomUUID())
                .email("mockUser@naver.com")
                .nickname("mockUser")
                .password("abcd1234!")
                .isMarketing(true)
                .isAlarm(true)
                .state(State.ACTIVE)
                .build();

    @Test
    @DisplayName("회원가입 성공 response 테스트")
    void testCreateUserSuccess() throws Exception {
    CreateUserReq createUserReq = CreateUserReq.testCreate(); // 임의의 UserReq 생성

    /** CreateUserReq 타입에 맞는 객체가 UserService.create에 들어가면 mockUser를 반환하도록
    *    given 메서드는 BDD 스타일 테스트에서 사용되는 Mockito의 메서드
    *    mocking객체(UserService)안의 파라미터에 any(), eq() 두 메서드를 통해 값을 넣어줄 수 있고
    *    any(CreateUserReq.class) 선언 시 CreateUserReq 타입이 userService.create() 안에 들어가야 모킹된 mockUser가 반환된다
    **/
    given(userService.create(any(CreateUserReq.class))).willReturn(mockUser);

    /**
    *  "/users"의 위치로 헤더에 MediaType 타입에 APPLICATION_JSON, body에 createUserReq의 값을 담아 요청
    *  andExpect() 안에서 값이 어떻게 반환되는지 확인 현재 예시에서는 201반환하는지 확인
    **/
    mockMvc.perform(post("/users")
                .contentType(MediaType.APPLICATION_JSON)
                .content(objectMapper.writeValueAsString(createUserReq)))
            .andExpect(status().isCreated());
    ...... 중략
}

❗구현이슈

  • @AutoConfigureMockMvc(addFilters = false) // 시큐리티 필터 제외
  • 임의의 시큐리티 필터를 생성했을 시엔, 해당 어노테이션을 넣어줘야 한다.
  • 넣어주지 않을 시 실제 시큐리티 필터를 타서 문제 발생
반응형

'LTF(learn through failure) > Spring' 카테고리의 다른 글

SQL Injection  (0) 2023.09.30
스프링부트 Lombok @RequiredArgsConstructor잘 알고쓰자  (0) 2023.07.26
반응형

아키텍처 간략 정리

1. MVC (Model-View-Controller)

구성 요소

  • Model: 데이터와 비즈니스 로직을 관리합니다.
  • View: 사용자에게 정보를 시각적으로 표시합니다.
  • Controller: 사용자 요청을 처리하고 Model과 View를 연결합니다.

특징

  • 역할이 분리되어 코드의 가독성과 재사용성이 높습니다.
  • 사용자가 View와 상호작용하면 Controller가 이를 처리하고 Model을 업데이트한 후, View에 결과를 표시합니다.

활용

  • 웹 애플리케이션(스프링 MVC, Ruby on Rails 등)
  • 데스크톱 애플리케이션

2. MVVM (Model-View-ViewModel)

구성 요소

  • Model: 데이터와 비즈니스 로직.
  • View: UI 요소.
  • ViewModel: View와 Model 사이의 중간 계층으로, View의 상태를 관리하고, 데이터 바인딩을 지원합니다.

특징

  • 양방향 데이터 바인딩을 통해 View와 ViewModel의 동기화를 자동으로 처리합니다.
  • View는 데이터에 대한 의존성을 최소화합니다.

활용

  • WPF(Windows Presentation Foundation)
  • Angular, Vue.js, React + Redux/MobX와 같은 SPA(Single Page Application) 프레임워크

3. MVP (Model-View-Presenter)

구성 요소

  • Model: 데이터와 비즈니스 로직.
  • View: 사용자 인터페이스(UI).
  • Presenter: View의 로직을 담당하며 Model과 상호작용한 후 데이터를 View에 전달합니다.

특징

  • View는 단순히 UI를 표시하는 역할만 하고, 모든 로직은 Presenter에서 처리됩니다.
  • View와 Presenter는 1:1 관계를 갖습니다.

활용

  • 안드로이드 애플리케이션
  • 레거시 데스크톱 애플리케이션

4. Clean Architecture

구성 요소

  • Entities: 애플리케이션의 비즈니스 규칙을 캡슐화.
  • Use Cases: 애플리케이션의 특정 작업이나 기능을 정의.
  • Interface Adapters: 데이터와 UI의 변환 계층.
  • Frameworks & Drivers: 데이터베이스, UI, 외부 API 등.

특징

  • 의존성 규칙: 안쪽 계층은 바깥쪽 계층을 알지 못합니다.
  • 비즈니스 로직이 프레임워크와 독립적이어서 확장성과 유지보수가 용이합니다.

활용

  • 대규모 시스템
  • 멀티 플랫폼 애플리케이션

5. Layered Architecture (계층형 아키텍처)

구성 요소

  • Presentation Layer: 사용자 인터페이스.
  • Application Layer: 비즈니스 로직.
  • Data Layer: 데이터베이스 및 데이터 액세스.

특징

  • 계층 간 명확한 분리가 이루어집니다.
  • 단순하고 이해하기 쉬운 구조지만, 복잡한 시스템에서 성능 저하가 있을 수 있습니다.

활용

  • 전통적인 웹 애플리케이션(3-tier 아키텍처)
  • 엔터프라이즈 애플리케이션

6. Microservices Architecture

구성 요소

  • 애플리케이션을 독립적으로 배포 가능한 작은 서비스들로 나눕니다.
  • 각 서비스는 고유한 비즈니스 기능을 담당하며 API로 통신합니다.

특징

  • 독립적인 배포와 확장이 가능합니다.
  • 서비스 간 통신 오버헤드가 있고, 분산 시스템의 복잡성이 증가할 수 있습니다.

활용

  • 대규모 분산 시스템
  • 클라우드 네이티브 애플리케이션

7. Event-Driven Architecture

구성 요소

  • Event Producer: 이벤트를 생성하고 발행.
  • Event Consumer: 이벤트를 처리.
  • Event Broker: 이벤트를 전달하거나 중개.

특징

  • 비동기 통신을 기반으로 설계되어 높은 확장성을 제공합니다.
  • 복잡한 이벤트 흐름을 관리하기 위한 설계가 필요합니다.

활용

  • IoT 시스템
  • 실시간 애플리케이션(채팅, 트랜잭션 시스템)

8. Hexagonal Architecture (Ports and Adapters)

구성 요소

  • Core (Application Logic): 애플리케이션의 핵심 비즈니스 로직.
  • Ports: 외부와의 상호작용을 정의하는 인터페이스.
  • Adapters: 특정 구현을 제공하여 Core와 통신.

특징

  • 비즈니스 로직과 외부 시스템 간의 의존성을 최소화합니다.
  • 높은 테스트 가능성과 확장성을 제공합니다.

활용

  • 복잡한 도메인 로직이 있는 시스템
  • 시스템 간 통합이 필요한 애플리케이션

9. Serverless Architecture

구성 요소

  • 클라우드 기반 서비스와 함수(Function-as-a-Service)를 이용하여 애플리케이션을 실행.
  • 서버를 관리하지 않고도 클라우드 제공자가 모든 인프라를 처리.

특징

  • 확장성과 비용 효율성이 높습니다.
  • 서버 환경에 대한 제어가 제한적입니다.

활용

  • 이벤트 중심 애플리케이션
  • 간단한 API 백엔드

10. CQRS (Command Query Responsibility Segregation)

구성 요소

  • Command: 데이터 변경 작업(쓰기).
  • Query: 데이터 읽기 작업.

특징

  • 읽기와 쓰기를 분리하여 각 작업을 최적화합니다.
  • 복잡한 시스템에서 동시성과 확장성을 지원합니다.

활용

  • 이벤트 소싱 시스템
  • 고성능 읽기/쓰기 작업이 필요한 시스템

11. Pipe and Filter Architecture

구성 요소

  • Filters: 데이터를 처리하는 독립적인 컴포넌트.
  • Pipes: 필터 간 데이터를 전달.

특징

  • 데이터 흐름을 직관적으로 표현할 수 있습니다.
  • 처리 단계가 많아지면 성능 저하가 발생할 수 있습니다.

활용

  • 데이터 처리 파이프라인
  • 이미지 또는 오디오 프로세싱

12. Service-Oriented Architecture (SOA)

구성 요소

  • 독립적인 서비스들로 구성되며, 각 서비스는 특정 비즈니스 기능을 제공합니다.
  • 서비스는 표준 프로토콜(예: SOAP, REST)을 통해 통신합니다.

특징

  • 서비스 간 의존성이 낮아 확장성과 재사용성이 높습니다.
  • 복잡한 통합과 관리가 필요합니다.

활용

  • 엔터프라이즈 애플리케이션
  • 분산 시스템

CSR에서 자바 스프링 백엔드 아키텍처

  1. 계층형 아키텍처 사용 (Layered Architecture)
  2. RESTful API 서버로 프론트엔드와 데이터 통신
  3. JPA + Hibernate를 통한 데이터베이스 연동
  4. JWT를 통한 보안 및 인증 처리
  5. 마이크로서비스 및 API Gateway 적용 가능 (Spring Cloud Gateway)
  6. 비즈니스 로직, 예외 처리, 로깅, 모니터링 구성

➡️ CSR 환경에서는 프론트엔드가 주로 UI를 렌더링하고, 자바 스프링 백엔드는 데이터 제공, 비즈니스 로직 처리, 보안, 데이터베이스 연동을 주로 담당합니다.

아키텍처 패턴 선택 가이드

  1. 프로젝트 규모:
    • 작은 프로젝트: MVC, MVP
    • 대규모 프로젝트: Microservices, Clean Architecture
  2. 프론트엔드 및 백엔드 협업:
    • 단일 애플리케이션: MVVM, MVC
    • 분리된 환경: RESTful API 기반 MC
  3. 확장성 요구:
    • 높은 확장성: Microservices, Serverless
  4. 실시간 처리:
    • 실시간 데이터: Event-Driven, CQRS
반응형

'공부 > CS' 카테고리의 다른 글

언어별 연산 속도  (0) 2024.12.30
Context Switching(문맥 교환)  (0) 2024.09.19
해시 - 솔트치기  (0) 2024.08.25
CGI, FastCGI  (1) 2024.07.23
Web Server  (0) 2024.07.22
반응형

언어별 연산 속도

단순 연산 기준으로 나눠본 언어별 연산 속도 + 특징

Python

  • 인터프리터 언어
  • 연산 속도 : 1초에 1억
  • C 기반의 확장 라이브러리(ex:Numpy)를 활용해 연산이 빠를 수 있음
  • PyPy (JIT 컴파일러) 약 2~10배 빠름

JavaScript

  • 인터프리터 언어
  • 연산 속도 : 1초에 1억 ~ 5억
  • JIT 컴파일러를 통해 연산속도 보완

Java

  • 컴파일 언어
  • 연산 속도 : 1초에 5억 ~ 10억
  • Java는 JVM 위에서 실행되며, JIT컴파일링, 런타임 최적화 등이 있음, 기본 연산속도로 따졌을 때 Python보다 약 1020배, JavaScript보다 약 25배 빠름

C / C++

  • 컴파일 언어
  • 연산 속도 : 1초에 10억 ~ 50억
    • C와 C++은 컴파일 언어로, 코드가 기계어로 직접 변환되기에 가장 빠른 속도
  • 하드웨어와 매우 가까운 수준에서 작업 가능

C#

  • 연산 속도 : 1초에 5억 ~ 10억
  • C#은 Java와 유사한 속도, .NET의 JIT 컴파일러와 런타임 최적화가 되어있음

PHP

  • 인터프리터 언어
  • 1초에 약 1억 ~ 2억
  • C 기반으로 구현된 함수와 라이브러리를 호출

데이터 베이스 구현 언어

현재 주력 데이터베이스들인 MySQL, PostgreSQL, Oracle등 대부분의 데이터베이스는 C 또는 C++로 구현되어 있어 기계어에 가까운 최적화된 실행 성능을 갖고 있다.

정리

기본 연산속도가 가장 빠른 언어는 C, 그 외의 언어는 연산속도를 보장하기 위해 JIT 컴파일러, c언어 기반의 최적화된 라이브러리 등을 지원하여, 연산속도를 보완한다.

추가로 개발자들이 사용하는 것들(ex: MySQL, PHP, 파이썬 라이브러리)이 C 기반으로 만들어지는 이유를 추측하자면, 연산속도를 포함하여 low한 레벨에서 하드웨어에 가깝게 빠른 동작을 실행하려면 메모리, Disk I/O등 C언어 방식으로 직접 관리하는 것이 가장 최적화에 도움을 주는 방식이기 때문이 아닐까 생각된다.

반응형

'공부 > CS' 카테고리의 다른 글

아키텍처 간략 정리  (0) 2025.01.05
Context Switching(문맥 교환)  (0) 2024.09.19
해시 - 솔트치기  (0) 2024.08.25
CGI, FastCGI  (1) 2024.07.23
Web Server  (0) 2024.07.22
반응형

개요

보안을 위해 jwt 토큰저장방식을 Cookie - httpOnly,Secure 옵션을 넣어 사용하는 것으로 합의

토큰 발급 api 구현 후 프론트엔드 병민님의 요청으로 현재 쿠키의저장로직이 다른 페이지로 이동 시 사라지는 것을 확인

  • 현재 통신방식
    • 서버 - ec2서버도메인
    • 클라이언트 - localhost

현재 상황

서버

  • ec2서버 도메인
  • SSL 미적용으로 http 통신

클라이언트

  • localhost로 각자 pc에서 요청
  • SSL 미적용으로 http통신

문제점

현재 서버와 클라이언트의 도메인이 일치하지 않아 서버측에 쿠키 발급 요청시 도메인이 일치하지 않아 토큰 저장까지는 하지만, 해당 페이지를 벗어났을 때 쿠키가 제거됨. 브라우저에서 막는 것으로 추정

서버에서 발급해준 쿠키의 Domain 옵션이 localhost로 변경되지 않고, 서버측 도메인으로 강제 설정되어있는 상태


생각할 수 있는 해결 방안

  • 임의로 바디로 넘겨주기(제대로 도메인 적용해서 배포하기 전까지)
  • 프론트를 서버에 띄우기
  • 각자 프론트 컴퓨터에 백엔드 서버 돌아가게 해주기
  • EC2랑 로컬에 SSL 적용해서 HTTPS 통신 되게 한 후, Samesite=None Secure=true 설정

⇒ 도메인 적용 전까지 바디로 넘겨주며, 서버에 배포해 동일한 도메인 사용 후에 Cookie로 서버측에서 발급하는 형태로 진행 예정

 
반응형
반응형

타입은 자바스크립트에서 제공하는 (숫자, 문자열, 불리언, null, undefined, 심벌, 객체) 타입이 있다. 이 때 크게 원시 타입(primitive type)과 객체 타입(object type)으로 구분되는데, 다른 점이 크게 세가지 있다.

  • 원시 타입의 값은 변경 불가능한 값이다. 이에 비해 객체 타입의 값, 즉 객체는 변경 가능한 값이다.
  • 원시 값을 변수에 할당하면 변수(확보된 메모리 공간)에는 실제 값이 저장된다. 이에 비해 객체를 변수에 할당하면 변수(확보된 메모리 공간)에는 참조 값이 저장된다.
  • 원시 값을 갖는 변수를 다른 변수에 할당하면 원본의 원시 값이 복사되어 전달된다. 이를 값에 의한 전달(call by value) 이라 한다. 이에 비해 객체를 가리키는 변수를 다른 변수에 할당하면 원본의 참조 값이 복사되어 전달된다. 이를 참조에 의한 전달(call by reference)이라 한다.

원시 값

변경 불가능한 값

원시 타입의 값은 변경 불가능하기에, 한번 생성된 원시 값은 읽기 전용 값으로써 변경할 수 없다.

변수는 하나의 값을 저장하기 위해 확보한 메모리 공간 자체이고, 값은 변수에 저장된 데이터로서 표현식이 평가되어 생성된 결과를 말한다. 변경 불가능하다는 것은 변수가 아니라 값에 대한 진술이다.

즉 “원시 값은 변경 불가능하다”는 말은 원시 값 자체를 변경할 수 없는 것이지 변수 값을 변경할 수 없다는 것이 아니다. 변수는 언제든지 재할당을 통해 변수 값을 변경할 수 있다.

//상수 o에 값 할당을 다시 못할 뿐, o에 최초할당 된 객체인 o의 프로퍼티는 변경할 수 있다.
const o = {};

o.a = 1;
console.log(o); // {a: 1}

변수에 값 할당이 여러번 이루어질 때 메모리는 말 그대로 재할당이기 때문에 메모리 공간에 특정 값을 등록 후 해당 위치로 변수가 바라보는 주소값을 변경하는 것이다.

let a = 1;
a = 3;

//값이 변경되는 것이 아닌, 값을 재할당

문자열과 불변성

자바스크립트의 문자열은 원시타입으로써 변경 불가능하지만 위와 동일하게 다른 주소를 할당하는 방식으로 변수에 재할당이 가능하다

값에 의한 전달

var score = 80;
var copy = score;

console.log(score); //80
console.log(copy); //80
//score와 copy가 보고있는 80은 서로 다른 메모리주소

score = 100;

console.log(score); //100
console.log(copy); //80

원시값에 대해서는 값을 기존의 값을 복사해서 전달하는 call by value가 일어난다.

객체

객체는 프로퍼티의 개수가 정해져 있지 않으며 동적으로 추가, 삭제가 가능하다.
따라서 객체는 원시 값과 같이 확보해야 할 메모리 공간의 크기를 사전에 정할 수 없다.

프로토타입 객체지향언어 자바스크립트와 클래스 기반 객체지향언어

클래스 기반 객체지향언어는 클래스 내에 이미 생성된 프로퍼티와 메서드가 정해져 있으며, 객체가 생성된 이후에는 프로퍼티를 삭제하거나 추가할 수 없다.

자바스크립트는 클래스 없이 객체 생성이 가능하며, 동적으로 프로퍼티와 메서드를 추가할 수 있다.
하지만, 편한 만큼 클래스 기반 언어보다 객체의 생성과 프로퍼티 접근에 비용이 더 많이든다.

변경 가능한 값

객체 값은 변경이 가능한 값(mutable value)이다.

var person = {
    name: 'Lee'
};

var sang = person;

sang.name = 'ss';

console.log(sang.name);
console.log(person.name);

객체는 원시 값이 값의 주소를 갖고있는 것과 다르게, 참조 값에 접근할 수 있다. 참조 값은 생성된 객체가 저장된 메모리 공간의 주소 그 자체다.

때문에 위의 코드처럼 sang, person이 같은 주소인 0x00000001 을 바라보고 있으며 값이 동시에 변경된다.

이를 얕은복사 라고 하며, 참조에 의한 전달이 된다

반응형
반응형

객체란?

자바스크립트는 원시 값을 제외한 나머지 값(함수, 배열, 정규 표현식 등)은 모두 객체

원시 타입은 단 하나의 값만 나타내고, 객체 타입은 다양한 타입의 값을 하나의 단위로 구성한 복합적인 자료구조다.
또 원시 값은 변경 불가능한 값이지만, 객체는 변경 가능한 값이다.

객체는 0개 이상의 프로퍼티로 구성된 집합이고, 키(key)와 값(value)으로 구성되어 있다.

var person = {
    name: 'Lee', //- 프로퍼티
    age: 20 // age : 키, 20 : 값
}

자바스크립트의 함수는 프로퍼티의 값으로 사용할 수 있다. 프로퍼티 값이 함수일 경우, 일반 함수와 구분하기 위해 메서드라고 부른다.

var counter = {
    num: 0,
    increase: function () {
        this.num++;
    }
};
  • 프로퍼티 : 객체의 상태를 나타내는 값
  • 메서드: 프로퍼티를 참조하고 조작할 수 있는 동작

객체 리터럴에 의한 객체 생성

자바스크립트는 프로토타입 기반 객체지향 언어로서 클래스 기반 객체지향 언어와는 달리 다양한 객체 생성 방법을 지원한다.

  • 객체 리터럴
  • Object 생성자 함수
  • 생성자 함수
  • Object.create메서드
  • 클래스(ES6)

이러한 객체 생성 방법 중에서 가장 일반적이고 간단한 방법은 객체 리터럴을 사용하는 방법이다.

객체 리터럴은 중괄호 내에 0개 이상의 프로퍼티를 정의한다. 변수에 할당되는 시점에 자바스크립트 엔진은 객체 리터럴을 해석해 객체를 생성한다.

var person = {
    name: 'Lee';
    sayHello: function() {
        console.log('Hello! My name is $(this.name}.');
    }
};

console.log(typeof person); // object
console.log(person); // {name: "Lee", sayHello: f}

var empty = {};
if(empty){

}
//if문의 코드블록에는 세미콜론 x

객체 리터럴의 중괄호는 코드 블록을 의미하지 않는다는 데 주의.
코드 블록의 닫는 중괄호 뒤에는 세미콜론을 붙이지 않고, 객체 리터럴의 닫는 중괄호 뒤에는 세미콜론을 붙인다.

프로퍼티

객체는 프로퍼티의 집합이며, 프로퍼티는 키와 값으로 구성된다.

var person = {
    name: 'Lee',
    age: 20
};

프로퍼티를 나열할 때는 쉼표(,)로 구분한다. 일반적으로 마지막 프로퍼티 뒤에는 쉼표를 사용하지 않지만, 사용해도 문제되지 않는다.

프로퍼티 키와 프로퍼티 값으로 사용할 수 있는 값은 다음과 같다.

  • 프로퍼티 키: 빈 문자열을 포함하는 모든 문자열 또는 심벌 값
  • 프로퍼티 값: 자바스크립트에서 사용할 수 있는 모든 값

이 때 네이밍 규칙을 따라야 프로퍼티 키값에 따옴표를 생략할 수 있다.

var person = {
    firstName: 'Ung-mo', // 식별자 네이밍 규칙을 준수하는 프로퍼티 키
    'last-name': 'Lee' // 식별자 네이밍 규칙을 준수하지 않는 프로퍼티 키
}

console.log(person); // {firstName: "Ung-mo", last-name: "Lee"}

메서드

자바스크립트에서 사용할 수 있는 모든 값은 프로퍼티 값으로 사용할 수 있다, 그렇기 때문에 자바스크립트의 함수도 프로퍼티 값으로 사용할 수 있다.

프로퍼티 값이 함수일 경우 일반 함수와 구분하기 위해 메서드라 부른다.

var circle = {
    radius: 5, // 프로퍼티

    // 원의 지름
    getDiameter: function () { // 메서드
        return 2 * this.radius; // this는 circle을 가리킨다.
    }
};

console.log(circle.getDiameter()); // 10

프로퍼티 접근

프로퍼티에 접근하는 방법은 다음과 같이 두 가지다.

  • 마침표 프로퍼티 접근 연산자를 사용하는 마침표 표기법
  • 대괄호 프로퍼티 접근 연산자를 사용하는 대괄호 표기법

프로퍼티 키가 식별자 네이밍 규칙을 준수하는 이름, 즉 자바스크립트에서 사용 가능한 유효한 이름이면 마침표 표기법과 대괄호 표기법을 모두 사용할 수 있다.

var person = {
    name: 'Lee'
};

console.log(person.name); // Lee

console.log(person['name']); // Lee

대괄호 프로퍼티 접근 연산자 내부에 지정하는 프로퍼티 키는 반드시 따옴표로 감싼 문자열이 되어야 한다.

문제 예시

var person = {
    name: 'Lee'
};

console.log(person[name]); // ReferenceError: name is not defined

객체에 존재하지 않는 프로퍼티에 접근하면 undefined를 반환한다. 이때 ReferenceError가 발생하지 않는데 주의하자.

프로퍼티 값 갱신

이미 존재하는 프로퍼티에 값을 할당하면 프로퍼티 값이 갱신

var person = {
    name: 'Lee'
}

person.name = 'Kim';

console.log(person); // {name: "Kim"}

프로퍼티 동적 생성

존재하지 않는 프로퍼티에 값을 할당하면 프로퍼티가 동적으로 생성되어 추가되고 프로퍼티 값이 할당된다.

var person = {
    name: 'Lee'
};

person.age = 20;

console.log(person); // {name: "Lee", age: 20}

프로퍼티 삭제

delete 연산자는 객체의 프로퍼티를 삭제한다. 이때 delete 연산자의 피연산자는 프로퍼티 값에 접근할 수 있는 표현식이어야 한다. 만약 존재하지 않는 프로퍼티를 삭제하면 아무런 에러 없이 무시된다.

var person = {
    name: 'Lee'
};

person.age = 20; // 프로퍼티 동적 생성

delete person.age;

delete person.address; // 없는 프로퍼티를 삭제해도 에러반환 x

console.log(person);

ES6에서 추가된 객체 리터럴의 확장 기능

ES6에서는 더욱 간편하고 표현력 있는 객체 리터럴의 확장 기능을 제공한다.

프로퍼티 축약 표현

객체 리터럴의 프로퍼티는 키, 값으로 구성된다.

//ES5
var x = 1, y = 2;

var obj = {
    x: x,
    y: y
}

console.log(obj); // {x: 1, y: 2}

ES6에서는 프로퍼티 값으로 변수를 사용하는 경우 변수 이름과 프로퍼티 키가 동일한 이름일 때 프로퍼티 키를 생략할 수 있다. 이때 프로퍼티 키는 변수 이름으로 자동 생성된다.

//ES6
let x = 1, y = 2;

const obj = { x, y };

console.log(obj); // { x: 1, y: 2 }

계산된 프로퍼티 이름

문자열 또는 문자열로 타입 변환할 수 있는 값으로 평가되는 표현식을 사용해 프로퍼티 키를 동적으로 생성할 수도 있다. 단, 키를 대괄호로 묶어야 한다.

//ES5
var prefix = 'prop';
var i = 0;

var obj = {};

// 계산된 프로퍼티 이름으로 프로퍼티 키 동적 생성
obj[prefix + '-' + ++i] = i;
obj[prefix + '-' + ++i] = i;
obj[prefix + '-' + ++i] = i;

console.log(obj); // {prop-1: 1, prop-2: 2, prop-3: 3}

ES6에서는 객체 리터럴 내부에서도 계산된 프로퍼티 이름으로 프로퍼티 키를 동적 생성할 수 있다.

//ES6
const prefix = 'prop';
let i = 0;

// 리터럴 내부에서 계산된 프로퍼티 이름으로 프로퍼티 키를 동적 생성
const obj = {
    [`${prefix}-${++i}`]: i,
    [`${prefix}-${++i}`]: i,
    [`${prefix}-${++i}`]: i
};

console.log(obj); // {prop-1: 1, prop-2: 2, prop-3: 3}

메서드 축약 표현

ES5는 프로퍼티 값으로 메서드를 정의, ES6에서는 메서드 정의할 때 function 키워드 생략 가능

//ES5
var obj = {
    name: 'Lee',
    sayHi: function() {
        console.log('Hi! ' + this.name);
    }
};

//ES6
const obj = {
    name: 'Lee',
    // 메서드 축약 표현
    sayHi() {
        console.log('Hi! ' + this.name);
    }
};

obj.sayHi(); // Hi! Lee
반응형

+ Recent posts