7. Synchronized 키워드에 대해 설명해 주세요.

[KIMSEI1124]

• Synchronized 키워드가 어디에 붙는지에 따라 의미가 약간씩 변화하는데, 각각 어떤 의미를 갖게 되는지 설명해 주세요.
• 효율적인 코드 작성 측면에서, Synchronized는 좋은 키워드일까요?
• Synchronized 를 대체할 수 있는 자바의 다른 동기화 기법에 대해 설명해 주세요.
• Thread Local에 대해 설명해 주세요.

[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 키워드