공부하고 기록하고 반복하자

영화 '히든피겨스'를 보고

슈코 — Sun, 28 Sep 2025 22:56:11 +0900

이번 주말에 대학동기의 결혼식이 있었다

금요일에 전주를 가서 일요일에 올 수 있었지만 얼마전 몸살이 찾아와서 이번엔 휴식을 취하기로 했다

스트레스가 많아졌나? 몸도 마음도 힘든 요즘이다

토요일엔 늦잠을 자기도 다짐하고, 금요일엔 영화를 한편 보기로 했다

(실제로 토요일엔 일찍 눈이 떠졌지만, 11시까지 다시 잠을 청하였다)

히든피겨스

이 영화에 흥미를 느꼈던건 유튜브에서 우연하게 보게 된 쇼츠였다

모두가 바쁜거 같은 사무실에서 화장실에 다녀온 흑인 여성
책임자는 어딜 다녀오냐고 윽박을 지른다
여성은 800m 떨어진 흑인 전용 화장실을 다녀오느라 늦었다고 소리친다
짧은 영상에 그녀의 그동안의 울분이 모두 쏟아지는거 같았다
책임자는 그 소리를 듣고 곧장 해머로 백인 전용 화장실 간판을 부셔버린다
나사에는 화장실 구분이 없다는 말과 함께

저 짧은 영상을 보고 흥미가 생겼다

사실 나는 아시아인을 차별하는 내용을 인터넷으로 종종 접했지만, 흑인에 대한 차별은 제대로 알지 못했다

생기지 않는 동기부여를 부여잡고 싶은 마음이 이끌었는지도 모른다

영화는 제목 그대로 숨겨진 영웅들을 다룬다

나사에서 우주 탐험을 위해서 노력했던 그 많은 사람들중 내가 전혀 몰랐던 분들이다

영화에 나오는 주인공들은 세명의 흑인 여성들인데 한명 한명 차별을 느끼고 있다

한명은 엔지니어를 꿈꾸는데, 성적은 우수하지만 백인들만 다닐 수 있는 학교에 수업을 들어야하는 조건이 있다

(지금 생각하면 정말 말도 안되는 건데, 우리나라 조선시대만 생각해도 너무 당연한것들이 많았으니...)

다른 한명은 관리자 직책을 맡기지도 않으면서 관리자처럼 일을 시킨다

나사에는 IBM이 도입되려고 하면서 단순 계산을 하고 있는 계산원들은 위기의식을 느끼기도 한다

마지막 한명은 탁월한 계산 능력을 가지고 있는데 상사의 무시를 기본적으로 느끼고, 본인은 참석할 수 없는 회의에서 위치가 자꾸 바뀌면서 쓸데없는 계산을 여러번 반복하는 일도 생긴다

물론, 기본적으로 가장 놀라웠던건 백인 전용 화장실, 흑인용 화장실이 따로 있고 커피포트도 같이 쓰는걸 꺼려하는 그 분위기다

흑인용 화장실에 'colored'가 붙어있는데 생각해보니...흰색은 색이 없는거고 흑색은 색이 있는거라 그런거구나...놀랍다...

이런 말도 안되는 상황속에서도 주인공들은 포기하지 않는다. 모든 영화가 마지막에 해피엔딩으로 끝나는 경우가 많아서 그걸 예상했지만, 특히나 이 영화 엔딩에서 주인공들의 행복한 모습이 너무 보고싶어졌다.

엔지니어를 꿈꾸던 주인공은 판사를 설득하여 수업을 들을 수 있었고,

관리자를 꿈꾸던 주인공은 미래(IBM으로 계산)를 먼저 보고 포트란 언어를 공부하여 프로그래머?로 전향?한다

정말 위기속에서도 공부하여 멋지게 기계를 활용하는 모습을 보고 감탄을 금치 못했다.

마지막 계산을 잘하는 주인공은 IBM의 치명적인 실수를 계산을 통하여 바로잡아 우주 계획을 성공적으로 이끌었다

계산원(계산을 담당하는 직원)들을 보면서는 지금 개발자들이 생각났다

단순히 계산을 사람이 하다가, 컴퓨터가 계산을 하게되면 그 차이는 정말 감당할 수 없었을 것 이다

IBM에 쫓겨 일자리를 잃을 수 있었지만, 역으로 IBM을 다룰 준비를 하다니!

대 AI 시대가 도래하면서, AI에게 일자리를 뺏기고 개발자를 못하게 되는건 아닌가? 하는 불안한 개발자들에게 이 영화를 보여주고 싶었다. 그리고, 정말 저렇게 말도 안되는 차별속에서도 꿈을 위해 노력을 포기하지 않고 결국 이루어 내는 주인공들을 보면서 내가 느꼈던 그 사소한 불합리한 것들은 정말 얼마나 나 스스로가 바보같은지를 생각해보게 되었다

회사도 이런저런 이슈로 시끌벅적한 요즘인데, 다시 한번 생각해보자

나는 화장실에 가려고 800m를 가지 않는다
나는 물도 자유롭게 마실 수 있다
나는 책 한권 빌리는게 몰래 가져오듯이 힘들지 않는다

AI 시대라 불안한가? 공부하는데 막는 사람은 아무도 없다!

질문이 너무 많으면

슈코 — Tue, 6 May 2025 10:04:08 +0900

질문이 너무 많은 사람을 만나서 귀찮거나 혹은 짜증이 난다면?

그 사람이 질문 안해도 되는 환경을 만든다!!

정말 오늘도 배운다

계속 질문을 한다

- 개선할점이 있는건가?

- 혼자 개발할 수 있는 충분한 환경을 만드는게 중요하다

- 고민거리같은거 말고 일을 하는데 있어서 필요한 질문들

우리가 문서화가 잘 안되어 있나?

혹은 그 문서를 찾는데 너무 어렵게 되어있나?

등을 고려하는 것 이다

오늘도 배운다!!

가을아침

슈코 — Wed, 4 Sep 2024 07:35:32 +0900

혹독한 무더위가 지나가고 있다

30일 넘는 열대야를 경험했고, 에어컨없이 살기 힘든 주말의 연속이었다

회사는 쾌적하였지만, 회사까지 가는것 조차 힘든 여름이랄까...

그렇게 끝나지 않을것만 같았던 이 여름도 조금씩 헤어질 준비를 하는거 같다

아침에 집을 나오는데, 이제 그렇게 덥다는 느낌이 없다

( 물론 한낮에는 여전히 덥지만 말이다... )

오히려 조금 선선한 바람이 부는날이면 가을이 오고 있음을 실감한다

가을에는 가을아침이지!

오늘 아침 출근길에 바로 선곡하였다

요즘 회사 분위기가 많이 좋지 않고 일이 많아서 힘든 시기이지만,

정말 큰 무더위로 힘든 여름이 지나가듯 이 시기도 지나갈거라고 믿는다

꾸준히 공부하면서 가을을 맞이하자

스레드 - interrupt()

슈코 — Tue, 3 Sep 2024 21:28:25 +0900

스레드의 작업을 중간에 중단하는 방법

flag값 설정 및 수정
interrupt() 사용

flag값 설정

특정 스레드의 실행을 flag 값이 true인 동안 계속해서 작업하도록 설정한다

특정 스레드를 중단하는 시점에 flag 값을 false로 바꾼다

이렇게 하면, 다음 반복문 실행 시점에 flag 값을 확인하고 해당 작업을 빠져 나온다

static class MyTask implements Runnable {

    volatile boolean runFlag = true;

    @Override
    public void run() {
        while (runFlag) {
            log("작업 중");
            sleep(3000);
        }
        log("자원 정리");
        log("작업 종료");
    }
}

runFlag 값을 true로 설정하고, 작업을 진행하는 스레드

public static void main(String[] args) {
    MyTask task = new MyTask();
    Thread thread = new Thread(task, "work");
    thread.start();

    sleep(4000);
    log("작업 중단 지시 runFlag=false");
    task.runFlag = false;
}

Mytask를 실행하고, 4초 후에 해당 스레드의 상태를 false로 수정한다

다음과 같은 방식을 활용하면 간단히 스레드의 작업을 중단 시킬 수 있다.

하지만, flag가 false로 바뀌는 시점에 그 시점의 반복문에서 실행하고 있는 코드는 모두 수행하고,

다음 조건 체크 시 빠져 나오게 된다.

interrupt()

인터럽트는 WATING, TIMED_WAITING과 같은 대기 상태의 스레드를 깨우고, RUNNABLE 상태로 만들 수 있다.

인터럽트 관련 메소드

thread.interrupt() - 해당 스레드에게 인터럽트를 건다
Thread.currentThread().isInterrupted() - 해당 스레드의 상태가 인터럽트인지 체크( 인터럽트 상태 변경 x )
Thread.interrupted() - 스레드의 상태가 인터럽트가 걸렸으면 true를 반환하고, 인터럽트의 상태를 변경해준다( true > false )

상당히 재미있다

interrupt()는 해당 스레드에게 인터럽트를 걸어준다

인터럽트를 건다고 하더라도, 즉각적으로 반응하지는 않는다.

즉, 해당 스레드에게 인터럽트가 걸리는 상황이 발생할때( 예시에서는 Sleep() ) 인터럽트가 발생한다.

인터럽트가 걸리면 InterruptedException이 발생하게되고, 인터럽트 상태가 해제된다

public static void main(String[] args) {
    MyTask task = new MyTask();
    Thread thread = new Thread(task, "work");
    thread.start();

    sleep(4000);
    log("작업 중단 지시 thread.interrupt()");
    thread.interrupt();
    log("work 스레드 인터럽트 상태1 = " + thread.isInterrupted()) ;
}

thread.interrupt()를 통해서 thread 에게 인터럽트를 걸어준다.

static class MyTask implements Runnable {

    volatile boolean runFlag = true;

    @Override
    public void run() {
        try {
            while (true) {
                log("작업 중");
                Thread.sleep(3000);
            }
        } catch (InterruptedException e) {
            log("work 스레드 인터럽트 상태2 = " + Thread.currentThread().isInterrupted());
            log("interrupt message = " + e.getMessage());
            log("state = " + Thread.currentThread().getState());
        }

        log("자원 정리");
        log("작업 종료");
    }
}

해당 스레드는 작업을 이어가다가 sleep(3000) 을 만나면, 인터럽트가 걸린다(걸리면서 해제된다)

isInterrupted()는 현재 스레드의 인터럽트 상태만을 체크한다.

즉, 인터럽트가 걸렸다고해서 해제되는 상황이 발생하지 않는다. 그냥 체크만 한다.

결과값

작업중 interrupt()가 요청되고 main에서 바로 확인한 현재 인터럽트 상태는 true가 반환된다

그 후에 곧바로 sleep 상태에 있는 스레드에게 인터럽트가 걸리게 되고 InterruptedException을 만나면서

인터럽트 상태는 false가 된다

( sleep 상태가 아니고 처리하는 로직이 있었으면, 로직을 수행한다 )

interrupted()는 현재 스레드의 상태가 인터럽트 상태라면, true 반환 후에 인터럽트 상태를 변경해준다( true > false )

static class MyTask implements Runnable {

    @Override
    public void run() {
        while (!Thread.interrupted()) { // 인터럽트 상태 변경X
            log("작업 중");
        }
        log("work 스레드 인터럽트 상태2 = " + Thread.currentThread().isInterrupted());

        try {
            log("자원 정리");
            Thread.sleep(500);
            log("작업 종료");
        } catch (InterruptedException e) {
            log("자원 정리 실패 - 자원 정리 중 인터럽트 발생 ");
            log("work 스레드 인터럽트 상태2 = " + Thread.currentThread().isInterrupted());
        }


    }
}

while문의 조건을 수정하였다

기존에는 true로 주어서 무한반복이 되게끔하고, sleep 상태일때 인터럽트에 걸리면서 빠져나왔다면,

현재는 Thread.interrupted() 메소드를 통해서 인터럽트가 걸리게 되면 바로 해당 반복문을 빠져나온다.

interrupted() 메소드는 인터럽트 상태일때, true를 반환하고 그 상태값을 변경해준다

Thread.interrupted() 메소드 결과

interrupt()를 요청한 직후 main에서 확인한 인터럽트 상태는 true이다

곧바로 스레드의 Thread.interrupted()가 상태값을 변경하면서 반복문을 빠져나오고 상태는 false가 된다;

상태값을 변경했기 때문에, 자원정리중 sleep()이 발생하여도 InterruptException 에 걸리지 않는다

만약, Thread.interrupted()를 사용하지 않고 Thread.currentThread.isInterrupted() 메소드를 사용하여 반복문을 빠져나오면

반복문을 빠져나오며 상태값을 변경하지 않기때문에, 자원정리의 sleep에서 인터럽트가 발생하여 Exception이 발생하게 된다.

어떤것이 무조건 좋다고 할 순 없다
상황에 맞게 설정해야할거 같다
interrupt() / isInterrupted() / interrupted() 의 역할이 무엇인지 확실하게 기억하고 넘어가자
이름이...살짝 헷갈리긴 하다...ㅎㅎ

interrupted()와 isInterrupted()

한가지 궁금점이 생겼다

isInterrupted()는 Thread.currentThread에서 호출하는데, interrupted()는 Thread에서 호출하는 점이다

그럼 혹시 다른스레드에서 interrupt를 호출해도 Thread.interrupted()에서 걸리게 되는걸까?

public class ThreadTest {

    public static void main(String[] args) {
        MyTask task = new MyTask();
        Thread thread = new Thread(task, "work");

        MyTask2 task2 = new MyTask2();
        Thread thread2 = new Thread(task2, "work2");

        thread.start();
        thread2.start();

        sleep(500);
        log("작업 중단 지시 thread2.interrupt()");
        thread2.interrupt();
        log("work 스레드 인터럽트 상태1 = " + thread.isInterrupted()) ;
        log("work 스레드2 인터럽트 상태1 = " + thread2.isInterrupted()) ;
    }

    static class MyTask implements Runnable {

        @Override
        public void run() {
            while (!Thread.interrupted()) { // 인터럽트 상태 변경X
                log("작업 중");
                sleep(2000);
            }
            log("work 스레드 인터럽트 상태2 = " + Thread.currentThread().isInterrupted());

            try {
                log("자원 정리");
                Thread.sleep(2000);
                log("작업 종료");
            } catch (InterruptedException e) {
                log("자원 정리 실패 - 자원 정리 중 인터럽트 발생 ");
                log("work 스레드 인터럽트 상태2 = " + Thread.currentThread().isInterrupted());
            }


        }
    }

    static class MyTask2 implements Runnable {

        volatile boolean runFlag = true;

        @Override
        public void run() {
            try {
                while (runFlag) {
                    log("작업 중");
                    Thread.sleep(2000);
                }
            } catch (InterruptedException e) {
                log("work2 인터럽트!");
            }

            log("자원 정리");
            log("작업 종료");
        }
    }
}

( 테스트용으로 한번에 코드를 올려보았다 )

각각 다른 스레드를 생성한다(MyTask, MyTask2)

MyTask는 interrupted()를 사용하여 인터럽트가 걸리면 바로 빠져 나오도록 설정하고

MyTask2는 sleep 상태일때 인터럽트가 걸리도록 설정해두었다

main에서는 thread2(MyTask2)에게 인터럽트를 걸었다

작업의 결과를 보면, 정상적으로 thread2에게 인터럽트가 걸렸다

sleep 상태의 thread2는 인터럽트에 걸려 작업이 종료된다

반면, 인터럽트 요청이 없는 thread1은 작업이 끝나지 않는다

Thread.currentThread가 아니라, Thread에서 걸어주어도 자신의 스레드만 체크한다

메소드를 확인해보면,

interrupted()는 안에서 currentThread()를 실행하고 있다.

테스트 해보길 잘했다

yield

- 특정한 스레드가 바쁘지 않은 상황에 다른 스레드에게 CPU 실행기회를 양보해 주는 스레드의 메소드

- yield 메소드를 호출한 스레드는 RUNNABLE 상태를 유지하면서 CPU를 양보한다

- 짧은 sleep()으로도 상태를 바꿀 수 있지만, TIME_WAITING으로 상태를 변경하고, 짧은 시간 스레드가 멈춘다

- 양보할 스레드가 없으면, 나의 스레드가 실행된다

- 최근엔, 많은 코어를 가진 CPU들이 많아서 양보가 큰 의미가 없을 수 있다

스레드 - join()

슈코 — Mon, 26 Aug 2024 21:51:28 +0900

join()

특정 스레드가 다른 스레드들의 작업이 끝난 후, 무언가를 종합해서 하고 싶다면 join() 메소드를 사용해주면 된다.

ex)

스레드1 - 1 ~ 50의 합을 구한다
스레드2 - 51 ~ 100의 합을 구한다
메인 - 스레드1,2의 결과값의 합을 구한다

public static void main(String[] args) {
        log("start");
        SumTask task1 = new SumTask(1, 50);
        SumTask task2 = new SumTask(51, 100);
        Thread thread1 = new Thread(task1, "task1");
        Thread thread2 = new Thread(task2, "task2");

        thread1.start();
        thread2.start();

        log("task1.result = " + task1.result);
        log("task2.result = " + task2.result);
        int sumAll = task1.result + task2.result;
        log("task1 + task2 = " + sumAll);

        log("end");
    }

    static class SumTask implements Runnable {

        int startValue;
        int endValue;
        int result = 0;

        public SumTask(int startValue, int endValue) {
            this.startValue = startValue;
            this.endValue = endValue;
        }

        @Override
        public void run() {
            log("작업 시작");
            sleep(2000);
            int sum = 0;
            for (int i = startValue; i < endValue; i++) {
                sum += i;
            }
            result = sum;
            log("작업 완료 result = " + result);
        }
    }

메인은 thread1과 thread2에게 각각 task1, task2를 시키고 그 결과를 합한다.

하지만, 실행해보면 원하는 결과값이 나오지 않는다.

main은 thread1과 thread2에게 작업을 시키고, 그것을 기다리지 않는다.

main은 바로 main의 일을 이어서 진행하기 떄문에, 빈값이 찍히게 된다.

여기서, thread1과 thread2는 각각의 스택에 run() 메소드를 올리고 실행한다.
task1, task2는 힙 영역에 할당되어서 공유하는 방식이다.

스레드는 메서드의 호출을 관리하는데,
메서드 단위로 스택 프레임을 만들고, 그 위에 스택을 쌓아 올린다.
인스턴스의 메소드 호출 시, 해당 인스턴스의 참조값을 저장하는데 이를 'this'라고 한다.

main이 thread1과 thread2의 작업을 기다리기 위해서 join()을 사용해주면 된다.

// 스레드가 종료될 때 까지 대기
log("join() - main 스레드가 thread1, thread2 종료까지 대기");
thread1.join();
thread2.join();
log("main 스레드 대기 완료");

다음 join() 메소드를 thread1과 thread2의 스레드 시작(start)후에 넣어주면 다음과 같은 결과가 나온다.

join()의 영향으로 main은 thread1, thread2의 종료까지 대기한다.

해당 스레드가 종료되면, main은 다시 RUNNABLE 상태가 되어서 원래 임무를 수행한다.

join() - 특정 시간 대기

대상 스레드가 완료될 때 까지 기다리는건 비효율적일 수 있다.

join(ms)를 활용하면, 특정 스레드의 완료까지 대기하지만 입력한 시간이 지나면 빠져나오도록 할 수 있다.

thread1.join(1000);

이는 '메인 스레드가 thread1의 종료까지 1초동안 대기한다.' 라고 생각하면 된다.

끝날때까지 기다려야 하는 로직을 작성해야하면 join()을, limit time을 지정해줘야 하면 join(ms)를 활용하면 된다.

중간에 나올때, 결과가 없으면 그에 맞는 추가 로직을 작성해야 한다.

sleep()을 활용하기엔, 스레드가 정확히 얼마만큼의 대기와 스케줄링이 걸리는지 100% 장담할 수 없다.

예제를 통해서

다음과 같이 3초동안 작업을 하는 스레드가 있다.

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(new MyTask(), "t1");
    Thread t2 = new Thread(new MyTask(), "t2");
    Thread t3 = new Thread(new MyTask(), "t3");

    t1.start();
    t1.join();

    t2.start();
    t2.join();

    t3.start();
    t3.join();

    System.out.println("모든 스레드 실행 완료");
}

public static class MyTask implements Runnable {

    @Override
    public void run() {
        for (int i = 1; i <= 3; i++) {
            log(i);
            sleep(1000);
        }
    }
}

스레드 하나 당 join()을 걸어서 기다려주고, 해당 작업이 끝나야 다음 작업을 시작하도록 하고 있다.

이렇게 되면, 시간은 총 9초가 걸리게 된다(t1, t2, t3 각 3초씩)

동시에 처리하려면,

모든 join() 메소드는 모든 스레드의 start() 메소드 이후에 실행해주어야 한다.

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(new MyTask(), "t1");
    Thread t2 = new Thread(new MyTask(), "t2");
    Thread t3 = new Thread(new MyTask(), "t3");

    t1.start();
    t2.start();
    t3.start();

    t2.join();
    t1.join();
    t3.join();

    System.out.println("모든 스레드 실행 완료");
}

다음과 같이, 실행해주면 3초의 시간에 모든 작업이 끝나게 된다.

하지만, 항상 아래와 같은 방식으로 해줘야하는건 아니다.

만약 전 작업이 끝나야 다음 작업을 수행하는 경우라면 아래의 방법을 사용해주어야 한다.

( 그렇지만... 모든 작업이 끝나야 다음 작업을 실행하는 경우라면, 굳이 멀티스레드를 도입해서 복잡성을 높일 필요는 없을거 같다! )

스레드 제어

슈코 — Thu, 22 Aug 2024 21:47:21 +0900

쓰레드 기본 정보

스레드 ID - 스레드의 고유 식별자, 스레드 생성 시 할당되고, 지정할 수 없다.
스레드 이름 - 내가 지정할 수 있고, 중복될 수 있다.
스레드 우선순위 - 1(낮음) ~ 10(높음), 기본값은 5, 절대적인 실행순서는 아니다.(힌트)
- 힌트라는 말은, 스케줄러가 '참고'하는 대상으로 인식한다는 정도
스레드 그룹 - 스레드가 속한 그룹, 자주 사용하지는 않음
부모 스레드 - 모든 스레드는(main 제외) 누군가가 생성해준다. 나를 생성해준 스레드가 부모 스레드
스레드 상태 - 스레드의 현재 상태
- NEW - 스레드가 생성되고 아직 실행되진 않은 상태
- RUNNABLE - 스레드를 실행중이거나, 실행될 준비가 된 상태
- BLOCKED - 동기화 락을 기다리는 상태
- WATING - 다른 스레드의 작업이 완료되기를 기다리는 상태
- TIMED_WATING - '일정기간' 동안 기다리는 상태
- TERMINATED - 스레드가 실행을 마친 상태
  - 한번 종료된 스레드는 다시 실행할 수 없다.
  - 스레드마다 주어진 스택이 텅 비어지기 떄문에

쓰레드 생명주기

NEW
- 스레드 생성 후 시작되지 않은 상태
- Thread 객체 생성, start() 메소드 실행 전
RUNNABLE
- 스레드가 실행될 준비가 된 상태
- start() 메소드 호출 시 해당 상태로 진입
- 모든 스레드가 동시에 실행되는 것은 아니다.
  - 운영체제의 스케줄러에 의해 CPU 시간을 할당
  - 스케줄러의 대기열에 포함되어 차례대로 실행
  - 너무나 빠르게 실행과 대기열 대기가 반복되기 때문에 이 상태를 구분할 수 없다.
- '실행 상태' 라고도 부른다
BLOCKED
- 다른 스레드에 의해 동기화 락을 얻기 위해 기다리는 상태
WAITING
- 다른 스레드의 특정 작업이 끝나기를 기다리는 상태
- wait(), join() 메서드 호출 시
TIMED WAITING
- 특정 시간동안 다른 스레드의 작업이 끝나기를 기다리는 상태
- '특정 시간'이라는 제한이 들어간다
TERMINATED
- 스레드 실행 완료
- 정상 종료 or 예외 종료
- 종료되면, 다시 시작할 수 없다

제네릭

슈코 — Thu, 15 Aug 2024 12:42:19 +0900

제네릭이 필요한 이유( Box 예제 )

타입 안전성을 높이면서, 코드를 재사용하기 위해

Integer 변수 value를 set, get을 할 수 있는 IntegerBox 클래스 생성

public class IntegerBox {

    private Integer value;

    public void set(Integer value) {
        this.value = value;
    }

    public Integer get() {
        return value;
    }
}

String 변수 value를 set, get을 할 수 있는 StringBox 클래스 생성

public class StringBox {

    private String value;

    public void set(String value) {
        this.value = value;
    }

    public String get() {
        return value;
    }
}

한가지 타입에 대한 같은 기능이지만, 타입을 추가할떄마다 매번 클래스를 새로 만들어야하는 불편함

모든 타입의 부모인 Object 타입으로 생성하여, 문제 해결 시도

public class ObjectBox {

    private Object value;

    public Object get() {
        return value;
    }

    public void set(Object value) {
        this.value = value;
    }
}

get을 할때 Object 타입으로 리턴을 해주기 때문에 맞는 타입을 리턴받으려면 캐스팅을 매번 해줘야 한다.

잘못된 타입(Integer만 set 하려고 했는데, String을 set)을 저장하면, 캐스팅 시 에러가 발생할 수 있다.

코드 재사용은 가능했지만, 에러가 발생할 이슈 존재

타입별로 클래스를 생성 - 타입의 안전성 ↑ 코드 재사용성 ↓
Object - 코드 재사용성 ↑ 타입 안전성 ↓

제네릭 클래스

<>를 사용한 클래스
<> = 다이아몬드
클래스 오른쪽에 <T> 표현 = 제네릭 클래스
T = 타입 매개변수
생성 시점에 타입을 적어 클래스 생성

제네릭 타입 Box로 이슈해결

public class GenericBox<T> {

    private T value;

    public void set(T value) {
        this.value = value;
    }

    public T get() {
        return value;
    }
}

GenericBox<T>를 선언, Integer로 사용하고 싶으면

GenericBox<Integer> integerBox = new GenericBox<Integer>();

다음과 같이 '생성' 시점에 Integer를 적어주면 된다.

( 코드 재사용성 ↑ )

여기서 오른쪽에 Integer는 생략이 가능하다

( 왼쪽에 생성할때, Integer를 적어주기 때문에, 추론이 가능하다 )

GenericBox<> integerBox = new GenericBox<Integer>() ;

Integer로 생성하면, String으로 값을 set 하는 순간 컴파일 에러가 발생한다.

( 타입 안전성 ↑ )

public static void main(String[] args) {

    GenericBox<Integer> integerBox = new GenericBox<Integer>(); // 생성 시점에 T의 타입 결정(Integer로)
    integerBox.set(10);
    Integer integer = integerBox.get(); // Integer 타입만 허용, 컴파일 오류
    System.out.println("integer = " + integer);

    GenericBox<String> stringBox = new GenericBox<String>();
    stringBox.set("hello");
    String str = stringBox.get();
    System.out.println("str = " + str);

    // 원하는 모든 타입 사용 가능
    GenericBox<Double> doubleBox = new GenericBox<>();
    doubleBox.set(10.0);
    Double doubleValue = doubleBox.get();
    System.out.println("doubleValue = " + doubleValue);
    
    // 타입 추론 : 생성하는 제네릭 타입 생략 가능
    GenericBox<Integer> integerBox2 = new GenericBox<>();
}

제네릭의 핵심

사용할 타입을 미리 결정하지 않는다. 생성 시점에 지정한다.

클래스 내부에서 사용하는 타입을 정의하는 시점이 아닌, 생성하는 시점에 결정

용어정리

제네릭 - 일반적인, 범용적인 뜻( 특정 타입에 속한 것 이 아니라, 범용적으로 사용할 수 있다! )
제네릭 타입 - 클래스, 인터페이스 정의 시 타입 매개변수를 사용하는 것
타입 매개변수 - 제네릭 타입, 메서드에서 사용하는 변수로 실제 타입으로 대체된다
타입 인자 - 제네릭 타입을 사용할때, 제공되는 실제 타입

GenericBox<T>
String - Generic<String>
Integer - Generic<Integer>

T를 타입 매개변수,
String, Integer를 타입인자

메소드 매개변수 & 제네릭 매개변수

메소드 매개변수 = 사용할 값에 대한 결정을 나중으로 미룬다.
제네릭 매개변수 = 사용할 타입에 대한 결정을 나중으로 미룬다.

제네릭 명명 관례

E - Element
K - Key
N - Number
T - Type
V - Value

제네릭 기타

한번에 여러 타입을 지정할 수 있다( <K, T> )
항상 <>을 사용해서 사용시점에 원하는 타입을 지정해야 한다
<>을 생략하면, 원시타입(매개변수가 Object로 사용)
원시타입은 제네릭이 생기기 전의 코드와 호환성을 위해

타입 매개변수 제한

제네릭 사용 시 특정 타입으로 타입 매개변수를 제한할때 사용
<T extend 클래스명>
extend 옆에 붙어있는 클래스명 자신, 혹은 그 자식들만 사용 가능

Animal 객체 예시를 통하여 타입 매개변수를 제한하는 것의 장점을 파악할 수 있다.

public class Animal {

    private String name;
    private int size;

    public Animal(String name, int size) {
        this.name = name;
        this.size = size;
    }

    public String getName() {
        return name;
    }

    public int getSize() {
        return size;
    }

    public void sound() {
        System.out.println("동물 울음 소리");
    }

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", size=" + size +
                '}';
    }
}

name과 size를 가지는 Animal 클래스, get() 메소드와 sound(): 동물 울음소리 출력 메소드를 가진다.

public class Dog extends Animal {


    public Dog(String name, int size) {
        super(name, size);
    }

    @Override
    public void sound() {
        System.out.println("멍멍");
    }
}

Animal 클래스를 상속받은 Dog 클래스

public class Cat extends Animal {

    public Cat(String name, int size) {
        super(name, size);
    }

    @Override
    public void sound() {
        System.out.println("야옹");
    }
}

역시 Animal 클래스를 상속받은 Cat 클래스

public class DogHospital {

    private Dog animal;

    public void set(Dog animal) {
        this.animal = animal;
    }

    public void checkup() {
        System.out.println("동물 이름 : " + animal.getName());
        System.out.println("동물 크기 : " + animal.getSize());
        animal.sound();
    }

    public Dog bigger(Dog target) {
        return animal.getSize() > target.getSize() ? animal : target;
    }
}

Dog 클래스를 활용하여 만든 DogHospital 클래스, checkup()과 bigger() 메소드를 가진다

public class CatHospital {

    private Cat animal;

    public void set(Cat animal) {
        this.animal = animal;
    }

    public void checkup() {
        System.out.println("동물 이름 : " + animal.getName());
        System.out.println("동물 크기 : " + animal.getSize());
        animal.sound();
    }

    public Cat bigger(Cat target) {
        return animal.getSize() > target.getSize() ? animal : target;
    }
}

Cat 클래스를 활용하여 만든 CatHospital 클래스, 역시 checkup()과 bigger() 메소드를 가진다

public class AnimalHospitalMainV0 {

    public static void main(String[] args) {
        DogHospital dogHospital = new DogHospital();
        CatHospital catHospital = new CatHospital();

        Dog dog = new Dog("멍멍이1", 100);
        Cat cat = new Cat("고양이1", 300);

        // 개 병원
        dogHospital.set(dog);
        dogHospital.checkup();

        // 고양이 병원
        catHospital.set(cat);
        catHospital.checkup();

        // 문제 1: 개 병원에 고양이 전달
        //dogHospital.set(cat); 다른타입을 입력하면 컴파일 오류

        // 문제 2: 개 타입 반환
        dogHospital.set(dog);
        Dog biggerDog = dogHospital.bigger(new Dog("멍멍이2", 200));
        System.out.println("biggerDog = " + biggerDog);
    }
}

DogHospital, CatHospital 클래스를 만들어 Dog, Cat을 넣어준다.

각각의 클래스는 그에 맞는 동물 클래스만 들어갈 수 있어서 DogHospital에 Cat 객체를 넣으면 컴파일 오류가 발생한다

하지만, 같은 기능을 수행하는 중복되는 클래스를 만든 이슈가 있다.

public class AnimalHospitalV1 {

    private Animal animal;

    public void set(Animal animal) {
        this.animal = animal;
    }

    public void checkup() {
        System.out.println("동물 이름 : " + animal.getName());
        System.out.println("동물 크기 : " + animal.getSize());
        animal.sound();
    }

    public Animal bigger(Animal target) {
        return animal.getSize() > target.getSize() ? animal : target;
    }
}

Dog, Cat 클래스의 부모 클래스인 Animal 클래스를 활용한 AnimalHospital 클래스를 만들어준다.

각각 만들 필요 없이 Dog, Cat 클래스를 모두 넣을 수 있다

public class AnimalHospitalMainV1 {

    public static void main(String[] args) {
        AnimalHospitalV1 dogHospital = new AnimalHospitalV1();
        AnimalHospitalV1 catHospital = new AnimalHospitalV1();

        Dog dog = new Dog("멍멍이1", 100);
        Cat cat = new Cat("고양이1", 300);

        // 개 병원
        dogHospital.set(dog);
        dogHospital.checkup();

        // 고양이 병원
        catHospital.set(cat);
        catHospital.checkup();

        // 문제 1: 개 병원에 고양이 전달
        dogHospital.set(cat);  // 매개변수 체크 실패 : 컴파일 오류가 발생하지 않는다.

        // 문제 2: 개 타입 반환
        dogHospital.set(dog);
        Dog biggerDog = (Dog) dogHospital.bigger(new Dog("멍멍이2", 200));
        System.out.println("biggerDog = " + biggerDog);
    }
}

Dog, Cat 클래스를 활용한 Hospital 클래스 없이도 모든 동물을 넣을 수 있다.

하지만, DogHospital로 만들어도 Cat 클래스를 넣을 수 있다(매개변수 체크 실패: 컴파일 오류가 발생하지 않음)

bigger() 메소드 사용 시 형 변환을 사용해야 하는 경우가 발생한다

매개변수 제한 없이 제네릭을 활용하면, 모든 타입이 들어갈 수 있다
또한, Animal에서 만든 메소드를 사용하지 못한다
(어떤 타입이 들어갈지 알 수 없기 때문에, Object의 기본 메소드만 활용가능)

public class AnimalHospitalV3<T extends Animal> {

    private T animal;

    public void set(T animal) {
        this.animal = animal;
    }

    public void checkup() {
        System.out.println("동물 이름 : " + animal.getName());
        System.out.println("동물 크기 : " + animal.getSize());
        animal.sound();
    }

    public T bigger(T target) {
        return animal.getSize() > target.getSize() ? animal : target;
    }
}

제네릭 선언 시, 매개변수 타입 제한을 활용하면, Animal 클래스 자신과 자식 클래스만 제네릭 타입으로 선언할 수 있다.

Animal 클래스의 메소드를 활용할 수 있다

자식 클래스는, 오버라이딩 되어서 자식 클래스의 메소드를 활용할 수 있다

public class AnimalHospitalMainV3 {

    public static void main(String[] args) {
        AnimalHospitalV3<Dog> dogHospital = new AnimalHospitalV3<>();
        AnimalHospitalV3<Cat> catHospital = new AnimalHospitalV3<>();

        Dog dog = new Dog("멍멍이1", 100);
        Cat cat = new Cat("고양이1", 300);

        // 개 병원
        dogHospital.set(dog);
        dogHospital.checkup();

        // 고양이 병원
        catHospital.set(cat);
        catHospital.checkup();

        // 문제 1: 개 병원에 고양이 전달
        //dogHospital.set(cat);  // 다른 타입을 입력: 컴파일 오류

        // 문제 2: 개 타입 반환
        dogHospital.set(dog);
        Dog biggerDog = dogHospital.bigger(new Dog("멍멍이2", 200));
        System.out.println("biggerDog = " + biggerDog);
    }
}

동물 클래스 별로 만들 필요가 없어 중복을 제거하고, 다른 타입이 들어오는 것을 방지할 수 있다(컴파일 오류 발생)

아빠가 되다

슈코 — Thu, 15 Aug 2024 12:17:58 +0900

2024년 4월 25일 내 인생에 가장 큰 이벤트가 발생하였다.

용용이(태명)가 태어난 것 이다!

나는 그렇게 아빠가 되었다.

사실 출산예정일은 5월 12일이었다.

그래서, 마음의 준비를 미처 하지 못하고 용용이를 맞이하러 내려갔다.

뜻밖의 전화

새벽 6시에 아내에게 전화가 왔었는데, 밤 12시30분부터 진통이 시작되었다고 했다.

처음에는 가진통이겠지 싶어서 가족들에게 이야기하지 않았다고 한다ㅠㅠ

아내는 극심한 고통을 이겨내며, 새벽에 장모님께서 아내를 발견하기 전까지 혼자 참아왔다.

이런 부분은 주말부부를 하고 있는 것 중에 가장 미안한 부분인거 같다ㅠ

KTX

나는 서둘러 내려갈 준비를 하였다.

정말 운이 좋게도? 전날부터 벨소리를 진동이 아닌 소리로 바꿔두었다.

바꾼 첫날에 연락이 올지는 몰랐지만...

머리도 감지 못하고 급하게 집을 출발하였다.

서울에서 전주로 가는 가장 빠른 KTX는

용산에서 출발하는 07시 10분과 07시 43분이 있었다.

07시 10분은 08시 54분에 전주에 도착, 07시 43분은 09시 57분에 전주에 도착하는 기차였다.

빠른 준비?로 다행히 07시 10분 기차에 탑승할 수 있었다.

( 용용이가 태어난 시각이 09시 44분이라서 다음 기차를 탔다면 용용이가 태어나는걸 보지 못했을 것 이다! )

기차안에서 무엇을 할 수 있을까...

아내에게 빨리 가고싶은 생각뿐이었다.

KTX를 이용하면 서울에서 전주까지 2시간 안으로 갈 수 있는 시대이지만,

그 2시간이 안되는 시간도 너무 길게 느껴졌다.

그렇게 아이의 탄생을 직접 볼 수 있었고,

탯줄을 잘라 줄 수 있었다.

아이가 태어나기전, 회사와 의논하여 아내의 산후조리원 기간에 재택근무를 할 수 있었고,

아내의 회복을 곁에서 도울 수 있었다.

그렇게, 용용이는 도훈이라는 이름을 가진 우리의 아들이 되었다.

중간에 도훈이는 복무팽만이 있어서 중환자실까지 가는 일이 있었지만,

다행히 우려하던 병은 아니였고, 무사히 퇴원해서 무럭무럭 자라고 있다.

100일을 넘어간 시점에 10키로에 가까워지고 있다!

한동안 블로그를 포함해서, 신경쓸 겨를이 없었다.

아이를 바라보고 있으면, 정말이지 행복하다.

그렇지만 주말부부라는 특징으로 아이를 보는 것도 주말뿐이다...

매일 고생하고 있는 아내를 보면, 매주 커가는 아이를 보고 있으면 시간을 더 잘 보내야겠다는 생각뿐이다.

다시 블로그도 열심히 하면서 평일에도 최선을 다해보아야겠다.

스레드의 생성과 실행

슈코 — Thu, 15 Aug 2024 10:14:04 +0900

스레드의 생성

Runnable 인터페이스 구현을 사용하자

Thread 클래스 상속
Runnable 인터페이스 구현

스레드는 Thread 클래스를 상속해서 만들거나, Runnable 인터페이스를 구현하는 방법으로 생성할 수 있다.

실무에서는 Runnable 인터페이스를 구현하는 방법을 선호한다.

Thread 클래스를 상속하는 경우, 다른 상속이 있는 경우에는 사용할 수 없다( 다중 상속 X )

따라서, 스레드와 실행할 작업을 명확히 나누어서 개발할 수 있는 Runnable 방식을 사용한다.

스레드 생성 - Thread 클래스 상속

Thread 클래스 상속 후 run() 메소드를 오버라이딩한다.

public class HelloThread extends Thread {

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " : run()");
    }
}

객체 생성 후 start() 메소드를 사용하여 실행한다.

public class HelloThreadMain {
    public static void main(String[] args) {
        HelloThread helloThread = new HelloThread();
        helloThread.start();
    }
}

스레드 생성 - Runnable 인터페이스 구현

Runnable 인터페이스를 구현하는 클래스를 만들고, Thread 객체를 생성할때 생성자로 넣어준다.

public class HelloRunnable implements Runnable {

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + ": run()");
    }
}

public class HelloRunnableMain {
    public static void main(String[] args) {
        HelloRunnable runnable = new HelloRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
    }
}

Runnable을 이용하여 다양한 방법으로 스레드를 생성할 수 있다.

가장 기본적으로, Runnable 인터페이스를 구현하고 이를 스레드 생성 시 파라미터로 넣어준다.

<기본>

public class InnerRunnableMainV1 {

    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
    }

    static class MyRunnable implements Runnable {
        @Override
        public void run() {
            log("run()");
        }
    }
}

다음과 같이 익명클래스를 사용하여 만들 수 있고, 이는 람다로 간단하게 표현할 수 있다.

익명클래스를 사용하는 경우는, 재사용없이 간단히 표현해줄때 사용하면 효과적일 수 있다.

( 재사용이 많은 경우에는, 따로 선언해놓는 방법이 효율적이다. )

<익명클래스>

public class InnerRunnableMainV2 {

    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                log("run()");
            }
        });
        thread.start();
    }
}

<람다 표현식>

public class InnerRunnableMainV2 {

    public static void main(String[] args) {
        Thread thread = new Thread(() -> log("run()"));
        thread.start();
    }
}

결국 람다를 사용한 이 방식을 자주 사용한다.

람다의 경우 다음번에 정리하는 시간을 가져야겠다.( 2024년 8월 19일 기준! )

Runnable의 경우, 한번 만들어둔 것을 반복해서 호출 할 수 있다.

맨 위에 예시 HelloRunnable을 가져와서 반복 생성해보자.

public class ManyThreadMainV1 {

    public static void main(String[] args) {
        HelloRunnable runnable = new HelloRunnable();

        Thread thread1 = new Thread(runnable);
        thread1.start();

        Thread thread2 = new Thread(runnable);
        thread2.start();

        Thread thread3 = new Thread(runnable);
        thread3.start();
    }
}

스레드의 실행

start() 메소드 호출( run() 메소드 호출 x )

만들어둔 스레드 객체를 생성하고, start() 메소드를 실행한다

run() 메소드가 아닌, start() 메소드를 호출해줘야 한다.

( start()를 호출해야, 별도 스레드에서 run()을 호출해줌 )

run() 메소드를 호출하는 경우, 별도의 스레드가 생성되면서 그 스레드가 run()을 호출하는 것이 아닌,

현재 스레드가 단순히 run() 메소드를 실행하게 된다.

( 스레드를 생성해서 그 스레드가 run()을 실행하려고 했던 원래 의도에서 벗어남 )

스레드 메소드

currentThread() - 해당 코드를 실행하는 스레드의 정보 조회

currentThread().getName() - 실행중인 스레드의 이름 조회

( 별도의 이름을 입력해주지 않으면, thread-0, thread-1 등으로 임의 생성된다 )

데몬 스레드

백그라운드에서 보조 작업을 수행하는 스레드

스레드는 사용자 스레드와 데몬 스레드로 구분할 수 있다

( Thread 메소드 setDaemon()을 true로 하면 데몬스레드, 디폴트는 false )

모든 유저 스레드가 종료되면, 데몬 스레드는 자동으로 종료된다.

로거

스레드를 실행할때는 로그를 남기는 것 이 중요하다.

( 어떤 스레드가 실행되었는지를 알아야 하기 때문에 )

로그를 남기는 메소드를 따로 구성하자!

import java.time.LocalTime;
import java.time.format.DateTimeFormatter;

public abstract class MyLogger {

    private static final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm:ss.SSS");

    public static void log(Object obj) {
        String time = LocalTime.now().format(formatter);
        System.out.printf("%s [%9s] %s\n", time, Thread.currentThread().getName(), obj);
    }
}

프로세스와 스레드

슈코 — Tue, 13 Aug 2024 19:41:19 +0900

멀티태스킹

하나의 컴퓨터 시스템이 동시에 여러작업을 수행하는 능력

소프트웨어적 관점

( 무지하게 빠른 CPU를 잘 활용해보자는 )

CPU가 빠르게 여러가지 프로그램의 코드를 번갈아가며 실행하여, 동시에 실행되는 것 처럼!

멀티프로세싱

둘 이상의 프로세서(CPU 코어)를 사용하여 동시에 여러 작업을 동시에 처리하는 기술

하드웨어적 관점

( 코어의 갯수가 여러가지 )

코어의 갯수만큼은 동시에 프로그램을 실행할 수 있는 것!

프로세스

실행중인 프로그램

프로그램이 클래스라면, 프로세스는 인스턴스

프로세스별 독립적인 공간 보유

코드섹션, 데이터 섹션, 힙, 스택으로 구분

( 스택은 스레드별로 주어지고, 나머지는 프로세스별로 주어진다! )

스레드를 실행하기 위한 컨테이너의 느낌으로 생각하면 된다

스레드

프로세스 내에서 반드시 하나 이상 존재

프로세스의 코드를 실행하는 흐름

실질적으로 프로그램 실행 시 프로세스안에 있는 스레드가 CPU의 자원을 활용하여 일을 한다!

스레드별 각자의 스택영역을 가지고 있고, 나머지 영역은 프로세스안에서 스레드들끼리 공유

한 프로세스 내 하나의 스레드 - 단일스레드

한 프로세스 내 여러 스레드 - 멀티스레드

멀티스레드 필요성 - 유튜브 영상보면서 댓글기능 - 영상 스레드, 댓글 스레드

스케줄링

CPU의 시간을 여러 작업에 나누어 분배하는 방법

( 어떤 프로그램이 얼마만큼 실행되는지 )

CPU를 최대한 활용할 수 있는 다양한 기법이 존재

( 필요하면 더 공부할 수 있도록 )

컨텍스트 스위칭

"문맥을 전환한다." 라는 뜻을 가짐

운영체제에서는, 한 스레드 실행 중 스케줄링에 의해 다른 스레드가 실행될때, 스레드 간 전환 과정

스레드가 전환하면서, 기존 데이터를 저장하고 새로운 작업을 하도록 하는 작업

비용이 발생한다

( 매우 빠르지만 비용이 발생한다는 점 )

대부분 효율적, 그러나 별거 아닌 기능에 너무 많은 전환이 들어가면 비효율적

스레드 실무

웹 어플리케이션 서버의 경우, I/O Bound가 자주 발생한다.

그 말은, CPU가 노는 경우가 많이 발생할 수 있다는 것.

이를 위해서, CPU 코어와 스레드 갯수를 맞추지 않고 스레드 갯수를 늘려 I/O 작업 시 스레드는 다른 작업을 진행한다

( 효율성 증가 )

실무에서는 성능 테스트를 통해서, 최적의 스레드 갯수를 찾아야 한다!