Java에서 동기화를 사용하는 방법

synchronized는 Java의 키워드이며 일종의 동기화 잠금입니다. 수정하는 개체는 다음과 같습니다.
1. 코드 블록을 수정합니다. 수정된 코드 블록은 중괄호 {}로 묶인 코드입니다. 코드 블록의 객체;
2. 메소드 수정. 수정된 메소드를 동기화 메소드라고 하며, 해당 메소드가 작동하는 객체는
3. 정적 메서드 수정, 해당 작업 범위는 전체 정적 메서드이고 대상은 이 클래스의 모든 개체입니다.
4. 클래스 수정, 해당 작업 범위는 동기화 후 괄호로 묶인 부분입니다. 주요 개체는 이 클래스의 모든 개체입니다.

코드 블록 수정

스레드가 객체의 동기화된(this) 동기화 코드 블록에 액세스하면 해당 객체에 액세스하려는 다른 스레드가 차단됩니다. 다음 예를 살펴보겠습니다.

[Demo1]: 동기화 사용

/**
 * 同步线程
 */class SyncThread implements Runnable {   private static int count;   public SyncThread() {
      count = 0;
   }   public  void run() {      synchronized(this) {         for (int i = 0; i < 5; i++) {            try {
               System.out.println(Thread.currentThread().getName() + ":" + (count++));
               Thread.sleep(100);
            } catch (InterruptedException e) {
               e.printStackTrace();
            }
         }
      }
   }   public int getCount() {      return count;
   }
}

SyncThread 호출:

SyncThread syncThread = new SyncThread();
Thread thread1 = new Thread(syncThread, "SyncThread1");
Thread thread2 = new Thread(syncThread, "SyncThread2");
thread1.start();
thread2.start();

결과는 다음과 같습니다.

SyncThread1:0 
SyncThread1:1 
SyncThread1:2 
SyncThread1:3 
SyncThread1:4 
SyncThread2:5 
SyncThread2:6 
SyncThread2:7 
SyncThread2:8 
SyncThread2:9*

두 개의 동시 스레드(thread1 및 thread2)가 동일한 객체(syncThread)의 동기화된 코드 블록에 액세스하면 동시에 하나의 스레드만 실행될 수 있으며 다른 스레드는 차단되어 대기해야 합니다. 현재 스레드는 실행을 완료합니다. 이 코드 블록은 나중에 실행될 수 있습니다. Thread1과 thread2는 동기화된 코드 블록이 실행될 때 현재 개체가 잠겨 있기 때문에 상호 배타적입니다. 개체 잠금은 코드 블록이 실행된 후에만 해제될 수 있으며 다음 스레드가 개체를 실행하고 잠글 수 있습니다.
SyncThread에 대한 호출을 살짝 변경해 보겠습니다.

Thread thread1 = new Thread(new SyncThread(), "SyncThread1");
Thread thread2 = new Thread(new SyncThread(), "SyncThread2");
thread1.start();
thread2.start();

결과는 다음과 같습니다.

SyncThread1:0 
SyncThread2:1 
SyncThread1:2 
SyncThread2:3 
SyncThread1:4 
SyncThread2:5 
SyncThread2:6 
SyncThread1:7 
SyncThread1:8 
SyncThread2:9

한 스레드가 동기화된 코드 블록을 실행하면, 다른 스레드가 차단되었나요? 위 예에서 thread1과 thread2가 동시에 실행되는 이유는 무엇입니까? 동기화는 객체만 잠그고, 각 객체에는 그에 연관된 잠금(lock)이 하나만 있기 때문이며, 위의 코드는 다음 코드와 동일합니다.

SyncThread syncThread1 = new SyncThread();
SyncThread syncThread2 = new SyncThread();
Thread thread1 = new Thread(syncThread1, "SyncThread1");
Thread thread2 = new Thread(syncThread2, "SyncThread2");
thread1.start();
thread2.start();

이때 SyncThread가 2개 생성됩니다. 개체 syncThread1 및 syncThread2, 스레드 thread1은 syncThread1 개체에서 동기화된 코드(실행)를 실행하고 스레드 thread2는 syncThread2 개체에서 동기화된 코드(실행)를 실행합니다. 우리는 동기화된 개체가 개체를 잠그고 두 개의 잠금 잠금이 있음을 알고 있습니다. syncThread1 객체와 syncThread2 객체는 각각 있으며, 이 두 잠금은 서로 간섭하지 않고 상호 배제를 형성하지 않으므로 두 스레드가 동시에 실행될 수 있습니다.

2. 스레드가 객체의 동기화된(this) 동기화 코드 블록에 액세스하면 다른 스레드는 여전히 객체의 동기화되지 않은(this) 동기화 코드 블록에 액세스할 수 있습니다.
[Demo2]: 다중 스레드가 동기화 및 비동기화 코드 블록에 액세스

class Counter implements Runnable{
   private int count;   public Counter() {      count = 0;
   }   public void countAdd() {
      synchronized(this) {         for (int i = 0; i < 5; i ++) {            try {
               System.out.println(Thread.currentThread().getName() + ":" + (count++));
               Thread.sleep(100);
            } catch (InterruptedException e) {
               e.printStackTrace();
            }
         }
      }
   }   //非synchronized代码块，未对count进行读写操作，所以可以不用synchronized
   public void printCount() {      for (int i = 0; i < 5; i ++) {         try {
            System.out.println(Thread.currentThread().getName() + " count:" + count);
            Thread.sleep(100);
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
      }
   }   public void run() {
      String threadName = Thread.currentThread().getName();      if (threadName.equals("A")) {
         countAdd();
      } else if (threadName.equals("B")) {
         printCount();
      }
   }
}

호출 코드:

Counter counter = new Counter();
Thread thread1 = new Thread(counter, "A");
Thread thread2 = new Thread(counter, "B");
thread1.start();
thread2.start();

결과는 다음과 같습니다.

A:0 
B count:1 
A:1 
B count:2 
A:2 
B count:3 
A:3 
B count:4 
A:4 
B count:5

위 코드에서 countAdd는 동기화되고 printCount는 비동기화됩니다. 위의 결과를 보면, 스레드가 객체의 동기화된 코드 블록에 접근하면 다른 스레드가 블록되지 않고 객체의 비동기화 코드 블록에 접근할 수 있음을 알 수 있습니다.

개체를 잠그도록 지정

[Demo3]: 개체를 잠그도록 지정

/**
 * 银行账户类
 */class Account {
   String name;   float amount;   public Account(String name, float amount) {      this.name = name;      this.amount = amount;
   }   //存钱
   public  void deposit(float amt) {
      amount += amt;      try {
         Thread.sleep(100);
      } catch (InterruptedException e) {
         e.printStackTrace();
      }
   }   //取钱
   public  void withdraw(float amt) {
      amount -= amt;      try {
         Thread.sleep(100);
      } catch (InterruptedException e) {
         e.printStackTrace();
      }
   }   public float getBalance() {      return amount;
   }
}/**
 * 账户操作类
 */class AccountOperator implements Runnable{   private Account account;   public AccountOperator(Account account) {      this.account = account;
   }   public void run() {      synchronized (account) {
         account.deposit(500);
         account.withdraw(500);
         System.out.println(Thread.currentThread().getName() + ":" + account.getBalance());
      }
   }
}

호출 코드:

Account account = new Account("zhang san", 10000.0f);
AccountOperator accountOperator = new AccountOperator(account);final int THREAD_NUM = 5;
Thread threads[] = new Thread[THREAD_NUM];for (int i = 0; i < THREAD_NUM; i ++) {
   threads[i] = new Thread(accountOperator, "Thread" + i);
   threads[i].start();
}

결과는 다음과 같습니다.

Thread3:10000.0 
Thread2:10000.0 
Thread1:10000.0 
Thread4:10000.0 
Thread0:10000.0

AccountOperator 클래스의 run 메소드에서는 동기화를 사용하여 계정 개체를 잠급니다. 이때, 스레드가 계정 개체에 접근하면 해당 스레드가 계정 개체에 접근할 때까지 해당 계정 개체에 접근하려는 다른 스레드는 차단됩니다. 즉, 잠금을 얻은 사람은 누구나 잠금이 제어하는 ​​코드를 실행할 수 있습니다.
잠금으로 명확한 개체가 있는 경우 다음과 유사한 방식으로 프로그램을 작성할 수 있습니다.

public void method3(SomeObject obj)
{   //obj 锁定的对象
   synchronized(obj)
   {      // todo
   }
}

잠금 역할을 하는 명시적인 개체가 없고 코드 일부만 동기화하려는 경우 잠금 역할을 할 특수 개체를 만들 수 있습니다.

class Test implements Runnable{
   private byte[] lock = new byte[0];  // 特殊的instance变量
   public void method()
   {
      synchronized(lock) {         // todo 同步代码块
      }
   }   public void run() {

   }
}

설명: 길이가 0인 바이트 배열 객체는 어떤 객체보다 생성하는 것이 더 경제적입니다. 컴파일된 바이트코드를 살펴보세요. 길이가 0인 byte[] 객체를 생성하려면 3개의 opcode만 필요한 반면, Object lock = new Object()에는 7줄의 코드가 필요합니다. opcode.

메서드 수정

동기화 메소드 수정은 매우 간단합니다. 즉, 메소드 앞에 동기화를 추가하고, public syncified void method(){//todo}를 추가하면 동기화됩니다. 코드 블록을 수정합니다. 비슷하지만 범위가 다릅니다. 수정된 코드 블록은 중괄호로 묶인 범위이고, 수정된 메서드의 범위는 전체 함수입니다. [Demo1]의 실행 방법을 다음 방법으로 변경해도 효과는 동일합니다.

*[Demo4]: 동기화는 메소드를 수정합니다.

public synchronized void run() {   for (int i = 0; i < 5; i ++) {      try {
         System.out.println(Thread.currentThread().getName() + ":" + (count++));
         Thread.sleep(100);
      } catch (InterruptedException e) {
         e.printStackTrace();
      }
   }
}

Synchronized는 전체 메소드에 대해 작동합니다.
작성 방법 1:

public synchronized void method()
{
   // todo
}

작성 방법 2:

public void method(){
   synchronized(this) {
      // todo
   }}

작성 방법 1은 방법을 수정하고, 방법 2를 작성하면 코드 블록을 수정하지만, 방법 1을 작성하고 작성 두 번째 방법은 동일하며 전체 방법이 잠겼을 때의 내용입니다.

在用synchronized修饰方法时要注意以下几点：
1. synchronized关键字不能继承。
虽然可以使用synchronized来定义方法，但synchronized并不属于方法定义的一部分，因此，synchronized关键字不能被继承。如果在父类中的某个方法使用了synchronized关键字，而在子类中覆盖了这个方法，在子类中的这个方法默认情况下并不是同步的，而必须显式地在子类的这个方法中加上synchronized关键字才可以。当然，还可以在子类方法中调用父类中相应的方法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，因此，子类的方法也就相当于同步了。这两种方式的例子代码如下：
在子类方法中加上synchronized关键字

class Parent {
   public synchronized void method() { }
}class Child extends Parent {
   public synchronized void method() { }
}

在子类方法中调用父类的同步方法

class Parent {
   public synchronized void method() {   }
}class Child extends Parent {
   public void method() { super.method();   }
}

在定义接口方法时不能使用synchronized关键字。

构造方法不能使用synchronized关键字，但可以使用synchronized代码块来进行同步。

修饰一个静态的方法

Synchronized也可修饰一个静态方法，用法如下：

public synchronized static void method() {
   // todo
}

我们知道静态方法是属于类的而不属于对象的。同样的，synchronized修饰的静态方法锁定的是这个类的所有对象。我们对Demo1进行一些修改如下：

【Demo5】：synchronized修饰静态方法

/**
 * 同步线程
 */class SyncThread implements Runnable {   private static int count;   public SyncThread() {
      count = 0;
   }   public synchronized static void method() {      for (int i = 0; i < 5; i ++) {         try {
            System.out.println(Thread.currentThread().getName() + ":" + (count++));
            Thread.sleep(100);
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
      }
   }   public synchronized void run() {
      method();
   }
}

调用代码:

SyncThread syncThread1 = new SyncThread();
SyncThread syncThread2 = new SyncThread();
Thread thread1 = new Thread(syncThread1, "SyncThread1");
Thread thread2 = new Thread(syncThread2, "SyncThread2");
thread1.start();
thread2.start();

结果如下：

SyncThread1:0 
SyncThread1:1 
SyncThread1:2 
SyncThread1:3 
SyncThread1:4 
SyncThread2:5 
SyncThread2:6 
SyncThread2:7 
SyncThread2:8 
SyncThread2:9

syncThread1和syncThread2是SyncThread的两个对象，但在thread1和thread2并发执行时却保持了线程同步。这是因为run中调用了静态方法method，而静态方法是属于类的，所以syncThread1和syncThread2相当于用了同一把锁。这与Demo1是不同的。

修饰一个类

Synchronized还可作用于一个类，用法如下：

class ClassName {
   public void method() {
      synchronized(ClassName.class) {
         // todo
      }
   }
}

我们把Demo5再作一些修改。
【Demo6】:修饰一个类

/**
 * 同步线程
 */
class SyncThread implements Runnable {
   private static int count;

   public SyncThread() {
      count = 0;
   }

   public static void method() {
      synchronized(SyncThread.class) {
         for (int i = 0; i < 5; i ++) {
            try {
               System.out.println(Thread.currentThread().getName() + ":" + (count++));
               Thread.sleep(100);
            } catch (InterruptedException e) {
               e.printStackTrace();
            }
         }
      }
   }

   public synchronized void run() {
      method();
   }
}

其效果和【Demo5】是一样的，synchronized作用于一个类T时，是给这个类T加锁，T的所有对象用的是同一把锁。

总结：

A. 无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。 
B. 每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。 
C. 实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。