Java 简明教程

Java - Static Synchronization

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

Multithreading

Multithreading 是一种 feature of Java programming language，使我们能够同时执行多个操作。其中，操作被分成多个称为线程的小部分。每个线程执行一个独立的任务，而不影响其他线程的性能。多线程的主要优点是对资源（例如 CPU）进行了最佳使用，并且它加快了分配的操作的执行时间。

Synchronization

线程是以异步方式执行的，因此无法预测它们将如何交互。有时，多个线程可能尝试访问单个资源，然后会发成问题，因为它可能会创建分配的错误任务结果。这时，同步就会发挥作用，并确保一个线程一次只能访问给定的资源。这是因为存在守护同步区域的锁对象。当一个线程进入该区域时，锁将被分配给它，而且在执行它的任务后它将释放锁。直到资源占用，其他线程都在队列中等待它们的轮次。

Static Synchronization in Java

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

Syntax of Static Synchronization

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

这里，returnType 可能为空或任何原始数据类型。parameters 包含变量名称，后跟数据类型。

Multithreading Without Static Synchronization

这是一个简单的示例，它可能并不会按顺序打印 counter 的值，而且每次运行都会基于线程对 CPU 的可用性产生不同的结果。

Example of Multithreading Without Static Synchronization

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.

Multithreading With Static Synchronization

这是一个在每次运行时都会按顺序打印 counter 值的示例，而且每次都产生相同的结果。这次，我们在一个方法上放了 synchronized 关键字，因此在方法执行期间，整个方法会按照对象锁定。

Example of Multithreading With Static Synchronization

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.