Семафоры

Перевод на русский © Сергей Миссан, 2000
Оригинал статьи опубликован на сайте Javable.com

Java Q&A

Java использует ключевое слово synchronized и методы wait() и notify() класса java.lang.Object для синхронизации. Существуют ли другие способы, например семафоры, в Java?

Единственные механизмы синхронизации, встроенные в Java-- это мониторы (monitors) и наборы задержек (wait sets), о которых большинство программистов даже не слышало, так как они скрыты в synchronized, wait() и notify(). К счастью, Java позволяет вам реализовать все знакомые схемы синхронизации на основе мониторов и наборов задержек. В конце этой заметки мы узнаем, как написать наш собственный класс Semaphore.

Однако перед этим давайте посмотрим немного на теоретические основы. Каждый многопотоковый (multithreaded) язык программирования должен иметь механизм для синхронизации нитей. Возьмем, например, программу с нитью, которая создает объекты, и нитью, которая использует их, как в этом примере кода:

Object data = null;

public void push(Object d) {
 data = d;
}

public Object pop() {
 Object d = data;
 data = null;
 return d;
}

class Producer implements Runnable {
 public void run() {
  while (true) {
   Object o =
     createNewObject();
   push(o);
  }
 }
}

class Consumer implements Runnable {
 public void run() {
  while (true) {
   Object o = pop();
   doSomethingWith(o);
  }
 }
}

public static void main(String args[]) {
 (new Thread(new Producer())).start();
 (new Thread(new Consumer())).start();
}

Проблема с этими примитивными классами Producer и Consumer заключается в том, что они не содержат никаких способов для взаимодействия друг с другом. Если одна нить работает быстрее, чем другая, она должна периодически ждать, пока медленная нить сделает свою работу. Мы можем изменить методы push() и pop() так, чтобы они работали поочередно и не обгоняли друг-друга.

public void push(Object d) {
 while (data != null)
  { /* Пустой цикл задержки. */ }
 data = d;
}

public Object pop() {
 while (data == null)
 { /* Пусто. */ }
 Object d = data;
 data = null;
 /* Выход из цикла для  push().*/
 return d;
}

Когда одна нить выполняет push(), а другая pop(), они взаимодействуют, используя значение поля data. push() ожидает окончания работы pop(), непрерывно проверяя поле data. Когда data становится null, push() может присвоить ему новый объект. pop() использует тот же прием, сидя в цикле и ожидая, пока data изменится. Как только data становится непустым, pop() выходит из цикла и устанавливает его опять в null.

Этот прием называется циклом задержки и содержит массу недостатков. Один из самых серьезных это то, что он может использовать все свободные ресурсы процессора. Если нить consume() имеет одинаковый или более высокий приоритет, чем produce(), цикл задержки в consume() может не дать produce() работать!

Java обходит необходимость в циклах задержки используя мониторы и наборы задержек. Монитор- это структура данных, которая может содержать одну-единственную нить. Если другая нить пытается занять монитор, содержащий нить, она будет заблокирована, пока монитор не освободится. У каждого объекта есть монитор: нить занимает его, вызывая метод synchronized для этого объекта, или входя в участок кода, который помечен как synchronized. Каждый объект Java содержит набор задержек -- набор нитей которые находятся в спящем режиме, пока другая нить не активирует одну из них. Нить запускает набор задержек объекта, вызывая его метод wait(). Она может покинуть набор задержек, когда другая нить вызывает метод notify() этого объекта.

Вот реализация push() и pop(), использующая мониторы и наборы задержек:

Object full  = new Object();
Object empty = new Object();

public void push(Object d) {
synchronized(full) {
 if (data != null) full.wait();
}

data = d;

synchronized(empty) {
 if (data != null) empty.notify();
}
}

public Object pop() {
synchronized(empty) {
 if (data == null) empty.wait();
}

Object o = data;
data = null;

synchronized(full) {
 if (data == null) full.notify();
}

return o;
}

Если data непуст, push() ждет, пока pop() сообщит ему, что data более не заполнен. Затем push() присваивает свой параметр data и сообщает pop(), что data заполнен. Такое решение гораздо менее нагружает процессор, чем цикл задержки. Оно также легко расширяется для поддержки нескольких производителей и потребителей объектов, вместо одного на каждый: достаточно только объявить push() и pop() как synchronized!

Мониторы Java и наборы задержек достаточно надежны для решения большинства проблем синхронизации и достаточно безопасны для того, чтобы большинство программистов не испытывали проблем. А для тех, кто любит рискованные приемы, мы приводим обещанную реализацию класса Semaphore:

/**
* Semaphore-
* это простая реализация хорошо известного
* примитива синхронизации.
* Его счетчик может быть установлен в любое
* неотрицательное значение или 0 по-умолчанию.
*/
package com.randomwalk.library.sync;

public class Semaphore {
private int counter;

public Semaphore() {
 this(0);
}

public Semaphore(int i) {
if (i < 0) throw
 new IllegalArgumentException(i + " < 0");
 counter = i;
}

/**
* Увеличивает внутренний счетчик,
* возможно активирует нить
* wait()ing in acquire().
*/
public synchronized void release() {
 if (counter == 0) {
  this.notify();
 }
 counter++;
}

/**
* Уменьшает счетчик или блокирует,
* если тот равен 0
*
* @exception InterruptedException
* передается из this.wait().
*/
public synchronized void acquire()
throws InterruptedException {
 while (counter == 0) {
  this.wait();
 }
 counter--;
}
}

Об авторе

Reprinted with permission from the March 2000 edition of JavaWorld magazine.
Copyright © ITworld.com, Inc., an IDG Communications company.
View the original article at: http://www.javaworld.com/javaworld/javaqa/1999-11/02-qa-semaphore.html