프로그래밍 기초_Day 12

오늘 한 공부🧐

오전

• 알고리즘 문제(SQL, Java) 1문제 풀이 & 블로그 정리
• Java 문법 종합반 5주차 강의 복습

오후

• Java 문법 종합반 5주차 강의 복습
• TIL 블로그 작성

 

오늘 얻은 내용 정리✏️

Java 문법 종합반_5주차 강의 내용 정리

Process와 Thread

Process : 운영체제로부터 자원을 할당받는 작업의 단위

• 실행 중인 프로그램을 의미한다.
• OS가 프로그램 실행을 위한 프로세스를 할당해줄 때 프로세스 안에 프로그램 Code와 Data 그리고 메모리 영역(Stack, Heap)을 함께 할당해준다.
  • Code는 Java main 메서드와 같은 코드를 말한다.
  • Data는 프로그램이 실행 중 저장할 수 있는 저장공간을 의미한다.
    • 전역변수, 정적변수(static), 배열 등 초기화된 데이터를 저장하는 공간
  • Memory(메모리 영역) → 동적으로 필요한 변수 저장하는 공간
    • Stack : 지역변수, 매개변수 리턴 변수 저장하는 공간
    • Heap : 프로그램이 동적으로 필요한 변수를 저장하는 공간 (new( ), mallock( ))
• 각 프로그램은 Process를 통해 Code, Data, Memory(Stack, Heap)를 OS로부터 할당받는다.

Thread : 프로세스가 할당받은 자원을 이용하는(공유하는) 실행의 단위 → 작업자, 일꾼

• Process가 작업 중인 프로그램에서 실행요청이 들어오면 Thread(일꾼)을 만들어 처리하도록 한다.
• Thread들은 실행을 위한 프로세스 내 주소공간이나 메모리공간(Heap)을 공유받는다.
• Thread(일꾼)들은 각각 명령처리를 위한 자신만의 메모리공간(Stack)을 할당받는다.
• Java Thread
  • Java Main Thread부터 실행되며 JVM에 의해 실행된다.
  • Java Main Thread : Java 프로그램이 실행될 때 무조건 처음에 같이 실행되는 Thread이다.

---

Multi Thread

Java는 Main Thread가 main( ) 메서드를 실행시키면서 시작이 된다.

• Main Thread는 필요에 따라서 작업 Thread들을 생성해서 병렬로 코드를 실행시킬 수 있다.
• Java는 멀티 Thread를 지원한다.
• Java 프로그램은 Main Thread외에 다른 작업 Thread들을 생성하여 여러 개의 실행흐름을 만들 수 있다.
  • Main Thread 안에서 만들어서 실행시키는 것이다.
• 장점
  • 여러 개의 Thread(실행 흐름)을 통해 여러 개의 작업을 동시에 할 수 있어서 성능이 좋아진다.
  • Stack을 제외한 모든 영역에서 메모리를 공유하기 때문에 자원을 보다 효율적으로 사용할 수 있다.
  • 응답 Thread와 작업 Thread를 분리하여 빠르게 응답을 줄 수 있다. (비동기)
• 단점
  • Process의 자원을 공유하면서 작업을 처리하기 때문에 자원을 서로 사용하려고 하는 충돌이 발생하는 경우를 의미한다.
  • 교착상태(Dead-Lock)이 발생할 수 있다.

---

Thread와 Runnable

Thread

package week05.thread;

// 1. Thread Class를 이용하는 것 (상속)
//
public class TestThread extends Thread{
    @Override
    public void run () {
        // 실제 우리가 쓰레드에서 수행할 작업
        for (int i = 0; i < 100; i++) {
            System.out.print("*");
        }
    }
}

• 핵심은 run( ) 메서드이다.
• run( ) 메서드에 작성된 코드가 Thread가 수행할 작업이다.

Runnable

package week05.thread;

public class TestRunnable implements Runnable{
    @Override
    public void run() {
        // Thread에서 수행할 작업 정의!!
        for (int i = 0; i < 100; i++) {
            System.out.print("$");
        }
    }
}

• 여기서의 run( ) 메서드도 마찬가지로 Thread가 수행할 작업이다.
• Java는 다중 상속을 지원하지 않는다. 그렇기 때문에 Thread를 상속 받아 처리하는 방법은 확장성이 매우 떨어진다.
• 하지만 Runnable은 인터페이스이기 때문에 다른 필요한 클래스를 상속받을 수 있다. 따라서 확장성에 매우 유리하다.

람다식

package week05.thread;

public class Main {
    public static void main(String[] args) {

        // 익명 함수처럼 사용할 수 있다.
        Runnable task = () -> {
            int sum = 0;
            for (int i = 0; i < 50; i++) {
                sum += i;
                System.out.println(sum);
            }
            System.out.println(Thread.currentThread().getName() + " 최종 합 : " + sum);
        };

        Thread thread1 = new Thread(task);
        thread1.setName("thread1");
        Thread thread2 = new Thread(task);
        thread2.setName("thread2");

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

• run( ) 메서드에 작성했던 Thread가 수행할 작업을 실행 블록 { } 안에 작성하면 된다.
• setname( ) 메서드는 쓰레드에 이름을 부여할 수 있다.
• Thread.currentThread( ).getName( )은 현재 실행 중인 Thread의 이름을 반환한다.

---

데몬 Thread와 사용자 Thread

데몬 Thread

• 보이지 않는 곳(background)에서 실행되는 낮은 우선순위를 가진 Thread를 말한다.
  • 보조적인 역할을 담당하며 대표적인 데몬 Thread로는 가비지 컬렉터(GC)가 있다.

package week05.thread.demon;

public class Main {
    public static void main(String[] args) {
        Runnable demon = () -> {
            for (int i = 0; i < 1000000; i++) {
                System.out.println(i + "번째 demon");
            }
        };

        // 우선순위가 낮다! -> 상대적으로 다른 Thread에 비해 리소스를 적게 할당받는다.
        Thread thread = new Thread(demon);
        thread.setDaemon(true);

        thread.start();

        for (int i = 0; i < 100; i++) {
            System.out.println(i + "번째 task");
        }
    }
}

• 우선순위가 낮고 다른 Thread가 모두 종료되면 강제 종료당한다.

사용자 Thread

• 보이는 곳(foreground)에서 실행되는 높은 우선순위를 가진 Thread를 말한다.
• 프로그램 기능을 담당하며 대표적인 사용자 Thread로는 Main Thread가 있다.
• 사용자 Thread 만드는 법 : 기존에 만들었던 Thread들이 전부 사용자 Thread이다.

JVM은 사용자 Thread의 작업이 끝나면 데몬 Thread도 자동으로 종료시켜 버린다.

---

Thread 우선 순위와 Thread 그룹

Thread 우선 순위

• Thread 작업의 중요도에 따라서 Thread의 우선순위를 부여할 수 있다.
  • 한 Process에 여러 개의 Thread가 있을 수 있다. 모든 Thread가 다 똑같이 중요한 Thread는 아닐 것이다. 
  • 작업의 중요도가 높을 때 우선순위를 높게 지정하면 더 많은 작업시간을 부여받아 빠르게 처리될 수 있다.
• Thread는 생성될 때 우선순위가 정해진다.
  • 최대 우선순위 (MAX_PRIORITY) = 10
  • 최소 우선순위 (MIN_PRIORITY) = 1
  • 보통 우선순위 (NROM_PRIORITY) = 5
    • 기본 값이 보통 우선순위이다.
  • 우선순위의 범위는 OS가 아니라 JVM에서 설정한 우선순위이다.
• Thread 우선순위는 setPriority( ) 메서드로 확인할 수 있다.
• getPriority( ) 메서드로 우선순위를 반환하여 확인할 수 있다.

package week05.thread.priority;

public class Main {
    public static void main(String[] args) {
        Runnable task1 = () -> {
            for (int i = 0; i < 100; i++) {
                System.out.print("$");
            }
        };

        Runnable task2 = () -> {
            for (int i = 0; i < 100; i++) {
                System.out.print("*");
            }
        };

        Thread thread1 = new Thread(task1);
        thread1.setPriority(8);
        int threadPriority = thread1.getPriority();
        System.out.println("threadPriority = " + threadPriority);

        Thread thread2 = new Thread(task2);
        thread2.setPriority(2);

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

• Thread1이 리소스를 더 많이 가져간다. 더 빨리 끝날 가능성이 높다.
  • 무거운 작업을 돌릴 때 빛을 볼 수 있다.

Thread 그룹

서로 관련이 있는 thread들을 그룹으로 묶어서 다룰 수 있다.

• Thread들은 기본적으로 그룹에 포함되어 있다.
  • JVM이 시작되면 system 그룹이 생성되고 Thread들은 기본적으로 system 그룹에 포함된다.
• Main Thread는 system 그룹 하위에 있는 main 그룹에 포함된다.
• 모든 Thread들은 반드시 하나의 그룹에 포함되어 있어야 한다. → 자동으로 main 그룹에 포함된다.

package week05.thread.group;

public class Main {
    public static void main(String[] args) {
        Runnable task = () -> {
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    Thread.sleep(1000);
                    System.out.println(Thread.currentThread().getName());
                } catch (InterruptedException e) {
                    break;
                }
            }
            System.out.println(Thread.currentThread().getName() + " Interrupted");
        };

        // ThreadGroup 클래스로 객체를 만듭니다.
        ThreadGroup group1 = new ThreadGroup("Group1");

        // Thread 객체 생성시 첫번째 매개변수로 넣어줍니다.
        // Thread(ThreadGroup group, Runnable target, String name)
        Thread thread1 = new Thread(group1, task, "Thread 1");
        Thread thread2 = new Thread(group1, task, "Thread 2");

        // Thread에 ThreadGroup 이 할당된것을 확인할 수 있습니다.
        System.out.println("Group of thread1 : " + thread1.getThreadGroup().getName());
        System.out.println("Group of thread2 : " + thread2.getThreadGroup().getName());

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

        try {
            // 현재 쓰레드를 지정된 시간동안 멈추게 합니다.
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // interrupt()는 일시정지 상태인 쓰레드를 실행대기 상태로 만듭니다.
        group1.interrupt();

    }
}

---

Thread 상태와 제어

Thread 상태

Thread를 정리한 표

상태	Enum(상수)	설명
객체 생성	NEW	Thread 객체 생성, 아직 start( ) 메서드 호출 전의 상태
실행 대기	RUNNABLE	실행 상태로 언제든지 갈 수 있는 상태
일시정지	WAITING	다른 쓰레드가 통지(notify)할 때까지 기다리는 상태
일시정지	TIMED_WAITING	주어진 시간 동안 기다리는 상태
일시정지	BLOCKED	사용하고자 하는 객체의 Lock이 풀릴 때까지 기다리는 상태
종료	TERMINATED	Thread의 작업이 종료된 상태

Thread 제어

---

sleep( ), interrupt( )

sleep( )

• 현재 Thread를 지정된 시간동안 멈추게 한다.
• Thread 자기자신에 대해서만 멈추게 할 수 있다.

package week05.thread.stat.sleep;

public class Main {
    public static void main(String[] args) {
        Runnable task = () -> {
            try {
                // (1) 예외처리 필수!
                // - interrupt() 를 만나면 다시 실행되기 때문에
                // - InterruptedException이 발생할 수 있다.
                // (2) 특정 Thread 지목 불가
                Thread.sleep(2000);  // TIMED_WAITING (주어진 시간동안만 기다리는 상태)


            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("task : " + Thread.currentThread().getName());
        };

        Thread thread = new Thread(task, "Thread");  // NEW
        thread.start();  // NEW -> RUNNABLE

        try {
            // 1초가 지나고 나면 runnable 상태로 변하여 다시 실행된다!
            // 특정 스레드를 지목해서 멈추게 하는 것은 불가능하다!
            // Static member 'java.lang.Thread.sleep(long)' accessed via instance reference
            thread.sleep(1000);
            System.out.println("sleep(1000) : " + Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

interrupt( )

• 일시정지 상태인 Thread를 실행대기 상태로 만든다.

package week05.thread.stat.interrupt;

public class Main {
    public static void main(String[] args) {
        Runnable task = () -> {
            // interrupted 상태를 체크해서 처리하면 오류를 방지
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    Thread.sleep(1000);
                    System.out.println(Thread.currentThread().getName());
                } catch (InterruptedException e) {
                    break;
                }
            }
            System.out.println("task : " + Thread.currentThread().getName());
        };

        Thread thread = new Thread(task, "Thread");
        thread.start();

        thread.interrupt();

        System.out.println("thread.isInterrupted() = " + thread.isInterrupted());

    }
}

join( )

• 정해진 시간 동안 지정한 Thread가 작업하는 것을 기다린다.
• 시간을 지정하지 않았을 때는 지정한 Thread의 작업이 끝날 때까지 기다린다.

package week05.thread.stat.join;

// 정해진 시간 동안 지정한 쓰레드가 작업하는 것을 기다린다.
// - 시간을 지정하지 않았을 때는 지정한 Thread의 작업이 끝날 때까지 기다린다.
public class Main {
    public static void main(String[] args) {
        Runnable task = () -> {
            try {
                Thread.sleep(5000); // 5초
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        };

        Thread thread = new Thread(task, "thread");  // NEW

        thread.start();  // NEW -> Runnable

        long start = System.currentTimeMillis();  // 몇 초정도 소요됐는지 계산해보기 위해 받아온다.

        try {
            // 시간을 지정하지 않았기 때문에 thread가 작업을 끝낼 때까지 main thread는 기다리게 된다.
            thread.join();

        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // thread 의 소요시간인 5000ms 동안 main 쓰레드가 기다렸기 때문에 5000이상이 출력됩니다.
        System.out.println("소요시간 = " + (System.currentTimeMillis() - start));
    }
}

yield( )

• 남은 시간을 다음 Thread에게 양보하고 Thread 자신은 실행대기 상태가 된다.

package week05.thread.stat.yield;

// 남은 시간을 다음 Thread에게 양보하고 Thread 자신은 실행대기 상태가 된다.

// thread1과 thread2가 같이 1초에 한 번씩 출력되다가
// 5초 뒤에 thread1에서 InterruptedException이
// 발생하면서 Thread.yield(); 이 실행되어 thread1은
// 실행대기 상태로 변경되면서 남은 시간은 thread2에게 양보된다.

public class Main {
    public static void main(String[] args) {
        Runnable task = () -> {
            try {
                for (int i = 0; i < 10; i++) {
                    Thread.sleep(1000);
                    System.out.println(Thread.currentThread().getName());
                }
            } catch (InterruptedException e) {
                Thread.yield();
            }
        };

        Thread thread1 = new Thread(task, "thread1");  // NEW
        Thread thread2 = new Thread(task, "thread2");  // NEW

        thread1.start();  // NEW -> Runnable
        thread2.start();  // NEW -> Runnable

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        thread1.interrupt();

    }
}

synchronized( )

• Multi Thread의 경우 여러 Thread가 한 프로세스의 자원을 공유해서 작업하기 때문에 서로에게 영향을 줄 수 있다.
  이로 인해 장애나 버그가 발생할 수 있다.
• 이러한 일을 방지하기 위해 한 Thread가 진행 중인 작업을 다른 Thread가 침범하지 못하도록 막는 것이다.
• 동기화를 하려면 다른 Thread의 침범을 막아야하는 코드들을 '임계영역'으로 설정하면 된다.
• 임계영역에는 Lock을 가진 단 하나의 Thread만 출입이 가능하다.
  • 임계영역은 한번에 단 하나의 Thread만 사용이 가능하다.
• 실행할 메서드 또는 실행할 코드 묶음 앞에 붙여서 임계영역을 지정하여 다른 Thread의 침범을 막을 수 있다.

package week05.thread.stat.sync;

public class Main {
    public static void main(String[] args) {
        AppleStore appleStore = new AppleStore();

        Runnable task = () -> {
            while (appleStore.getStoredApple() > 0) {
                appleStore.eatApple();
                System.out.println("남은 사과의 수 = " + appleStore.getStoredApple());
            }

        };

        // 3개의 thread를 한꺼번에 만들어서 start를 해버림!!
        // 생성(NEW)과 동시에 start(NEW -> Runnable)
        for (int i = 0; i < 3; i++) {
            // thread A, B, C
            new Thread(task).start();
        }
    }
}

class AppleStore {
    private int storedApple = 10;

    public int getStoredApple() {
        return storedApple;
    }

    public void eatApple() {
        synchronized (this) {
            if(storedApple > 0) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                storedApple -= 1;
            }
        }
    }
}

wait( ), notify( ) → 둘은 쌍이다. 항상 같이 사용한다.

• 침범을 막은 코드(sync)를 수행하다가 작업을 더 이상 진행할 상황이 아니면, wait( )을 호출하여 Thread가 Lock을 반납하고 기다리게 할 수 있다.
• 추후에 작업을 진행할 수 있는 상황이 되면 notify( )를 호출해서 작업을 중단했던 Thread가 다시 Lock을 얻어 진행할 수 있게 된다.

wait( )

• 실행 중이던 Thread는 해당 객체의 대기실(waiting pool)에서 통지를 기다린다.

notify( )

• 해당 객체의 대기실(waiting pool)에 있는 모든 Thread 중에서 임의의 Thread만 통지를 받는다. (random으로 받는다.)

package week05.thread.stat.waitnotify;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static String[] itemList = {
            "MacBook", "IPhone", "AirPods", "iMac", "Mac mini"
    };
    public static AppleStore appleStore = new AppleStore();
    public static final int MAX_ITEM = 5;

    public static void main(String[] args) {

        // 가게 점원
        Runnable StoreClerk = () -> {
            while (true) {
                // 0부터 4 사이의 정수 중, Random한 값을 뽑아내기 위함.
                int randomItem = (int) (Math.random() * MAX_ITEM);

                // restock : 재고를 넣는 메서드
                appleStore.restock(itemList[randomItem]);
                try {
                    Thread.sleep(50);
                } catch (InterruptedException ignored) {
                }
            }
        };

        // 고객
        Runnable Customer = () -> {
            while (true) {
                try {
                    Thread.sleep(77);
                } catch (InterruptedException ignored) {
                }

                int randomItem = (int) (Math.random() * MAX_ITEM);

                // sale : 판매하는 메서드
                appleStore.sale(itemList[randomItem]);
                System.out.println(Thread.currentThread().getName() + " Purchase Item " + itemList[randomItem]);
            }
        };


        new Thread(StoreClerk, "StoreClerk").start();
        new Thread(Customer, "Customer1").start();
        new Thread(Customer, "Customer2").start();

    }
}

class AppleStore {
    private List<String> inventory = new ArrayList<>();

    public void restock(String item) {
        synchronized (this) {
            while (inventory.size() >= Main.MAX_ITEM) {
                System.out.println(Thread.currentThread().getName() + " Waiting!");
                try {
                    wait(); // 재고가 꽉 차있어서 재입고하지 않고 기다리는 중!
                    Thread.sleep(333);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 재입고
            inventory.add(item);
            notify(); // 재입고 되었음을 고객에게 알려주기
            System.out.println("Inventory 현황: " + inventory.toString());
        }
    }

    public synchronized void sale(String itemName) {
        while (inventory.size() == 0) {
            System.out.println(Thread.currentThread().getName() + " Waiting!");
            try {
                wait(); // 재고가 없기 때문에 고객 대기중
                Thread.sleep(333);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        while (true) {
            // 고객이 주문한 제품이 있는지 확인
            for (int i = 0; i < inventory.size(); i++) {
                if (itemName.equals(inventory.get(i))) {
                    inventory.remove(itemName);
                    notify(); // 제품 하나 팔렸으니 재입고 하라고 알려주기
                    return; // 메서드 종료
                }
            }

            // 고객이 찾는 제품이 없을 경우
            try {
                System.out.println(Thread.currentThread().getName() + " Waiting!");
                wait();
                Thread.sleep(333);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

Lock

• synchronized 블럭으로 동기화하면 자동적으로 Lock이 걸리고 풀리지만, 같은 메서드 내에서만 Lock을 걸 수 있다는 제약이 있다.
  이 제약을 해결하기 위해 Lock 클래스를 사용한다.
• ReentrantLock
  • 재진입 가능한 Lock, 가장 일반적인 배타 Lock
  • 특정 조건에서 Lock을 풀고, 나중에 다시 Lock을 얻어 임계영역으로 진입이 가능하다.

public class MyClass {
    private Object lock1 = new Object();
    private Object lock2 = new Object();
    
    public void methodA() {
        synchronized (lock1) {
            methodB();
        }
    }
    
    public void methodB() {
        synchronized (lock2) {
            // do something
            methodA();
        }
    }
}

• methodA에서 이미 Lock1을 가지고 있으므로 lock2를 기다리는 상태가 되어 데드락이 발생할 가능성이 있다.
• 하지만 ReentrantLock을 사용하면, 같은 Thread가 이미 Lock을 가지고 있더라도 Lock을 유지하며 계속 실행할 수 있기 때문에 Dead-Lock이 발생하지 않는다.
• 코드의 유연성을 높일 수 있다.

• ReentrantReadWriteLock
  • 읽기를 위한 Lock과 쓰기를 위한 Lock을 따로 제공한다.
  • 읽기에는 공유적이고, 쓰기에는 베타적인 Lock이다.
  • 읽기 Lock이 걸려있으면 다른 Thread들도 읽기 Lock을 중복으로 걸고 읽기를 수행할 수 있다. (read-only)
  • 읽기 Lock이 걸려있는 상태에서 쓰기 Lock을 거는 것은 허용되지 않는다.
• StampedLock
  • ReentrantReadWriteLock에 낙관적인 Lock의 기능을 추가했다.
    • 낙관적인 Lock : 데이터를 변경하기 전에 락을 걸지 않는 것을 의미한다.
    • 낙관적인 Lock을 사용하면 읽기와 쓰기 작업 모두가 빠르게 처리된다. → 여러 Thread가 동시에 변경하려고 할 때는 적합하지 않다.

Condition

• waiting pool 내 Thread를 구분하지 못한다는 것을 해결한 것이 Condition이다.
• Condition은 waiting pool 내의 Thread를 분리하여 특정 조건이 만족될 때만 깨우도록 할 수 있으며, ReentrantLock 클래스와 함께 사용된다.
• 따라서 Condition을 사용하면 wait( )과 notify( )의 문제점을 보완할 수 있다.

public class Main {
public static final int MAX_TASK = 5;

private ReentrantLock lock = new ReentrantLock();

// lock으로 condition 생성
private Condition condition1 = lock.newCondition();
private Condition condition2 = lock.newCondition();

private ArrayList<String> tasks = new ArrayList<>();

// 작업 메서드
public void addMethod(String task) {
			lock.lock(); // 임계영역 시작
	
			try {
				while(tasks.size() >= MAX_TASK) {
						String name = Thread.currentThread().getName();
						System.out.println(name+" is waiting.");
						try {
							condition1.await(); // wait(); condition1 쓰레드를 기다리게 합니다.
							Thread.sleep(500);
						} catch(InterruptedException e) {}	
				}
	
				tasks.add(task);
				condition2.signal(); // notify();  기다리고 있는 condition2를 깨워줍니다.
				System.out.println("Tasks:" + tasks.toString());
			} finally {
				lock.unlock(); // 임계영역 끝
			}
		}
	}

---

모던 자바 알아보기

• 시장에서 프로그래머가 해결해야 하는 문제는 계속 변화한다.
• 문제가 변화하기 때문에, 프로그래밍 언어에 요구되는 기능들도 변화한다.
• 예를 들어 C/C++ 같은 언어들은 프로그램 실행에 대한 비용이 크지 않고, 하드웨어적인 보편성, 호환성에 큰 장점을 가지고 있었기 때문에 시장에서 가장 지배적인 입지를 차지했었습니다.
• 하지만 특유의 난이도와 다른 요인들의 영향으로 예기치 않게 종료되거나, 보안 이슈가 많아지는 등 안정성이 떨어지게 됩니다.
• 그러던 와중에 하드웨어는 꾸준한 진화를 거듭했고, 그 진화의 결과로 프로그램을 실행시키는 자원을 더 많이 사용해도 괜찮은 환경에서는, 더 안정성이 높은 c#, java와 같은 언어들이 각광받게 됩니다.
• 이처럼 시장의 상황에 따라서 프로그래밍 언어는 새로운 대안으로 등장하고, 적응해서 살아남거나, 적응하지 못해서 도태되기도 합니다.

람다 익명함수

• 람다는 익명함수를 지칭하는 말이다.
• 일급 객체로 취급된다. → 일급 값(함수 = 객체(변수))으로 받는다는 것과 같은 맥락

스트림

• 데이터 처리연산을 지원하도록 소스에서 추출된 연속된 요소이다.
• 컬렉션의 반복을 멋지게 처리하는 일종의 기능이자, Multi Thread 관련 코드를 구현하지 않아도 알아서 병렬로 추가해주는 기능이다.

사용 예시 코드

package week05.thread.modern;

import java.util.ArrayList;
import java.util.List;

// 주차장 예제
// 티켓, 파킹머니 -> 주차하게 하는 예제
public class LambdaAndStream {
    public static void main(String[] args) {

        // 주차대상 차량
        ArrayList<Car> carsWantToPark = new ArrayList<>();

        // 주차장
        ArrayList<Car> parkingLot = new ArrayList<>();

        // 주말주차장
        ArrayList<Car> weekendParkingLot = new ArrayList<>();

        // 5개의 car instance
        Car car1 = new Car("Benz", "Class E", true, 0);
        Car car2 = new Car("BMW", "Series 7", false, 100);
        Car car3 = new Car("BMW", "X9", false, 0);
        Car car4 = new Car("Audi", "A7", true, 0);
        Car car5 = new Car("Hyundai", "Ionic 6", false, 10000);

        carsWantToPark.add(car1);
        carsWantToPark.add(car2);
        carsWantToPark.add(car3);
        carsWantToPark.add(car4);
        carsWantToPark.add(car5);



        //        parkingLot.addAll(parkingCarWithTicket(carsWantToPark));
        parkingLot.addAll(parkCars(carsWantToPark, Car::hasTicket));

        //        parkingLot.addAll(parkingCarWithMoney(carsWantToPark));
        parkingLot.addAll(parkCars(carsWantToPark, Car::noTicketHasMoney));

        // 익명함수 적용
        parkingLot.addAll(parkCars(carsWantToPark, (Car car) -> car.hasParkingTicket() && car.getParkingMoney() > 1000));

        for (Car car : parkingLot) {
            System.out.println("Parked Car : " + car.getCompany() + "-" + car.getModel());
        }


    }

    // 타입!!! -> (함수형) 인터페이스
    // 인터페이스는 타입 역할을 할 수 있기 때문! (멀티 리모컨 예제)
    // 함수형 인터페이스 : 추상 메서드를 딱 하나만 가지고 있다!
//    public exampleMethod (int parameter1, ??? parameterFunction) {
//        parameterFunction~~~
//    }

//    public static List<Car> parkingCarWithTicket(List<Car> carsWantToPark) {
//        ArrayList<Car> cars = new ArrayList<>();
//
//        for (Car car : carsWantToPark) {
//            if (car.hasParkingTicket()) {
//                cars.add(car);
//            }
//        }
//
//        return cars;
//    }
//
//    public static List<Car> parkingCarWithMoney(List<Car> carsWantToPark) {
//        ArrayList<Car> cars = new ArrayList<>();
//
//        for (Car car : carsWantToPark) {
//            if (!car.hasParkingTicket() && car.getParkingMoney() > 1000) {
//                cars.add(car);
//            }
//        }
//
//        return cars;
//
//    }

    // 위의 두 메서드를 하나로!! : 내부 주요 로직을 함수로 전달받자
    public static List<Car> parkCars(List<Car> carsWantToPark, Predicate<Car> function) {
        List<Car> cars = new ArrayList<>();

        for (Car car : carsWantToPark) {
            // 전달된 함수를 사용하여 구현
            if (function.test(car)) {
                cars.add(car);
            }
        }

        return cars;
    }
}

class Car {
    private final String company; // 자동차 회사
    private final String model; // 자동차 모델

    private final boolean hasParkingTicket;
    private final int parkingMoney;

    public Car(String company, String model, boolean hasParkingTicket, int parkingMoney) {
        this.company = company;
        this.model = model;
        this.hasParkingTicket = hasParkingTicket;
        this.parkingMoney = parkingMoney;
    }

    public String getCompany() {
        return company;
    }

    public String getModel() {
        return model;
    }

    public boolean hasParkingTicket() {
        return hasParkingTicket;
    }

    public int getParkingMoney() {
        return parkingMoney;
    }

    public static boolean hasTicket (Car car) {
        return car.hasParkingTicket;
    }

    public static boolean noTicketHasMoney (Car car) {
        return !car.hasParkingTicket && car.getParkingMoney() > 1000;
    }
}

interface Predicate<T> {
    boolean test(T t);
}

 

오늘 하루 정리✏️

하루종일 자바 강의 들으면서 실습만 했던 것 같다. Thread 부분은 어느 정도 이해가 됐는데 모던 자바에 있는 람다, 스트림에 대해서는 추가적으로 공부하면서 익혀야 할 것 같다!

오늘 5주차 숙제까지 끝내는 것이 목표였는데 강의를 너무 오래 들어서 내일 오전으로 미뤄야겠다.. 오전에는 숙제를 끝내는 것을 목표로 하고 오후부터는 추가 과제(키오스크)를 도전해야겠다!!

이번 일주일도 공부 열심히 하면서 잘 버틴 것 같다. 계속해서 성장하고 있고 이대로 지치지 않고 계속 해나간다면 좋은 성과를 얻을 수 있을 것 같다. 첫 번째 과제인 계산기 만들기에 대한 튜터님의 피드백을 오늘 확인했는데 생각보다 긍정적으로 피드백을 남겨주셔서 키오스크 과제에는 피드백을 반영해서 과제를 완성해야겠다!!

주말이라고 늘어지지 말고 적당히 공부하면서 쉬어가는 시간을 가져야지~~
이번 주도 고생했다..!!

 

내일 계획⏰

오전

• Java 문법 종합반_5주차 숙제 도전..!

오후

• 키오스크 과제 시작
• 인프런 강의 들으면서 부족한 부분 이해