[Java] 자바 쓰레드의 동기화

• 이 글은 "자바 온라인 스터디" 공부하여 작성한 글입니다.

쓰레드 동기화란?

멀티 쓰레드 프로그래밍에서 동기화 작업이 필수입니다. 쓰레드 동기화란 여러 쓰레드가 동일한 리소스를 공유하여 사용하게 되면 서로의 결과에 영향을 주기 때문에 방지하는 기법입니다.
쓰레드 동기화를 하기 위해서는 임계영역(critical section)과 락(lock)을 사용합니다. 임계영역으로 설정한 구역은 동시에 리소스를 사용할 수 없는 구역이고, 락을 획득한 쓰레드에 대해서만 리소스를 사용하도록 하는 방식입니다.

synchronized를 이용한 동기화

자바에서는 synchronized 키워드를 사용하여 임계영역을 지정하여 동시에 공유자원을 차지하지 않도록 강제합니다. synchronized를 사용하는 방법을 메소드 자체에 적용하거나, 코드 블록에 적용할 수 있습니다.

• 메소드 전체를 임계영역을 지정 : 메소드 선언 시에 synchronized 키워드 추가, 이 메소드가 호출되면 메소드를 가지고 있는 객체에 대한 락을 획득하여 작업을 수행하다가 메소드 종료되면 락을 반납합니다.

• 특정 영역만 임계영역을 지정 : synchronized 키워드로 시작하는 블록으로 지정, 특정 객체를 지정하여 블록 내에서 객체에 대한 락을 획득하고 블록을 벗어나면 락을 반납합니다.

 

synchronized 실습 코드

• 참조(https://kyun2.tistory.com/12)

public class Student {

    int bookCount = 5;      // 공유 자원

    public int getBookCount() {
        return bookCount;
    }

    public void setBookCount(int bookCount) {
        this.bookCount = bookCount;
    }

    public void borrowBook() throws InterruptedException {
        int m = bookCount;
        Thread.sleep(2000);
        bookCount = m+1;
        System.out.println("대출완료");
    }

    public void returnBook() throws InterruptedException {
        int m = bookCount;
        Thread.sleep(3000);
        bookCount = m-1;
        System.out.println("반납완료");
    }
}

public class Library {
    public  static Student student = new Student();
}

public class BorrowThread extends Thread{
    @Override
    public void run() {
        try {
            Library.student.borrowBook();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("학생이 빌린 총 책의 갯수 : "+Library.student.getBookCount());
    }
}

public class ReturnThread extends Thread{
    @Override
    public void run() {
        try {
            Library.student.returnBook();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("학생이 빌린 총 책의 갯수 : "+Library.student.getBookCount());
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("현재 대출한 책의 갯수 : "+Library.student.getBookCount());

        BorrowThread bt = new BorrowThread();
        ReturnThread rt = new ReturnThread();

        bt.setPriority(10);
        bt.start();
        rt.start();

        try{
            bt.join();
            rt.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

다음 예제는 동기화를 하지 않아서 문제가 되는 코드입니다. 코드를 보고 어느 지점에서 문제가 생길지 안다면 동기화에 대해 이미 어느정도 알고 계신겁니다.

실행 결과를 보면 학생이 현재 대출한 책은 총 5권이었습니다. 그리고 한 권을 대출한 후 반납을 하여 현재 학생이 빌린 책의 갯수는 처음과 동일해야 합니다. 하지만 대출하고 난 후 책은 6권이 되었지만, 반납을 하니 5권이 아닌 4권이 되었습니다.

    public void borrowBook() throws InterruptedException {
        int m = bookCount;
        Thread.sleep(2000);
        bookCount = m+1;
        System.out.println("대출완료");
    }

    public void returnBook() throws InterruptedException {
        int m = bookCount;
        Thread.sleep(3000);
        bookCount = m-1;
        System.out.println("반납완료");
    }

원인을 분석해 보자면, BorrowThread는 borrowBook 메소드를 호출하고 ReturnThread는 returnBook 메소드를 동시에 호출합니다. 그에 따라, 지역변수 m에는 현재 bookCount인 5가 모두 대입이 되고, 몇 초간의 딜레이 후 bookCount에 값을 대입하기 때문에 +1일 때는 6이되고 -1일 때는 4가 되는 것입니다.
이를 방지하기 위해서는 synchronized 키워드로 임계영역을 지정하여 동기화를 해야 합니다.

    public synchronized void borrowBook() throws InterruptedException {
        int m = bookCount;
        Thread.sleep(2000);
        bookCount = m+1;
        System.out.println("대출완료");
    }

    public synchronized void returnBook() throws InterruptedException {
        int m = bookCount;
        Thread.sleep(3000);
        bookCount = m-1;
        System.out.println("반납완료");
    }

Student의 메소드인 boroowBook과 returnBook에 synchronized 키워드를 추가하였습니다. 이 메소드를 호출할 경우에는 Student객체에 대한 락을 얻고 락을 얻지 못한 객체는 락을 반납할 때까지 기다려야 합니다.
따라서, borrowThread가 먼저 Student 객체 락을 획득하고 borrowBook 메소드를 실행합니다. 메소드가 종료되어 락이 반납된 이후 ReturnThread의 returnBook 메소드가 호출됩니다.

실행 결과 원하는 결과를 얻을 수 있습니다.

    public void borrowBook() throws InterruptedException {
        synchronized (this){
            int m = bookCount;
            Thread.sleep(2000);
            bookCount = m+1;
            System.out.println("대출완료");
        }
    }

    public void returnBook() throws InterruptedException {
        synchronized (this){
            int m = bookCount;
            Thread.sleep(3000);
            bookCount = m-1;
            System.out.println("반납완료");
        }
    }

멀티 쓰레드 프로그래밍에서 임계 영역은 성능을 좌우하기 때문에 가능하면 메소드 전체 락을 거는 것보다는 synchronized 블럭으로 임계영역을 최소화해서 효율적인 프로그램을 작성하는 것이 좋습니다.

 

wait(), notify() 동기화

• 참조(https://kyun2.tistory.com/12)

public class Student {

    int bookCount = 0;      // 공유 자원

    public int getBookCount() {
        return bookCount;
    }

    public void setBookCount(int bookCount) {
        this.bookCount = bookCount;
    }

    public synchronized void borrowBook() throws InterruptedException {
        if(bookCount>=10){
            try{
                System.out.println("10권 초과로 대출할 수 없습니다");
            }catch (Exception e){

            }
        }
        int m = bookCount;
        bookCount = m+1;
        System.out.println("책 대출 성공. 대출한 책의 갯수 : "+bookCount);
    }

    public synchronized void returnBook() throws InterruptedException {
        if(bookCount<=0){
            try{
                System.out.println("반납할 책이 없습니다");
            }catch (Exception e){

            }
        }
        int m = bookCount;
        bookCount = m-1;
        System.out.println("책 반납 성공. 대출한 책의 갯수 : "+bookCount);
    }
}

public class Library {
    public  static Student student = new Student();
}

public class BorrowThread extends Thread{
    @Override
    public void run() {
        for(int i=0;i<30;i++){
            try {
                Library.student.borrowBook();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ReturnThread extends Thread{
    @Override
    public void run() {

        for(int i=0;i<30;i++){
            try {
                Library.student.returnBook();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("현재 대출한 책의 갯수 : "+Library.student.getBookCount());

        BorrowThread bt = new BorrowThread();
        ReturnThread rt = new ReturnThread();

        bt.setPriority(10);
        bt.start();
        rt.start();

        try{
            bt.join();
            rt.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

다음 코드는 synchronized 키워드로 동기화가 되어 있기 때문에 대출한 책의 수가 10권이 넘더라도 BorrowThread가 종료된 후에 ReturnThread가 실행되는 것을 확인할 수 있었습니다.
제가 원하는 결과는 최대 빌릴 수 있는 수는 10권이고 10권을 이미 빌렸을 경우 반납부터 진행하도록 하고 싶었습니다. 그렇게 하기 위해서는 빌린 책의 수가 10권이 되면 락을 반납하여 ReturnThread가 실행되도록 하는 방법입니다. 또한, 반납할 책의 수가 없다면 대출이 가능하도록 BorrowThread에게 락을 주는 방법입니다.

    public synchronized void borrowBook() throws InterruptedException {
        if(bookCount>=10){
            try{
                System.out.println("10권 초과로 대출할 수 없습니다");
                wait();
            }catch (Exception e){

            }
        }
        int m = bookCount;
        bookCount = m+1;
        System.out.println("책 대출 성공. 대출한 책의 갯수 : "+bookCount);
        notify();
    }

    public synchronized void returnBook() throws InterruptedException {
        if(bookCount<=0){
            try{
                System.out.println("반납할 책이 없습니다");
                wait();
            }catch (Exception e){

            }
        }
        int m = bookCount;
        bookCount = m-1;
        System.out.println("책 반납 성공. 대출한 책의 갯수 : "+bookCount);
        notify();
    }

다음과 같이 코드를 수정하게 되면 10권 초과로 대출할 수 없고 0권이 되면 반납할 수 없도록 하였습니다.