Java - 静态同步

同步 是一种建立多个线程之间协作的方法，这些线程试图访问共享资源。对于可靠的线程交互，同步是必要的，并且使用“synchronized”关键字完成。在这里，线程是大型操作的小型子进程。在本文中，我们将学习静态同步以及它们如何管理线程以便它们能够高效地工作。

多线程

多线程 是 Java编程语言的一个特性，它允许我们同时执行多个操作。在多线程中，操作被分成多个称为线程的较小部分。每个线程执行一个独立的任务，而不会影响其他线程的性能。多线程的主要好处是优化资源利用，例如 CPU，并缩短分配操作的执行时间。

同步

线程以异步方式执行，因此无法预测它们将如何交互。有时，多个线程可能试图访问单个资源，然后出现问题，因为它可能会导致分配任务的错误结果。此时，同步就发挥作用，它确保一次只有一个线程可以访问给定的资源。这是因为锁对象保护了同步区域。当一个线程进入该区域时，锁将分配给它，并在执行其任务后释放锁。在资源繁忙期间，其他线程将排队等待。

Java中的静态同步

当我们使用这种类型的同步时，如果一个线程位于静态同步区域，则尝试访问此区域的所有其他线程都将被阻塞。由于静态方法属于类，因此静态同步应用类级锁。

静态同步的语法

static synchronized returnType nameOfMethod( Type parameters) {
	// code
} 

这里returnType可以是void或任何基本数据类型。parameters包含变量名后跟数据类型。

无静态同步的多线程

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

无静态同步的多线程示例

package com.tutorialspoint;

class PrintDemo {
   public static 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;

   ThreadDemo( String name) {
      threadName = name;
   }
   
   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[]) {
      ThreadDemo t1 = new ThreadDemo( "Thread - 1 " );
      ThreadDemo t2 = new ThreadDemo( "Thread - 2 " );

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

      // wait for threads to end
         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关键字，以便在方法执行期间根据对象锁定整个方法。

带静态同步的多线程示例

package com.tutorialspoint;

class PrintDemo {
   public static synchronized 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;

   ThreadDemo( String name) {
      threadName = name;
   }
   
   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[]) {
      ThreadDemo t1 = new ThreadDemo( "Thread - 1 " );
      ThreadDemo t2 = new ThreadDemo( "Thread - 2 " );

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

      // wait for threads to end
         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.