Groovy - 线程同步

为什么需要线程同步？

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

因此，需要同步多个线程的操作，确保在任何给定时间点只有一个线程可以访问资源。这是通过一种称为monitors的概念来实现的。Groovy 中的每个对象都关联一个 monitor，线程可以锁定或解锁该 monitor。同一时间只有一个线程可以持有 monitor 的锁。

Groovy 中的线程同步

Groovy 编程语言提供了一种非常便捷的方式来创建线程并同步它们的任务，即使用 synchronized 块。将共享资源保存在这个块中。以下是 synchronized 语句的一般形式 −

语法

synchronized(objectidentifier) {
   // Access shared variables and other shared resources
   // 访问共享变量和其他共享资源
}

在这里，objectidentifier 是对对象的引用，其锁与 synchronized 语句所代表的 monitor 相关联。现在我们来看两个例子，我们将使用两个不同的线程打印一个计数器。当线程未同步时，它们打印的计数器值不是顺序的，但当我们将计数器放在 synchronized() 块中打印时，两个线程都会非常有序地打印计数器。

示例 - 没有线程同步的多线程

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

Example.groovy

class Example {
   static void main(String[] args) {
      PrintDemo printDemo = new PrintDemo();
      ThreadDemo thread1 = new ThreadDemo( "Thread - 1 ", printDemo );
      ThreadDemo thread2 = new ThreadDemo( "Thread - 2 ", printDemo );

      thread1.start();
      thread2.start();

      // wait for threads to end
      // 等待线程结束
      try {
         thread1.join();
         thread2.join();
      } catch ( Exception e) {
         println("Interrupted");
         // 中断
      }
   }
}
class PrintDemo {
   void printCount() {
      try {
         for(int i = 5; i > 0; i--) {
            println("Counter   ---   "  + i );
         }
      } catch (Exception e) {
         println("Thread interrupted.");
         // 线程被中断。
      }
   }
}

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

   ThreadDemo( String threadName,  PrintDemo printDemo) {
      this.threadName = threadName;
      this.printDemo = printDemo;
   }
   
   void run() {
      printDemo.printCount();
      println("Thread " +  threadName + " exiting.");
      // 退出
   }

   void start () {
      println("Starting " +  threadName );
      // 启动
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}

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

输出

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

示例 - 使用线程同步的多线程

这是一个相同的示例，它会按顺序打印计数器值，并且每次运行都会产生相同的结果。

Example.groovy

class Example {
   static void main(String[] args) {

      PrintDemo printDemo = new PrintDemo();

      ThreadDemo thread1 = new ThreadDemo( "Thread - 1 ", printDemo );
      ThreadDemo thread2 = new ThreadDemo( "Thread - 2 ", printDemo );

      thread1.start();
      thread2.start();

      // 等待线程结束
      try {
         thread1.join();
         thread2.join();
      } catch ( Exception e) {
         println("Interrupted");
      }
   }
}
class PrintDemo {
   void printCount() {
      try {
         for(int i = 5; i > 0; i--) {
            println("Counter   ---   "  + i );
         }
      } catch (Exception e) {
         println("Thread interrupted.");
      }
   }
}

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

   ThreadDemo( String threadName,  PrintDemo printDemo) {
      this.threadName = threadName;
      this.printDemo = printDemo;
   }
   
   void run() {
      synchronized(printDemo) {
         printDemo.printCount();
      }
      println("Thread " +  threadName + " exiting.");
   }

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

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

输出

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.