Java에서 동기화 키워드를 사용하는 방법을 이해하는 예

이 기사에서는 java에 대한 관련 지식을 제공하며 동기화 방법의 사용, 동기화 문 또는 블록의 사용, 동기화란 무엇인지, 동기화가 필요한 이유를 포함하여 동기화 키워드와 관련된 문제를 주로 소개합니다. 아래 내용을 보시고 모든 분들께 도움이 되었으면 좋겠습니다.

추천 학습: "java 비디오 튜토리얼"

일상 개발에서 동기화 키워드를 자주 접하게 됩니다. 이번 글에서는 이를 소개하겠습니다.

동기화를 사용하는 방법에는 두 가지가 있습니다.

• 동기화된 메서드 사용
• 동기화된 문 또는 블록 사용

동기화된 메서드 사용

메서드를 동기화하려면 해당 선언에 동기화 키워드를 추가하기만 하면 됩니다.

public class SynchronizedDemo {

    private int i = 0;

    public synchronized void add() {
        i++;
    }

    public synchronized void del() {
        i--;
    }

    public synchronized int getValue() {
        return i;
    }
}

위 코드에서 볼 수 있듯이 세 가지 동기화 방법이 있습니다.

• add()
• del()
• getValue()

각 방법은 동일한 객체에 대해 동시에 한 번만 호출됩니다. 예를 들어 스레드가 add()를 호출하면 첫 번째 스레드가 add() 메서드 처리를 완료할 때까지 다른 스레드가 차단됩니다.

동기화 문 또는 블록 사용

    public void del(int value){

        synchronized(this){
            this.i -= value;
        }
    }

위 코드에서 동기화는 동기화 코드 블록을 나타내는 {} 코드 앞에 추가됩니다.

위는 동기화 키워드를 사용하는 두 가지 방법입니다. 동기화와 관련된 개념을 간략하게 소개하겠습니다.

동기화란 무엇인가요?

동기화는 공유 리소스에 액세스하는 여러 스레드를 제어하여 일관되지 않은 결과를 방지하는 프로세스입니다. 동기화를 사용하는 주요 목적은 스레드의 일관되지 않은 동작을 방지하고 스레드 간섭을 방지하는 것입니다.

Java에서 동기화 키워드를 사용하면 동기화 효과를 얻을 수 있습니다. 동기화는 변수와 클래스가 아닌 메소드와 블록에만 적용할 수 있습니다.

왜 동기화가 필요한가요?

먼저 코드를 살펴보겠습니다.

public class SynchronizedDemo {

    int i;

    public void increment() {
        i++;
    }

    public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();
        synchronizedDemo.increment();
        System.out.println("计算值为：" + synchronizedDemo.i);
    }
}

increment() 메소드가 호출될 때마다 계산된 값은 1씩 증가합니다.

2번 호출하면 2가 추가되고, 호출되면 2가 추가됩니다. 3번 호출하면 3번이 추가되고 4번 호출되면 3번이 추가됩니다.

public class SynchronizedDemo {

    int i;

    public void increment() {
        i++;
    }

    public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();
        synchronizedDemo.increment();
        synchronizedDemo.increment();
        synchronizedDemo.increment();
        synchronizedDemo.increment();
        System.out.println("计算值为：" + synchronizedDemo.i);
    }
}

이제 위의 예를 확장하고 increment() 메서드를 10번 호출하는 스레드를 만들어 보겠습니다.

public class SynchronizedDemo {

    int i;

    public void increment() {
        i++;
    }

    public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();
        Thread thread = new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                synchronizedDemo.increment();
            }
        });
        thread.start();
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("计算值为：" + synchronizedDemo.i);
    }
}

이번 계산 결과는 예상대로 10이 나왔습니다.

싱글스레드 상황이라 모든게 너무 좋은데 과연 그럴까요? 멀티스레드 환경이라면 어떤 모습일까요?

아래에서 멀티스레딩 상황을 보여드리겠습니다!

public class SynchronizedDemo {

    int i;

    public void increment() {
        i++;
    }

    public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();

        Thread thread1 = new Thread(() -> {
            for (int i = 1; i <= 1000; i++) {
                synchronizedDemo.increment();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 1; i <= 1000; i++) {
                synchronizedDemo.increment();
            }
        });

        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("计算值为：" + synchronizedDemo.i);
    }
}

위 코드에서 볼 수 있듯이 thread1과 thread2 두 개의 스레드를 생성했습니다. 각 스레드는 increment()를 1000번 호출합니다. 이론적으로 최종 인쇄된 값은

2000이어야 합니다. 왜냐하면 thread1이 increment(를 호출한 후에 값이 변경되기 때문입니다. ) 1000번은 1000이 됩니다. thread2가 increment()를 1000번 호출하면 값은 2000이 됩니다.

실행해서 결과를 확인해 보겠습니다.

결과가 생각한 것과 다릅니다. 2000. 다시 실행해 보겠습니다.

결과가 여전히 2000보다 작습니다.

이게 왜일까요?

멀티스레딩은 병렬 처리를 지원하므로 두 스레드가 동시에 카운터 값을 얻는 것이 항상 가능하므로 둘 다 동일한 카운터 값을 얻습니다. 따라서 이 경우에는 값을 증가시키는 대신 카운터가 두 번이면 한 번만 증가합니다.

그럼, 이런 상황을 피하는 방법은 무엇일까요?

동기화 키워드를 이용해 풀어보세요.

increment() 메소드에 동기화만 추가하면 됩니다:

public class SynchronizedDemo {

    int i;

    public synchronized void increment() {
        i++;
    }

    public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();

        Thread thread1 = new Thread(() -> {
            for (int i = 1; i <= 1000; i++) {
                synchronizedDemo.increment();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 1; i <= 1000; i++) {
                synchronizedDemo.increment();
            }
        });

        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("计算值为：" + synchronizedDemo.i);
    }
}

이번에 다시 실행해 보겠습니다:

값이 2000인 것을 볼 수 있습니다.

계산 횟수를 10,000으로 늘립니다. times :

public class SynchronizedDemo {

    int i;

    public synchronized void increment() {
        i++;
    }

    public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();

        Thread thread1 = new Thread(() -> {
            for (int i = 1; i <= 10000; i++) {
                synchronizedDemo.increment();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 1; i <= 10000; i++) {
                synchronizedDemo.increment();
            }
        });

        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("计算值为：" + synchronizedDemo.i);
    }
}

실행 결과는 다음과 같습니다.

조금 동기화하면 이 문제가 아주 쉽게 해결되는 것을 볼 수 있습니다.

이 원칙은 스레드 1이 increment() 메서드를 실행할 때 이 메서드가 동기화되기 때문에 자동으로 잠긴다는 것입니다. 이때 스레드 1만 잠금을 소유하고 다른 스레드는 스레드 1이 잠금을 해제할 때까지만 기다릴 수 있습니다. 잠금을 잠근 후에만 스레드 2가 호출에 참여할 수 있습니다.

마찬가지로 스레드 2가 increment()를 호출하면 스레드 2가 잠금을 획득하고 스레드 1은 스레드 2가 잠금을 해제할 때까지 기다립니다. 이러한 방식으로 계산이 완료될 때까지 이 프로세스에서는 계산 오류가 발생하지 않습니다.

Summary

• synchronized 키워드는 블록이나 메소드를 동기화하는 유일한 방법입니다.
• Synchronized 키워드는 스레드 간에 경쟁 조건이 발생하지 않도록 하는 잠금 기능을 제공합니다. 잠긴 후 스레드는 주 메모리에서만 데이터를 읽을 수 있으며 데이터를 읽은 후 잠금을 해제하기 전에 쓰기 작업을 플러시합니다.
• synchronized 키워드는 프로그램 명령문의 재정렬을 방지하는 데에도 도움이 됩니다.

추천 학습: "java 비디오 튜토리얼"

위 내용은 Java에서 동기화 키워드를 사용하는 방법을 이해하는 예의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!