Java 块同步

当我们在一个 Java 程序中启动两个或更多的线程时，可能会遇到多个线程试图访问相同的资源的情况，最终导致由于并发问题而产生不可预测的结果。例如，如果有多个线程试图在同一文件中写入数据，则它们可能会破坏数据，因为其中一个线程可能会覆盖数据，或者当一个线程正在打开同一个文件时，另一个线程可能正在关闭同一个文件。

因此，需要同步多个线程的动作，以确保只有一个线程可以在给定的时间点访问资源。这是通过称为监视器的概念来实现的。Java 中的每个对象都与一个监视器相关联，线程可以锁定或解锁它。一次只能有一个线程持有监视器的锁。

Java 中的代码块同步

Java 编程语言提供了一种非常方便的方式来创建线程并通过使用同步块来同步它们的任务。您可以在这些块中保持共享资源。

语法

以下是 synchronized 语句的一般形式：

synchronized(objectidentifier) {
   // 访问共享变量和其他共享资源
}

这里的 objectidentifier 是对一个对象的引用，该对象的锁与 synchronized 语句所代表的监视器关联。现在我们将看到两个例子，在这两个例子中，我们将使用两个不同的线程打印一个计数器。当线程不同步时，它们打印的计数器值不是连续的，但是当我们把计数器放在 synchronized() 块中时，对于两个线程来说，计数器的打印非常有序。

没有同步的多线程示例

这里是一个简单的例子，它可能会也可能不会按顺序打印计数器值，每次运行时，根据线程获得的 CPU 时间的不同，会产生不同的结果。

示例

package com.tutorialspoint;

class PrintDemo {
   public void printCount() {
      try {
         for(int i = 5; i > 0; i--) {
            Thread.sleep(50);
            System.out.println("Counter   ---   "  + i );
         }
      } catch (Exception e) {
         System.out.println("Thread  interrupted.");
      }
   }
}

class ThreadDemo extends Thread {
   private Thread t;
   private String threadName;
   PrintDemo  printDemo;

   ThreadDemo( String name,  PrintDemo pd) {
      threadName = name;
      printDemo = pd;
   }
   
   public void run() {
      printDemo.printCount();
      System.out.println("Thread " +  threadName + " exiting.");
   }

   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}

public class TestThread {
   public static void main(String args[]) {

      PrintDemo printDemo = new PrintDemo();

      ThreadDemo t1 = new ThreadDemo( "Thread - 1 ", printDemo );
      ThreadDemo t2 = new ThreadDemo( "Thread - 2 ", printDemo );

      t1.start();
      t2.start();

      // 等待线程结束
      try {
         t1.join();
         t2.join();
      } catch ( Exception e) {
         System.out.println("Interrupted");
      }
   }
}

输出

每次运行此程序都会产生不同的结果：

Starting Thread - 1 
Starting Thread - 2 
Counter   ---   5
Counter   ---   5
Counter   ---   4
Counter   ---   4
Counter   ---   3
Counter   ---   3
Counter   ---   2
Counter   ---   2
Counter   ---   1
Counter   ---   1
Thread Thread - 1  exiting.
Thread Thread - 2  exiting.

在代码块级别进行同步的多线程示例

这里是一个相同例子的变体，它按顺序打印计数器值，并且每次运行时都会产生相同的结果。我们在这次在一块代码上放置了 synchronized 关键字，使得在方法执行期间，计数器递增的代码是按照对象锁定的。我们使用当前的对象作为锁，作为参数传递到 synchronized 块中。

示例

package com.tutorialspoint;

class PrintDemo {
   public void printCount() {
      try {
         for(int i = 5; i > 0; i--) {
            Thread.sleep(50);
            System.out.println("Counter   ---   "  + i );
         }
      } catch (Exception e) {
         System.out.println("Thread  interrupted.");
      }
   }
}

class ThreadDemo extends Thread {
   private Thread t;
   private String threadName;
   PrintDemo printDemo;

   ThreadDemo( String name, PrintDemo pd) {
      threadName = name;
      printDemo = pd;
   }
   
   public void run() {
      synchronized(printDemo) {
         printDemo.printCount();
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }

   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}

public class TestThread {

   public static void main(String args[]) {
      PrintDemo printDemo = new PrintDemo();

      ThreadDemo t1 = new ThreadDemo( "Thread - 1 ", printDemo );
      ThreadDemo t2 = new ThreadDemo( "Thread - 2 ", printDemo );

      t1.start();
      t2.start();

      // 等待线程结束
      try {
         t1.join();
         t2.join();
      } catch ( Exception e) {
         System.out.println("Interrupted");
      }
   }
}

输出

每次运行此程序都会产生相同的结果：

Starting Thread - 1 
Starting Thread - 2 
Counter   ---   5
Counter   ---   4
Counter   ---   3
Counter   ---   2
Counter   ---   1
Thread Thread - 1  exiting.
Counter   ---   5
Counter   ---   4
Counter   ---   3
Counter   ---   2
Counter   ---   1
Thread Thread - 2  exiting.

在方法级别进行同步的多线程示例

这里是一个相同例子的变体，它按顺序打印计数器值，并且每次运行时都会产生相同的结果。这次我们在方法上放置了 synchronized 关键字，使得在方法执行期间整个方法是按照对象锁定的。

示例

package com.tutorialspoint;

class PrintDemo extends Thread {
   public void printCount() {
      try {
         for(int i = 5; i > 0; i--) {
            Thread.sleep(50);
            System.out.println("Counter --- " + i );
         }
      } catch (Exception e) {
         System.out.println("Thread " + Thread.currentThread().getName()+" interrupted.");
      }
   }
   public synchronized void run() {
      printCount();
      System.out.println("Thread " + Thread.currentThread().getName() + " exiting.");
   }
}
public class TestThread {
   public static void main(String args[]) {
      PrintDemo printDemo = new PrintDemo();
      Thread t1 = new Thread(printDemo );
      Thread t2 = new Thread(printDemo );
      t1.start();
      t2.start();
      // 等待线程结束
      try {
         t1.join();
         t2.join();
      } catch ( Exception e) {
         System.out.println("Interrupted");
      }
   }
}

输出

每次运行此程序都会产生相同的结果：

Counter --- 5
Counter --- 4
Counter --- 3
Counter --- 2
Counter --- 1
Thread Thread-1 exiting.
Counter --- 5
Counter --- 4
Counter --- 3
Counter --- 2
Counter --- 1
Thread Thread-2 exiting.