synchronized! 동적 정적 include!

[olrlobt]

👍 문제

24장 정리된 내용을 보다보니, 웬걸! 배운 것 같은 내용인데 머릿속에 ?가 가득 생겼다.

필요한부분에synchronized 블록을사용하였는가?
그냥 동시에해당메서드가 호출될것같아서synchronized 블록을사용한
것은아닌지확인해야한다. 필요없는부분에synchronized 블록을사용하 게될 경우 성능저하를발생시킬수있다.

JSP의include는동적으로했는가?아니면정적으로했는가?
JSP를 동적으로include하면 서버에도 부하를줄 뿐만아니라 응답 시간에
도영향을준다. 꼭필요한부분에만동적include를하기바라며, 그렇지않 은 경 우 에 는 정 적 i n c l u d e 의 사 용 을 권 장 한 다 . 그렇 다 고 무 조 건 정 적 으 로
include 를하면변수를 공유하게되어예기치못한문제가발생할수 있으므 로 유 의 해 서 사 용 하 기 바 란 다.

위 내용들을 예제와 함께 이유를 설명해주면 좋을 것 같다!

✈️ 선정 배경

내 머릿속의 지우개

📺 관련 챕터 및 레퍼런스

관련 챕터와 출처를 적어주세요

story. 24 425p.

🐳 비고

[KIMSEI1124]

들어가며

Java를 공부할 때 synchronized 키워드가 존재하는 것은 알고 있었습니다! 하지만 딱히 사용하지 않아 자세히 몰랐는데 해당 기회가 되어서 조사를 해보았습니다.

Synchronized

자바에서 멀티스레드를 이용하면 여러작업을 동시에 처리할 수 있기 때문에 작업효율이 좋아집니다. 하지만 하나의 공유자원을 여러 스레드에서 동시에 접근하여 사용하게 되면 때때로 예상치 못한 결과가 나타나게 됩니다. 이러한 문제를 해결하기 위해 사용되는 synchronized 에 대해서 알아보겠습니다.

자바에서 지원하는 synchroized 키워드는 여러개의 스레드가 한개의 자원을 사용하고자 할 때, 현재 데이터를 사용하고 있는 해당 스레드를 제외하고 나머지 스레들은 데이터에 접근 할 수 없도록 막는 개념입니다.

해당 키워드는 변수나 함수에 사용해서 동기화할 수 있습니다. 하지만 Synchroinzed 를 남발하면 오히려 프로그램 성능저하를 일으킬 수 있습니다. 그 이유는 자바 내부적으로 메서드나 변수에 동기화를 하기 위해 block 와 unblock 을 처리하게 되는데 이런 처리가 많이지게 되면 오히려 프로그램 성능저하를 일으킬 수 있습니다.

사용 방법

Non Synchronized

---

먼저 synchronized 가 필요한 이유를 예제 코드로 알아보도록 하겠습니다.

Main

package thread;  

import thread.obj.Task;  

public class SynchronizedStudy {  
    public static void main(String[] args) {  
        Task task = new Task();  
        Thread threadOne = new Thread(task);  
        Thread threadTwo = new Thread(task);  

        threadOne.setName("Thread One");  
        threadTwo.setName("Thread Two");  

        threadOne.start();  
        threadTwo.start();  
    }  
}

Task 를 초기화 한 뒤 Thread를 2개 생성하였습니다. 각 스레드의 이름을 설정한 뒤 실행하였습니다.

Task

package thread.obj;  

import java.util.Random;  

public class Task implements Runnable {  

    private final Random random;  
    Account account = new Account();  

    public Task() {  
        random = new Random();  
        random.setSeed(System.currentTimeMillis()); // `seed`를 랜덤으로 설정  
    }  

    @Override  
    public void run() {  
        while (account.canWithDraw()) {  
            int money = (random.nextInt(3) + 1) * 100;  
            account.withDraw(money);  
        }  
    }  
}

Task 스레드입니다. Runnable 를 implements 하여 run() 을 Override 하였습니다. Money를 100, 200, 300 중 하나의 값을 가져와 Account의 withDraw를 실행합니다.

Account

package thread.obj;  

public class Account {  
    private int balance = 1000;  

    public void withDraw(int money) {  
        if (canWithDrawByMoney(money)) {  
            try {  
                String threadName = Thread.currentThread().getName();  
                System.out.println(threadName + ") 출금 금액 : [" + money + "]");  
                Thread.sleep(1000);  
                balance -= money;  
                System.out.println(threadName + ") balance : [" + balance + "]");  
            } catch (InterruptedException e) {  
                System.out.println(e.getMessage());  
                Thread.currentThread().interrupt();  
            }  
        }  
    }  

    private boolean canWithDrawByMoney(int money) {  
        return balance >= money;  
    }  

    public boolean canWithDraw() {  
        return balance > 0;  
    }  
}

단순히 balance 를 money 만큼 줄여주는 단계 입니다.

실행 결과

Thread One) 출금 금액 : [100]
Thread Two) 출금 금액 : [100]
Thread Two) balance : [900]
Thread Two) 출금 금액 : [300]
Thread One) balance : [800]
Thread One) 출금 금액 : [100]
Thread One) balance : [700]
Thread One) 출금 금액 : [300]
Thread Two) balance : [400]
Thread Two) 출금 금액 : [300]
Thread One) balance : [100]
Thread One) 출금 금액 : [100]
Thread Two) balance : [-200]
Thread One) balance : [-300]

결과 화면을 보면 잔액이 0이 될 때까지 출금을 해야하는데 잔액이 마이너스가 되었습니다.

여기서 멀티스레드의 문제점이 발견되었습니다. 이러한 이유로 thread-safe하기 위해서 synchronized 키워드를 사용하게됩니다.

Synchronized

---

공유데이터에 대한 접근과 수정이 이루어지는 메서드에 synchronized 키워드를 리턴타입 앞에 붙여 주면 위의 예제는 해결할 수 있습니다.

package thread.obj;  

public class Account {  
    private int balance = 1000;  

    public synchronized void withDraw(int money) {  
        if (canWithDrawByMoney(money)) {  
            try {  
                String threadName = Thread.currentThread().getName();  
                System.out.println(threadName + ") 출금 금액 : [" + money + "]");  
                Thread.sleep(1000);  
                balance -= money;  
                System.out.println(threadName + ") balance : [" + balance + "]");  
            } catch (InterruptedException e) {  
                System.out.println(e.getMessage());  
                Thread.currentThread().interrupt();  
            }  
        }  
    }

  ...
}

실행 결과

Thread One) 출금 금액 : [100]
Thread One) balance : [900]
Thread One) 출금 금액 : [200]
Thread One) balance : [700]
Thread Two) 출금 금액 : [200]
Thread Two) balance : [500]
Thread Two) 출금 금액 : [100]
Thread Two) balance : [400]
Thread Two) 출금 금액 : [200]
Thread Two) balance : [200]
Thread Two) 출금 금액 : [200]
Thread Two) balance : [0]

synchronized를 사용하여 thread-safe를 시켰기 때문에 데이터나 메서드 점유하고 있는 스레드가 온전히 자신의 작업일 마칠 수 이습니다.

사용 가능한 블록

synchronized 키워드는 다음과 같은 유형에서 사용할 수 있습니다.

• 인스턴스 메소드
• 스태틱 메소드
• 인스턴스 메소드 코드 블럭
• 스태틱 메소드 코드 블럭

인스턴스 메소드

---

위의 예제에서 사용한 방식입니다.

인스턴스 메소드의 동기화는 이 메소드를 가진 인스턴스를 기준으로 이루어집니다. 그러므로, 한 클래스가 동기화된 인스턴스 메소드를 가진다면, 여기서 동기화는 이 클래스의 한 인스턴스를 기준으로 이루어집니다. 그리고 한 시점에 오직 하나의 쓰레드만이 동기화된 인스턴스 메소드를 실행할 수 있습니다.

정리하면 둘 이상의 인스턴스가 있다면, 한 시점에 한 인스턴스에 한 쓰레드만 이 메소드를 실행시킬 수 있습니다.

스태틱 메소드

---

스태틱 메소드의 동기화는 인스턴스 메소드와 같은 방식으로 이루어지지만 JVM안에 클래스 객체는 클래스당 하나만 존재할 수 있으므로, 같은 클래스에 대해서 오직 한 쓰레드만 스태틱 메소드를 실행할 수 있습니다.

만일 동기화된 스태틱 메소드가 다른 클래스에 각각 존재한다면, 쓰레드는 각 클래스의 메소드를 실행할 수 있습니다.

package thread.obj;  

public class Account {  
    private static int balance = 1000;  

    public static synchronized void withDraw(int money) {  
        if (canWithDrawByMoney(money)) {  
            try {  
                String threadName = Thread.currentThread().getName();  
                System.out.println(threadName + ") 출금 금액 : [" + money + "]");  
                Thread.sleep(1000);  
                balance -= money;  
                System.out.println(threadName + ") balance : [" + balance + "]");  
            } catch (InterruptedException e) {  
                System.out.println(e.getMessage());  
                Thread.currentThread().interrupt();  
            }  
        }  
    }  

    ...
}

인스턴스 메소드 안의 동기화 블록

---

메소드 안에 동기화 블록을 따로 작성할 수 있습니다.

동기화 블록이 괄호 안에 한 객체를 전달받고 있습니다. 예제에서는 this가 사용되었는데 withDraw() 메소드가 호출된 객체를 의미합니다. 이 동기화 블록 안에 전달된 객체를 모니터 객체라 합니다. 이 코드는 모니터 객체를 기준으로 동기화가 이루어지고 있습니다.

같은 모니터 객체를 기준으로 동기화된 블록 안의 코드를 오직 한 쓰레드만이 실행할 수 있습니다.

package thread.obj;  

public class Account {  
    private int balance = 1000;  

    public void withDraw(int money) {  
        synchronized (this) {  
            if (canWithDrawByMoney(money)) {  
                try {  
                    String threadName = Thread.currentThread().getName();  
                    System.out.println(threadName + ") 출금 금액 : [" + money + "]");  
                    this.wait(1000);  
                    balance -= money;  
                    System.out.println(threadName + ") balance : [" + balance + "]");  
                } catch (InterruptedException e) {  
                    System.out.println(e.getMessage());  
                    Thread.currentThread().interrupt();  
                }  
            }  
        }  
    }  

    ...
}

💫 Info SonarLint 정적 코드 분석 도구에서는 인스턴스 메소드 방법보다는 인스턴스 메소드 안의 동기화 블럭을 권장하고 있습니다.

스태틱 메소드 안의 동기화 블록

---

package thread.obj;  

public class Account {  
    private static int balance = 1000;  

    public static void withDraw(int money) {  
        synchronized (Account.class) {  
            if (canWithDrawByMoney(money)) {  
                try {  
                    String threadName = Thread.currentThread().getName();  
                    System.out.println(threadName + ") 출금 금액 : [" + money + "]");  
                    Thread.sleep(1000);  
                    balance -= money;  
                    System.out.println(threadName + ") balance : [" + balance + "]");  
                } catch (InterruptedException e) {  
                    System.out.println(e.getMessage());  
                    Thread.currentThread().interrupt();  
                }  
            }  
        }  
    }  

    private static boolean canWithDrawByMoney(int money) {  
        return balance >= money;  
    }  

    public boolean canWithDraw() {  
        return balance > 0;  
    }  
}

위와의 차이는 static 을 사용하였기 때문에 class를 넣어야 합니다.

성능 문제

그럼 본론으로 돌아와서 synchronized 가 성능저하를 일으키는 이유에 대해서 알아보겠습니다.

• Contention의 증가 : 여러 스레드가 하나의 synchronized 블록을 경합하여 접근하려고 할 때, 경합이 발생할 수 있습니다. 이로 인해 스레드가 대기하고 경합을 해결하기 위해 시스템 리소스가 낭비됩니다.
• Context Switching 비용 : synchronized 블록에서 스레드 간의 경합이 발생하면 스레드가 대기 상태로 전환되고 다른 스레드로 전환됩니다. 이러한 문맥 전환 비용은 성능을 저하시킵니다.
• Double Lock 문제 : synchronized 블록을 중첩하여 사용하거나 클래스 수준에서 synchronized 블록을 사용하면 더블 락 문제가 발생할 수 있으며, 이는 성능 저하의 원인이 될 수 있습니다.

public void withDraw(int money) {  
    synchronized (this) {  
        if (canWithDrawByMoney(money)) {  
            try {  
                String threadName = Thread.currentThread().getName();  
                    System.out.println(threadName + ") 출금 금액 : [" + money + "]");  
                    Thread.sleep(1000);  
                    balance -= money;  
                    System.out.println(threadName + ") balance : [" + balance + "]");  
                    doubleLock();  
                } catch (InterruptedException e) {  
                    System.out.println(e.getMessage());  
                    Thread.currentThread().interrupt();  
            }  
        }  
    }  
}  

private void doubleLock() {  
    synchronized (this) {  
        try {  
            Thread.sleep(1000);  
        } catch (InterruptedException e) {  
            System.out.println(e.getMessage());  
            Thread.currentThread().interrupt();  
        }  
    }  
}

정리

실제로 실무에서는 synchronized를 많이 사용하지 않는데 이 방법은 성능에 치명적이기 때문입니다. 따라서 synchronized 사용은 지양해야합니다. 동시성을 보장해야 하는 경우에는 자바가 제공하는 thread-safe한 자료구조를 사용해야합니다. (ConcurrentHashMap, BlockingQueue 등)

JSP 동적 Include?!, 정적 Include?!

JSP의 include는 동적으로도할 수 있고 정적으로도 할 수 있습니다.

그러면 각 방식에 대한 장점과 단점을 알아보도록 하고 어떠한 방식을 사용해야하는 지 고려 사항을 작성해보겠습니다.

Static Include

JSP 페이지를 서버에서 컴파일 할 때, include된 내용을 해당 위치에 정적으로 삽입합니다.

이 방식은 jsp:include 또는 <%@ include %> 디렉티브를 사용하여 구현합니다.

이 방식에 대한 장단점은 다음과 같습니다.₂₎

1. 이는 서버에서 부하를 덜 주지만, 모든 페이지를 불필요하게 재 컴파일해야 할 수 있으며, 동적으로 데이터를 전달하기 어렵습니다.
2. include 페이지에 선언한 변수를 부모페이지에서 별도의 변수 선언없이 사용이 가능하지만 부모 페이지에 include한 파일이 많을경우 include 페이지에서 선언된 변수를 추적해야할 유지보수할 때 힘듭니다.
3. JSP 파일에 html이 많아지고 Java 로직도 많아지면 라인 수가 늘어나게 되는데 이 때 모든 부분을 정적으로 할당하면 아래와 같은 에러로그를 만날 수 있습니다.₁₎ Generated servlet error: The code of method _jspService(HttpServletRequest, HttpServletResponse) is exceeding the 65535 bytes limit 정적 include 방법을 활용하여 10,000라인 정도 넘어가면 해당 에러를 만나게 될 수 있습니다.

Dynamic Include

JSP 페이지가 실행될 때, include 된 내용을 동적으로 실행하고 페이지의 실행 흐름 중에 다른 JSP 페이지를 포함시킵니다. 이 방식은 <jsp:include> 또는 Java 코드를 사용하여 구현합니다.

이 방식에 대한 장단점은 다음과 같습니다.₂₎

1. 이는 동적 데이터와 변수를 공유할 수 있어 유연하게 콘텐츠를 조합할 수 있지만, 서버에 부하를 더 많이 줄 수 있으며 응답 시간에 영향을 미칠 수 있습니다.
2. 부모페이지와 include 페이지는 변수를 공유하지 않으므로 유지 보수시 편합니다. 하지만 부모페이지에서 include한 파일에서 변수를 사용시 <jsp:param name="userName" value="<%=userName%>"/>와 같이 부모페이지에서 지정해 주어야 합니다.

고려 사항

1. 부하 관리 동적 include는 서버 부하를 증가시킬 수 있으므로, 꼭 필요한 부분에만 동적 include를 사용해야 합니다. 정적 include는 일반적으로 서버 부하에 영향을 미치지 않습니다.
2. 응답 시간 동적 include가 많이 사용될 경우, 응답 시간이 느려질 수 있습니다. 이를 최소화하려면 적절한 캐싱 전략을 고려해야 합니다.
3. 변수 공유 동적 include를 사용하면 변수를 공유할 수 있으므로, 예기치 못한 문제가 발생할 수 있습니다. 변수를 공유할 수 있으므로, 예기치 못한 문제가 발생할 수 있습니다. 변수의 스코프와 충돌을 방지하기 위해 변수명을 신중하게 선택하고, 변수 스코프를 제어하는 방법을 이해해야 합니다.
4. 유연성 동적 include를 사용하면 동적 데이터를 페이지에 포함시킬 수 있으므로, 유연성이 향상됩니다. 이를 통해 동적으로 페이지를 구성하고 다양한 콘텐츠를 생성할 수 있습니다.

Ref

1. [JSP] include 제대로 알고 쓰기 (동적, 정적)
2. [JSP] 정적, 동적 include
3. java - synchronized 란? 사용법?
4. 자바 - Synchronized 스레드 동기화 개념 및 사용예제
5. Java의 Synchronized 키워드

추가적으로 공부하면 좋은 블로그

1. Java - synchronized 동기화
2. synchronized와 Moniter
3. Synchronized 키워드