s0hlog

[로그인] Spring Security + JWT 로그인 구현하기

s0hlog — Tue, 29 Jul 2025 15:12:08 +0900

Spring Security는 스프링의 보안 Java의 인증과 권한 부여에 중점을 둔 하위 프레임워크이다.

보안 용어

접근 주체 (Principal) : 보호된 시스템 리소스에 접근하는 사용자나 프로세스 등, 식별 가능한 모든 행위자.
인증 (Authentication) : 접근 주체가 제시한 자격 증명을 통해 그들의 신원이 진짜임을 검증하는 절차.
인가 (Authorization) : 인증된 주체가 특정 리소스에 대해 요청한 작업을 수행할 수 있는 권한을 가지고 있는지 여부를 결정하는 과정.
권한 (Authority) : 인증된 주체에게 부여된, 특정 리소스에 접근하거나 특정 작업을 수행할 수 있도록 허가된 권리의 범위 또는 수준.

JWT

JWT는 헤더(Header), 페이로드(Payload), 서명(Signature) 세 부분으로 구성됨

이 세 부분은 각각 Base64Url로 인코딩되어 점(.)으로 구분 (예: xxxxx.yyyyy.zzzzz)

- 헤더 (Header)

토큰의 종류(typ)와 어떤 알고리즘(alg)으로 서명되었는지 등, 토큰에 대한 기본 정보 담김.

{
  "alg": "HS256",
  "typ": "JWT"
}

- 페이로드 (Payload)

토큰에 담아 전달할 실제 데이터(정보)를 담는 부분.

사용자의 아이디(sub), 토큰 만료 시간(exp) 등 '클레임(Claim)'이라 불리는 정보 조각들이 포함되는 곳.

중요: 이 부분은 암호화된 것이 아니라서 누구나 디코딩해서 볼 수 있으므로, 비밀번호 같은 민감한 정보는 절대 넣으면 안 됨

{
  "sub": "user123",
  "name": "홍길동",
  "exp": 1672531199
}

서명 (Signature)

토큰의 위변조 여부를 확인하는 데 사용되는 부분

인코딩된 헤더와 페이로드를 합친 후, 서버만 알고 있는 비밀 키(Secret Key)로 암호화하여 생성

이 서명이 있어야만 토큰이 신뢰성을 가짐

구현 과정

1. build.gradle 에 코드 추가

dependencies {
	implementation 'org.springframework.boot:spring-boot-starter-security'
	// ... 기존 코드 ...
	implementation 'io.jsonwebtoken:jjwt-api:0.11.5'
	implementation 'io.jsonwebtoken:jjwt-impl:0.11.5'
	implementation 'io.jsonwebtoken:jjwt-jackson:0.11.5'
}

Spring Security를 위한 의존성 하나, JWT를 위한 의존성 3개를 추가한다.

jjwt-api : 전체적인 구조
jjwt-jackson : 헤더와 페이로드의 내용을 JSON으로 변환
jjwt-impl : 서명 & 최종 JWT를 완성

2. JwtToken DTO 생성

@Builder
@Data
@AllArgsConstructor
public class JwtToken {
    private String grantType;
    private String accessToken;
    private String refreshToken;
}

Lombok 을 사용하는 이유 : JWT 처리 과정에 필요한 수많은 데이터 객체들을 생성하고 관리하는 코드를 획기적으로 줄여줌

@Data: @Getter, @Setter, @ToString, @EqualsAndHashCode 등 핵심적인 메서드들 전부 자동 생성
@Builder: 객체 생성을 위한 빌더(Builder) 패턴 코드를 자동 생성, 직관적인 객체 생성을 가능하게 함
@AllArgsConstructor: 모든 필드를 인자로 받는 생성자를 자동 생성

grantType : 토큰 유형
- "이 토큰은 어떤 종류의 토큰입니다"를 알려주는 필드.
- JWT에서는 거의 항상 Bearer 라는 값을 사용 (Bearer : 표준 인증 방식)
accessToken : 접근 토큰
- 실제로 API를 호출하거나 보호된 리소스에 접근할 때 사용하는 단기 유효기간의 토큰
- 클라이언트는 요청을 보낼 때마다 이 토큰을 HTTP 헤더에 담아 보내야 함
refreshToken : 갱신 토큰
- accessToken이 만료되었을 때, 새로 발급받기 위해 사용하는 장기 유효기간의 토큰
- 이 토큰 덕분에 사용자는 accessToken이 만료될 때마다 다시 로그인할 필요 없이, 자동으로 인증 연장 가능

3.application.properties 에 코드 추가

jwt.secret=apU0yOW7PgV5L5qwE04kNjwms6SmuNbM4HBGUQGvCdpF0Xd1f3aI7QMk59h9

JWT의 서명을 만들고 검증하는 데 사용되는 비밀 키로, 외부 노출 XXX

4. SecurityConfig 파일 생성

우리 서버의 보안 총괄 설정 파일이다.

이 클래스 안에서 로그인 방식, URL별 접근 권한, CORS, CSRF 등 애플리케이션의 모든 보안 규칙을 정의한다.

CORS (Cross-Origin Resource Sharing) 정책: 외부(프론트엔드)와의 연결 규칙 정의
CSRF (Cross-Site Request Forgery) 보호 기능: JWT 기반 인증을 사용할 때 일반적으로 따르는 보안 정책 중 하나를 선택

@Configuration // 스프링의 설정 클래스임을 나탄냄
@EnableWebSecurity // 스프링 시큐리티 활성화, 웹 보안 설정을 커스터마이징
@RequiredArgsConstructor // final 필드나 @NonNull 필드에 대한 생성자를 자동으로 생성해주는 Lombok 어노테이션
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
                .cors(Customizer.withDefaults())
                .csrf(AbstractHttpConfigurer::disable)

                // 세션 비활성화: JWT를 사용하므로 세션을 STATELESS 상태로 변경
                .sessionManagement(session -> session
                        .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                )

                // 기본 로그인 및 인증 비활성화: 기본으로 제공되는 formLogin, httpBasic 인증 사용 X
                .formLogin(AbstractHttpConfigurer::disable)
                .httpBasic(AbstractHttpConfigurer::disable)

                // URL별 접근 권한 설정
                .authorizeHttpRequests(authz -> authz
                        .requestMatchers("/api/v1/signup", "/api/v1/login").permitAll() // 회원가입, 로그인 API는 인증 없이 누구나 접근 가능하도록 허용
                        .anyRequest().authenticated() // 그 외 모든 요청은 반드시 인증된 사용자만 접근 가능
                )
                .addFilterBefore(new JwtAuthenticationFilter(jwtProvider, userDetailsService), UsernamePasswordAuthenticationFilter.class);
        return http.build();
    }

    @Bean
    CorsConfigurationSource corsConfigurationSource() {
        CorsConfiguration config = new CorsConfiguration(); // CORS 정책을 설정하기 위한 객체 생성

        config.setAllowCredentials(true);  // 요청에 쿠키나 인증 헤더 같은 자격 증명(credentials)을 포함하도록 허용
        config.setAllowedOrigins(List.of("http://localhost:3000")); // 요청을 허용할 출처(Origin)를 지정. 배포시에는 그 도메인주소로 설정
        config.setAllowedMethods(List.of("GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS")); // 허용할 HTTP 메서드 지정
        config.setAllowedHeaders(List.of("*")); // 허용할 요청 헤더 지정. "*"는 모든 헤더 허용
        config.setExposedHeaders(List.of("*")); // 클라이언트(브라우저)에서 노출할 응답 헤더를 지정

        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource(); // URL 기반으로 CORS 설정을 관리하는 소스 객체를 생성
        source.registerCorsConfiguration("/**", config); // "/**" 패턴, 즉 모든 URL 경로에 대해 위에서 정의한 CORS 정책(config) 적용
        return source; // 설정이 완료된 소스 객체를 반환합니다.
    }
    
    @Bean
    public PasswordEncoder passwordEncoder() {
        return PasswordEncoderFactories.createDelegatingPasswordEncoder();
    }
}

filterChain(HttpSecurity http) : Spring Security의 핵심 보안 설정 담당

corsConfigurationSource() : CORS(Cross-Origin Resource Sharing) 정책 정의

passwordEncoder() : 비밀번호를 안전하게 암호화하기 위한 암호화 도구 생성

5. JwtProvider 파일 생성

토큰을 본격적으로 사용하는 파일.

주로 JWT 생성, JWT 검증, 정보 추출의 역할을 한다.

@Slf4j
@Component
public class JwtProvider {

    private final Key key;

    // application.yml 또는 application.properties에서 시크릿 키를 주입받음
    public JwtProvider(@Value("${jwt.secret}") String secretKey) {
        byte[] keyBytes = Decoders.BASE64.decode(secretKey);
        this.key = Keys.hmacShaKeyFor(keyBytes);
    }

    /**
     * 사용자 정보를 기반으로 Access Token과 Refresh Token을 생성
     * @param userId - 토큰을 발급받을 사용자 ID
     * @return 생성된 토큰 정보 (TokenDto)
     */
    public JwtToken generateToken(String userId) {
        long now = (new Date()).getTime();

        // Access Token 생성 (유효 기간: 1시간)
        Date accessTokenExpiresIn = new Date(now + 3600000); // 1시간
        String accessToken = Jwts.builder()
                .setSubject(userId)
                .setExpiration(accessTokenExpiresIn)
                .signWith(key, SignatureAlgorithm.HS256)
                .compact();

        // Refresh Token 생성 (유효 기간: 7일)
        String refreshToken = Jwts.builder()
                .setExpiration(new Date(now + 604800000)) // 7일
                .signWith(key, SignatureAlgorithm.HS256)
                .compact();

        return JwtToken.builder()
                .grantType("Bearer")
                .accessToken(accessToken)
                .refreshToken(refreshToken)
                .build();
    }

    /**
     * JWT 토큰의 유효성을 검증
     * @param token - 검증할 토큰 문자열
     * @return 토큰이 유효하면 true, 아니면 false
     */
    public boolean validateToken(String token) {
        try {
            Jwts.parserBuilder().setSigningKey(key).build().parseClaimsJws(token);
            return true;
        } catch (io.jsonwebtoken.security.SecurityException | MalformedJwtException e) {
            log.info("잘못된 JWT 서명입니다.");
        } catch (ExpiredJwtException e) {
            log.info("만료된 JWT 토큰입니다.");
        } catch (UnsupportedJwtException e) {
            log.info("지원되지 않는 JWT 토큰입니다.");
        } catch (IllegalArgumentException e) {
            log.info("JWT 토큰이 잘못되었습니다.");
        }
        return false;
    }

    /**
     * 토큰에서 사용자 ID를 추출
     * @param accessToken - 사용자 ID를 추출할 토큰
     * @return 추출된 사용자 ID
     */
    public String getUserId(String accessToken) {
        Claims claims = parseClaims(accessToken);
        return claims.getSubject();
    }

    /**
     * 토큰을 파싱하여 클레임(정보)을 추출 (만료된 토큰도 정보 추출 가능)
     * @param accessToken - 파싱할 토큰
     * @return 추출된 클레임
     */
    private Claims parseClaims(String accessToken) {
        try {
            return Jwts.parserBuilder().setSigningKey(key).build().parseClaimsJws(accessToken).getBody();
        } catch (ExpiredJwtException e) {
            return e.getClaims();
        }
    }
}

역할: JWT 관련 모든 기능을 제공하는 핵심 도구
생성자: 설정 파일의 비밀 키를 가져와 JWT 서명에 사용할 키를 생성
generateToken 메서드:
- 사용자 ID를 받아 단기 액세스 토큰과 장기 리프레시 토큰을 생성
- 생성된 토큰들을 TokenDto에 담아 반환
validateToken 메서드:
- 토큰을 입력받아 서명, 유효기간 등을 검증
- 유효하면 true, 아니면 false 반환
getUserId 메서드:
- 유효한 토큰에서 사용자 ID 정보를 추출
parseClaims 메서드:
- 토큰의 데이터 부분(Payload)을 꺼내는 내부 기능

6. JwtAuthenticationFilter 구현

클라이언트의 모든 요청을 가로채서, 요청 헤더에 담긴 JWT를 검증하고, 유효하다면 해당 사용자를 인증 상태로 만들어주는 역할

@RequiredArgsConstructor
public class JwtAuthenticationFilter extends OncePerRequestFilter {

    private final JwtTokenProvider jwtProvider;
    private final UserDetailsService userDetailsService;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        // 1. 요청 헤더에서 토큰 추출
        String token = resolveToken(request);

        // 2. 토큰 유효성 검사
        if (token != null && jwtProvider.validateToken(token)) {
            // 토큰이 유효할 경우 토큰에서 Authentication 객체를 가져와서 SecurityContext에 저장
            String username = jwtProvider.getUserId(token);
            UserDetails userDetails = userDetailsService.loadUserByUsername(username);

            // 인증 객체 생성
            UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, "", userDetails.getAuthorities());

            // SecurityContext에 인증 정보 저장
            SecurityContextHolder.getContext().setAuthentication(authentication);
        }

        filterChain.doFilter(request, response);
    }

    // Request Header에서 토큰 정보 추출
    private String resolveToken(HttpServletRequest request) {
        String bearerToken = request.getHeader("Authorization");
        if (StringUtils.hasText(bearerToken) && bearerToken.startsWith("Bearer ")) {
            return bearerToken.substring(7);
        }
        return null;
    }
}

7-1. User 엔티티 생성

데이터베이스에 저장될 사용자 정보를 담는 User 엔티티 생성

@Entity
@Getter
@NoArgsConstructor
@Table(name = "users")
public class User implements UserDetails {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, unique = true)
    private String username; // 로그인 ID

    @Column(nullable = false)
    private String password; // 암호화된 비밀번호

    @ElementCollection(fetch = FetchType.EAGER)
    @Builder.Default
    private List<String> roles = new ArrayList<>(); // 사용자의 권한 목록

    @Builder
    public User(String username, String password, List<String> roles) {
        this.username = username;
        this.password = password;
        this.roles = roles;
    }

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        // 'roles' 목록을 Spring Security가 이해할 수 있는 권한(GrantedAuthority) 객체로 변환
        return this.roles.stream()
                .map(SimpleGrantedAuthority::new)
                .collect(Collectors.toList());
    }

    @Override
    public String getPassword() {
        return this.password; // 암호화된 비밀번호 반환
    }

    @Override
    public String getUsername() {
        return this.username; // 로그인 ID 반환
    }

    // 아래 4개는 계정 상태에 대한 설정입니다. (지금은 모두 true로 설정)
    @Override
    public boolean isAccountNonExpired() {
        return true; // 계정 만료 여부
    }

    @Override
    public boolean isAccountNonLocked() {
        return true; // 계정 잠금 여부
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true; // 비밀번호 만료 여부
    }

    @Override
    public boolean isEnabled() {
        return true; // 계정 활성화 여부
    }
}

8. UserRepository 생성

위에서 만든 User 엔티티의 데이터베이스 작업을 처리할 UserRepository 생성

public interface UserRepository extends JpaRepository<User, Long> {
    // username을 기반으로 사용자를 찾는 메서드
    Optional<User> findByUsername(String username);
}

9. UserDetailsService 구현

Spring Security가 사용자 정보를 조회할 때 사용할 서비스인 UserDetailsService의 실제 구현체 생성

이 클래스가 JwtAuthenticationFilter에서 호출됨

@Service
@RequiredArgsConstructor
public class CustomUserDetailsService implements UserDetailsService {

    private final UserRepository userRepository;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // UserRepository를 통해 DB에서 사용자를 찾아 UserDetails 타입으로 반환합니다.
        // 사용자를 찾지 못하면 예외를 발생시킵니다.
        return userRepository.findByUsername(username)
                .orElseThrow(() -> new UsernameNotFoundException("해당하는 유저를 찾을 수 없습니다."));
    }
}

10. 로그인, 회원가입 로직 구현하기

10-1. UserService 생성

@Service
@RequiredArgsConstructor
public class UserService {

    private final UserRepository userRepository;
    private final PasswordEncoder passwordEncoder;
    private final JwtProvider jwtProvider;
    private final AuthenticationManagerBuilder authenticationManagerBuilder;

    @Transactional
    public Long signUp(String username, String password) {
        if (userRepository.findByUsername(username).isPresent()) {
            throw new IllegalArgumentException("이미 사용 중인 아이디입니다.");
        }
        String encodedPassword = passwordEncoder.encode(password);
        User user = User.builder()
                .username(username)
                .password(encodedPassword)
                .roles(Collections.singletonList("USER")) // 기본 권한
                .build();
        return userRepository.save(user).getId();
    }

    @Transactional
    public JwtToken login(String username, String password) {
        // 1. ID/PW 기반으로 AuthenticationToken 생성
        UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(username, password);

        // 2. 실제 검증 (비밀번호 대조)
        // 이 과정에서 CustomUserDetailsService의 loadUserByUsername 메서드가 실행됨
        Authentication authentication = authenticationManagerBuilder.getObject().authenticate(authenticationToken);

        // 3. 인증 정보를 기반으로 JWT 생성
        return jwtProvider.generateToken(authentication.getName());
    }
}

10-2. UserController 생성

@RestController
@RequiredArgsConstructor
@RequestMapping("/api/v1")
public class UserController {

    private final UserService userService;

    @PostMapping("/signup")
    public ResponseEntity<String> signUp(@RequestBody UserRequestDto request) {
        userService.signUp(request.getUsername(), request.getPassword());
        return ResponseEntity.ok("회원가입이 완료되었습니다.");
    }

    @PostMapping("/login")
    public ResponseEntity<JwtToken> login(@RequestBody UserRequestDto request) {
        JwtToken token = userService.login(request.getUsername(), request.getPassword());
        return ResponseEntity.ok(token);
    }
    
    // 요청 시 사용할 DTO
    @Data
    static class UserRequestDto {
        private String username;
        private String password;
    }
}

이것으로 Spring Security와 JWT를 이용한 로그인 시스템의 모든 구현이 끝났습니다.

전체 흐름

최초 요청: 클라이언트가 ID/PW로 /api/v1/login을 호출
인증 및 토큰 발급: UserService가 ID/PW를 검증하고, 성공 시 JwtProvider를 통해 Access/Refresh 토큰을 발급하여 클라이언트에게 전달
인증이 필요한 요청: 클라이언트는 발급받은 accessToken을 Authorization: Bearer <토큰> 형식으로 HTTP 헤더에 담아 다른 API 요청
필터 기반 검증: JwtAuthenticationFilter가 요청을 가로채 헤더의 토큰을 검증함. 토큰이 유효하면, CustomUserDetailsService를 통해 사용자 정보를 찾아 SecurityContext에 저장하여 "인증된 사용자"로 만듬.
API 로직 수행: 인증이 완료되었으므로 컨트롤러의 로직이 정상적으로 수행

후기 : 항상 간단하게 패스워드 받고 로그인하는 과정만 만들어봐서 신기했다. 토큰이라해서 어렵게 생각했는데, 작은 단위에서 하나하나 만들다보니 유기적으로 연계된게 느껴져서 이해가 더 쉬웠다. JWT를 실제로 해보니 더 깊게 이해하게 된 것 같다.

혼자 공부하는 컴퓨터구조론 + 운영체제 : 10단원 정리

s0hlog — Wed, 23 Jul 2025 21:56:12 +0900

혼자 공부하는 컴퓨터구조론 + 운영체제 : 10단원 정리

I. 10-1: 프로세스 개요

프로세스

프로그램 :

- 아직 실행되지 않은 명령어와 데이터의 덩어리

- 정적인 파일

ex) hwp.exe 아이콘은 그 자체로는 아무 일도 하지 않는 프로그램

프로세스 :

- 메모리 위에서 활발하게 실행되고 있는 프로그램

- 프로그램을 더블 클릭하여 실행하는 순간, 운영체제는 실행을 시작

[작업 관리자->프로세스] 탭의 프로세스 직접 확인

- 사용자가 직접 실행한 몇몇 응용 프로그램 외에도 수십, 수백 개의 알 수 없는 프로세스들이 실행되고 있다

-> 운영체제가 단순히 사용자가 실행한 프로그램을 띄워주는 수동적인 플랫폼이 아님

-> 자체적인 프로세스들을 끊임없이 실행

프로세스의 분류

포그라운드 프로세스 (Foreground Process): 사용자가 눈으로 보며 직접 상호작용하는 프로세스
- 웹 브라우저, 텍스트 편집기, 게임 등
백그라운드 프로세스 (Background Process): 보이지 않는 곳에서 정해진 작업을 수행하는 프로세스
유닉스 계열에서는 데몬(daemon),
Windows에서는 서비스(service) 라고 부름.

프로세스 제어 블록(Process Control Block, PCB)

운영체제가 각 프로세스를 관리하기 위해 필요한 모든 핵심 정보를 담고 있는 자료구조
동시에 실행되는 수백 개의 프로세스를 구별하고 관리할 수 있는 이유
운영체제가 프로세스를 관리하는 데 필요한 거의 모든 정보를 포함

PCB에 담기는 정보

항목	설명
프로세스 ID (PID)	프로세스를 식별하기 위해 부여하는 고유한 번호
레지스터 값	프로세스가 실행하며 사용했던 레지스터 값들이 저장됨
프로세스 상태	현재 프로세스의 상태가 저장됨
CPU 스케줄링 정보	프로세스가 언제 CPU를 할당받을지에 대한 정보가 저장됨
메모리 관리 정보	프로세스의 메모리 주소가 저장됨
사용한 파일과 입출력장치 목록	프로세스에 할당되었던 입출력장치나 파일에 대한 내용이 저장됨

문맥 교환 (Context Switching)

기존 프로세스의 문맥을 PCB에 백업하고, 새로운 프로세스를 실행하기 위해 문맥을 PCB로부터 복구하여 새로운 프로세스를 실행하는 것

문맥(Context)

: 하나의 프로세스를 다시 실행하기 위해 저장되는 정보

: PCB에 기록되는 정보

프로세스의 메모리 영역

영역	설명	할당 방식
코드 (Code)	- 텍스트 영역 - CPU가 실행할 명령어 저장되는 공간 - 읽기 전용 공간	정적 할당
데이터 (Data)	- 프로그램이 실행되는 동안 유지할 데이터 저장	정적 할당
힙 (Heap)	- 프로그래머가 직접 할당할 수 있는 저장 공간 - 메모리의 낮은 주소에서 높은 주소로 할당 - 동적으로 할당하고 해제 - 메모리 누수 주의	동적 할당
스택 (Stack)	- 데이터를 임시로 저장하는 공간 - 메모리의 높은 주소에서 낮은 주소로 할당	동적 할당

정적 할당 영역 : 크기 고정

동적 할당 영역 : 크기 변화 가능

10-2. 프로세스 상태와 계층 구조

프로세스 상태 다이어그램

생성 상태
- 프로세스를 생성 중인 상태로, 이제 막 메모리에 적재되어 PCB를 할당받은 상태.
- 생성 상태를 거쳐 실행할 준비가 완료된 프로세스는 곧바로 실행되지 않고 준비 상태가 되어 CPU의 할당을 기다림
준비 상태
- 당장이라도 CPU를 할당받아 실행할 수 있지만, 아직 자신의 차례가 아니기에 기다리고 있는 상태
- 차례가 되면 CPU를 할당받아 실행 상태로
실행 상태
- CPU를 할당받아 실행 중인 상태
- 할당된 일정 시간 동안만 CPU 사용 가능
- 프로세스가 할당된 시간을 모두 사용한다면 다시 준비 상태,
- 실행 도중 입출력장치를 사용하여 입출력 장치의 작업이 끝날 때까지 기다려야 한다면 대기 상태
대기 상태
- 입출력장치의 작업을 기다리는 상태
- 좀 더 일반적으로는 특정 이벤트(주로 입출력)가 일어나길 기다리는 상태
- 입출력 작업이 완료되면 해당 프로세스는 다시 준비 상태로 CPU 할당을 기다림
종료 상태
- 프로세스가 종료된 상태
- 프로세스가 종료되면 운영체제는 PCB와 프로세스가 사용한 메모리를 정리

프로세스 계층 구조

부모 프로세스 : 새 프로세스를 생성한 프로세스
자식 프로세스 : 부모에 의해 생성된 프로세스

프로세스 생성 기법

fork
- 부모 프로세스는 fork 시스템 호출을 통해 자신의 복사본을 자식 프로세스로 생성
- 이때 부모 프로세스의 자원들(메모리 내의 내용, 열린 파일 목록 등)이 자식 프로세스에 상속
- 자식 프로세스의 PID 값이나 저장된 메모리 위치는 다름
exec
- 만들어진 복사본(자식 프로세스)은 exec 시스템 호출을 통해 자신의 메모리 공간을 새로운 프로그램으로 덮어씀
- 코드 영역과 데이터 영역의 내용이 실행할 프로그램의 내용으로 바뀌고, 나머지 영역은 초기화

10-3. 스레드

스레드
- 프로세스를 구성하는 실행의 흐름 단위
- 하나의 프로세스는 여러 개의 스레드를 가질 수 있음
프로세스 : 스레드를 몇 개 가지느냐에 따라 단일 스레드 프로세스와 멀티 스레드 프로세스로 나뉨
단일 스레드 프로세스
- 하나의 실행 흐름(스레드)만을 가지는 프로세스
- 하나의 작업이 끝나야 다음 작업을 시작할 수 있음.

멀티 스레드 프로세스
- 여러 개의 실행 흐름(스레드)을 가지는 프로세스
- 러 작업을 동시에 처리하여 효율을 높임.

멀티프로세스
- 여러 개의 프로세스를 동시에 실행하는 것
- 다른 프로세스와 자원 공유 X
- 각각의 프로세스는 운영체제로부터 자신만의 독립된 메모리 영역 할당 -> 다른 프로세스의 자원에 직접 접근 X
멀티스레드
- 하나의 프로세스를 여러 개의 스레드로 나누어 동시에 실행하는 것
- 다른 스레드와 자원 공유 O
- 같은 프로세스 내의 스레드들은 코드, 데이터, 힙 영역을 서로 공유
- 단, 각 스레드는 자신만의 스택 영역은 별도로 가짐

혼자 공부하는 컴퓨터구조론 + 운영체제 : 9단원 정리

s0hlog — Wed, 16 Jul 2025 14:19:04 +0900

[혼자 공부하는 컴퓨터구조+운영체제] 9장 정리

09-1 운영체제의 기본

운영체제(OS) 는 컴퓨터 하드웨어와 사용자 사이에서 자원을 효율적으로 관리하고, 응용 프로그램 실행을 지원하는 소프트웨어이다.
실행할 프로그램에 필요한 자원(CPU, 메모리, 저장장치 등)을 할당하고, 프로그램이 안전하고 효율적으로 동작하도록 제어한다.

09-2 운영체제의 큰 그림

커널 (Kernel)

운영체제의 핵심 부분으로, 자원 관리와 제어를 담당한다.
하드웨어 자원에 접근하거나, 여러 응용 프로그램 간의 충돌 없이 시스템 자원을 배분한다.
커널에 포함되지 않는 서비스
- 사용자 인터페이스 (UI)
- 그래픽 유저 인터페이스 (GUI)
- 커맨드 라인 인터페이스 (CLI)
  → 이런 것들은 운영체제의 ‘껍데기(shell)’ 역할을 하는 부분이다.

이중 모드(Dual Mode)와 시스템 호출(System Call)

이중 모드(Dual Mode)

CPU는 명령어를 두 가지 모드 중 하나에서 실행한다:
- 사용자 모드(User Mode)
  - 운영체제 서비스를 제공받을 수 없는 실행되는 모드
  - 커널 영역의 코드 실행 X
  - 하드웨어 자원 직접 접근 불가능
- 커널 모드(Kernel Mode)
  - 운영체제 서비스 코드를 실행할 수 있는 모드
  - 자원(CPU, 메모리, 하드웨어)에 직접 접근 가능

이중 모드의 목적
→ 응용 프로그램이 하드웨어 자원에 직접 접근하지 못하게 막아 시스템 안정성과 보안을 확보하기 위함

시스템 호출(System Call)

사용자 모드에서 실행 중인 프로그램이 운영체제의 서비스 요청
시스템 호출이 발생하면:
1. CPU가 커널 모드로 전환
2. 커널 코드가 실행되어 요청 처리
3. 작업이 끝나면 다시 사용자 모드로 돌아감
시스템 호출은 일종의 인터럽트
- 소프트웨어 인터럽트라고도 함
- 명령어에 의해 의도적으로 발생하는 인터럽트

시스템 호출 예시 (하드 디스크 접근)

한 응용 프로그램이 하드 디스크에 데이터를 저장하려고 할 때의 과정을 예로 들어보자.

응용 프로그램이 하드 디스크에 저장 요청 → 시스템 호출 발생
커널 모드로 전환되어, 커널 영역에 있는 하드 디스크 저장 코드를 실행
작업이 끝나면 사용자 모드로 복귀하여 응용 프로그램의 실행을 이어감

이처럼 사용자 모드에서 하드웨어 자원에 직접 접근하지 못하게 하고, 반드시 커널 모드로 전환해 운영체제를 통해 자원을 사용하도록 제어한다.

운영체제의 핵심 서비스

프로세스(Process)
→ 실행 중인 프로그램을 말한다.
예) 윈도우의 작업 관리자를 열어 보면 수많은 프로세스가 실행 중인 것을 확인할 수 있다.
사용자가 컴퓨터를 사용하는 동안 메모리 안에서는 계속해서 새로운 프로세스가 생성되고, 사용되지 않는 프로세스는 메모리에서 삭제된다.

자원 접근 및 할당

모든 프로세스는 실행을 위해 CPU, 메모리, 입출력 장치 등 여러 자원을 필요로 한다. 운영체제는 이러한 자원을 적절히 할당해 주고, 여러 프로세스가 동시에 동작할 때 충돌 없이 공정하게 자원을 사용할 수 있도록 관리한다.

CPU

일반적으로 메모리에는 여러 프로세스가 적재되어 있지만, CPU는 한 번에 하나의 프로세스만 실행 가능하다.
따라서 CPU를 사용 중인 프로세스가 있으면, 다른 프로세스는 대기해야 한다.
운영체제는 어떤 프로세스부터 CPU를 사용하게 할지, 얼마나 오래 CPU를 사용하게 할지를 결정한다.
- 이를 CPU 스케줄링이라 한다.

메모리

적재된 프로세스들

크기가 다르다.
적재되는 메모리 주소도 매번 다를 수 있다.

운영체제는 새로운 프로세스를 메모리에 적재할 때마다 어느 위치에 적재할지 결정해야 한다.

입출력 장치

입출력 서비스 루틴은 운영체제가 제공하는 기능으로 커널 영역에 있다.
입출력 장치가 CPU에 하드웨어 인터럽트 신호를 보내면:
1. CPU는 수행 중이던 작업을 잠시 백업
2. 커널 영역에 있는 인터럽트 서비스 루틴을 실행
운영체제는 이러한 인터럽트 서비스 루틴을 통해 입출력 작업을 수행한다.

파일 시스템 관리

컴퓨터 사용 시 파일을 열고, 생성하고, 삭제한다.
여러 파일은 디렉터리(폴더)로 묶어 관리한다.
파일 시스템(file system) 은 이러한 파일과 디렉터리를 관리하고 저장하는 운영체제의 핵심 서비스다.

핵심 정리

운영체제의 핵심 서비스를 제공하는 부분을 커널이라 한다.
사용자 프로세스가 커널 서비스를 받으려면, 사용자 모드에서 커널 모드로 전환해야 한다.
이 전환은 시스템 호출(system call) 을 통해 이루어진다.
커널의 대표적인 서비스:
- 프로세스 관리
- 자원 접근 및 할당
- 파일 시스템 관리

[백준/JAVA] 9012번: 괄호 | STACK 공부

s0hlog — Fri, 4 Jul 2025 15:26:32 +0900

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

스택 공부를 위해 찾은 9012번.

내내 파이썬으로 코딩테스트를 공부하다가 자바로 공부하기로 마음을 먹었다.

그래서 1년 전에 풀었다가 다시 푸는 문제!

((()()(()))(((())))() 이렇게 이어져있는 String문에서 하나씩 보는게 어려웠다.
파이썬은 그냥 s[i]를 통해 접근했었는데 ㅠㅠ

처음에 문제를 보고서는 가장 단순한 방법으로 접근했는데, 머릿속에 떠올리자마자 저번에 구현했다가 오답이 났던 게 기억이 난다.

최종 정답 코드

package stack;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.Stack;


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

        int num1 = Integer.parseInt(br.readLine());
        for (int i = 0; i < num1; i++) {
            String result = "YES";
            String s = br.readLine();

            Stack<String> st = new Stack<>();

            for (int j = 0; j < s.length(); j++) {
                char c = s.charAt(j);
                if (c == '(') {
                    st.add("(");
                } else if (c == ')') {
                    if (st.isEmpty()) {
                        result = "NO";
                        break;
                    } else {
                        st.pop();
                    }
                }
            }

            if (!st.isEmpty()) {
                result = "NO";
            }
            System.out.println(result);
        }
    }
}

간단한 코드 설명

입력으로 테스트케이스 개수 num1을 먼저 받는다.
그다음 각 줄마다 괄호 문자열을 받아서 한 글자씩 확인한다.
여는 괄호 (가 나오면 스택에 push하고, 닫는 괄호 )가 나오면 스택에서 pop한다.
만약 닫는 괄호를 pop하려는데 스택이 비어있으면 → 이미 짝이 안 맞으니 NO 출력.
마지막까지 돌고 난 뒤에도 스택이 비어있지 않으면 → 남은 여는 괄호가 있으니 NO 출력.
모두 잘 맞으면 YES 출력.

스택으로 괄호 짝 맞추는 전형적인 문제인데, 자바에서는 charAt()으로 한 글자씩 보는 법을 배웠다.

스택을 쓰니 쉽게 풀렸다.

지난번에 배운 BufferedReader도 사용해보고 싶어서 써보기 ㅎㅎ

[문법/JAVA] BufferedReader, BufferedWriter 등등 시간초과 대비

s0hlog — Wed, 2 Jul 2025 19:15:31 +0900

항상 Scanner, sout를 편하다는 이유로 자주 사용하다보니 시간초과가 종종 일어난다.

BufferedReader, BufferedWriter를 사용하면 더 빠르다는데...

확실히 알기 위해 정리하기!

BufferedReader 기본 사용법

장점 : 훨씬 빠르다!

단점 : 무조건 String으로 읽어온다!

예제 - 정수 하나 입력받기

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        
        int n = Integer.parseInt(br.readLine());
        System.out.println(n);
    }
}

정수 하나를 입력받고 출력하는 예제이다.

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

그동안 Scanner를 정의하듯이, 이를 정의하면 된다.

readLine()은 한 줄 통째로 문자열로 읽는 역할을 한다.

문자열이니까 int 로 받으려면 꼭 형변환하기

throws IOException은, 입출력은 항상 오류가 날 수 있어 반드시 사용해줘야한다.

종종 까먹어도 컴파일러가 늘 밑줄로 경고해준다!

StringTokenizer 기본 사용법

장점 : 빠르고, 공백으로 쉽게 나눌 수 있다.
단점 : nextToken()으로 하나하나 꺼내야 해서 조금 귀찮다.

백준에서 입력이

10 20 30 40

이렇게 한 줄에 여러 개 들어올 때 split() 보다 속도 면에서 유리하다.

예제 - 공백으로 구분된 여러 수 입력받기

import java.io.*;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        
        String str = br.readLine();
        StringTokenizer st = new StringTokenizer(str);

        while (st.hasMoreTokens()) {
            int num = Integer.parseInt(st.nextToken());
            System.out.println(num);
        }
    }
}

StringTokenizer는 문자열을 토큰 단위로 잘라준다.

StringTokenizer st = new StringTokenizer(str);

기본으로 공백 기준으로 자른다.

다른 기준으로 자르고 싶다면 두 번째 매개변수에 구분자를 적는다.

예시 - 콤마(,)를 구분자로 사용

StringTokenizer st = new StringTokenizer("10,20,30", ",");

다음 코드를 보면

while (st.hasMoreTokens()) {
    int num = Integer.parseInt(st.nextToken());
    System.out.println(num);
}

입력을 받고, 바로 문자열을 토큰 단위로 자르라는 코드이다.

hasMoreTokens()을 통해 아직 꺼낼 토큰이 남아있는지 확인하고 (Boolean),

nextToken() 를 통해 토큰을 하나 꺼내온다.

BufferedWriter 기본 사용법

백준에서 출력이 많으면 System.out.println()도 느리다. 이럴 때 쓰는 게 BufferedWriter이다.

장점 : 출력 속도가 매우 빠르다.

단점 : flush()를 직접 해줘야 한다.

예제 - 숫자 여러 줄 출력하기

import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        
        int n = Integer.parseInt(br.readLine());
        
        for (int i = 1; i <= n; i++) {
            bw.write(i + "\n");
        }
        
        bw.flush(); 
        bw.close();
    }
}

BufferedReader은, 앞에서 배웠듯이 입력받는 방법이다.

BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

이는 출력을 위해 선언해준다.

write()

: 문자열을 출력 버퍼에 기록한다. sout과 다르게 바로 출력되지 않고, 버퍼에 잠깐 모아둔다.

flush()

: 버퍼에 모아둔 데이터를 한 번에 출력한다. BufferedWriter를 썼다면 꼭 해줘야 한다!

close()

: 스트림을 닫고 자원을 정리한다. 마지막에 꼭 호출하는 것이 좋다.

StringBuilder 기본 사용법

백준에서 가장 많이 쓰이는 출력 방식이 StringBuilder 이다.

장점 : 문자열을 한 번에 모아서 출력 → 속도 빠름
단점 : 코드가 조금 길어질 수 있다.

예제 - StringBuilder로 출력

import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        
        int n = Integer.parseInt(br.readLine());
        StringBuilder sb = new StringBuilder();
        
        for (int i = 1; i <= n; i++) {
            sb.append(i).append("\n");
        }
        
        System.out.print(sb);
    }
}

StringBuilder는 문자열을 계속 더할 때 쓰는 클래스이다.

→ + 연산으로 문자열을 합치는 것보다 훨씬 빠르다.

BufferedWriter보다 편해서 많은 사람들이 쓰곤 한다.

StringBuilder sb = new StringBuilder();

StringBuilder 객체를 만든다. 빈 문자열 상태로 만들어진다.

append()

: 문자열을 뒤에 계속 붙인다. 기존 문자열 + 새 문자열

sb.append(i).append("\n");

append(i) → 숫자 i를 문자열로 바꿔서 추가

append("\n") → 줄바꿈 문자 추가

이렇게 계속 더해진 값을 sout을 통해 마지막에 출력해주면 된다.

정리하자면

BufferedReader → 빠르게 입력

StringTokenizer → 공백으로 잘라 쓰기

BufferedWriter → 빠르게 출력

StringBuilder → 문자열 모아서 한 번에 출력

너무너무 헷갈리고 항상 까먹는다.

꼭 복습을 통해 잊지말자 !!!