14.2 Поделение ограниченных ресурсов

```markdown
class Observer extends Thread {
  private Share1 p;
  public Observer(Share1 p) {
    this.p = p;
    start();
  }
  public void execute() {
    while(true) {
      for(int i = 0; i < p.s.length; i++)
        p.s[i].synchronizationTest();
      try {
        sleep(500);
      } catch (InterruptedException e){}
    }
  }
}
``````java
public class Sharing1 extends Applet {
    TwoCounter[] s;
    private static int accessCount = 0;
    private static TextField aCount = new TextField("0", 10);

    public static void incrementAccess() {
        accessCount++;
        aCount.setText(Integer.toString(accessCount));
    }

    private Button start = new Button("Start"), observer = new Button("Observe");
    private boolean isApplet = true;
    private int numCounters = 0;
    private int numObservers = 0;

    public void init() {
        if (isApplet) {
            numCounters = Integer.parseInt(getParameter("size"));
            numObservers = Integer.parseInt(getParameter("observers"));
        }
        
        s = new TwoCounter[numCounters];
        for (int i = 0; i < s.length; i++) 
            s[i] = new TwoCounter(this);
        
        Panel p = new Panel();
        start.addActionListener(new StartL());
        p.add(start);
        observer.addActionListener(new ObserverL());
        p.add(observer);
        p.add(new Label("Access Count"));
        p.add(aCount);
        add(p);
    }

    class StartL implements ActionListener {
        public void actionPerformed(ActionEvent e) {
            for (int i = 0; i < s.length; i++)
                s[i].start();
        }
    }

    class ObserverL implements ActionListener {
        public void actionPerformed(ActionEvent e) {
            for (int i = 0; i < numObservers; i++)
                new Watcher(Sharing1.this);
        }
    }

    public static void main(String[] args) {
        Sharing1 applet = new Sharing1();
        // Это не апплет, поэтому установите флаг и

Как обычно, каждый счетчик содержит свои компоненты отображения: два текстовых поля и одну метку. По их начальным значениям можно понять, что счетчики идентичны. Эти компоненты добавляются в контейнер через конструктор `TwoCounter`. Поскольку этот поток запускается действием пользователя — нажатием кнопки, метод `start()` может быть вызван несколько раз. Однако повторный вызов `Thread.start()` для одного и того же потока является недопустимым (вызовет ошибку). В маркере `started` и переопределенном методе `start()`, можно заметить меры предосторожности против этой ситуации. В методе `run()`, увеличение и отображение значений `count1` и `count2` внешне кажутся одинаковыми, что может создать впечатление их полной синхронизации. Однако затем вызывается метод `sleep()`. Без этого вызова программа выдает ошибку, так как это затрудняет переключение задач между процессорами.
```Метод `synchTest()` выполняет действия, которые могут показаться бессмысленными. Он проверяет, равны ли значения `count1` и `count2`; если они не равны, то метка устанавливается в значение `"Несинхронизировано"`. Вначале он вызывает статический член класса `Sharing1`, чтобы увеличивать и выводить счетчик доступа, указывающий, сколько раз была выполнена эта проверка (причины этого станут очевидны при рассмотрении других версий данного примера).

Класс `Watcher` представляет собой поток, который вызывает метод `synchTest()` для всех активных объектов типа `TwoCounter`. При этом он проходит по массиву, содержащемуся в объектах класса `Sharing1`. Можно представить себе `Watcher` как постоянно "шпионящего" за объектами `TwoCounter`.

Класс `Sharing1` содержит массив объектов типа `TwoCounter`, который инициализируется методом `init()` и запускается как поток после нажатия кнопки `"start"`. После того как нажата кнопка `"Observe"` (наблюдение), создаются один или несколько наблюдателей, которые исследуют неохраняемые объекты `TwoCounter`.

Обратите внимание, что для запуска программы в виде апплета в браузере страница должна содержать следующие строки:

```html
<applet code=Sharing1 width=650 height=500>
<param name=size value="20">
<param name=observers value="1">
</applet>
```Вы можете изменять ширину, высоту и параметры по своему усмотрению для проведения экспериментов. Изменение размера (`size`) и количества наблюдателей (`observers`) влияют на поведение программы. Также стоит отметить, что она спроектирована таким образом, чтобы работать как самостоятельное приложение, принимая параметры командной строки (или используя значения по умолчанию).И вот самое удивительное. В бесконечном цикле метода `TwoCounter.run()` повторяются соседние строки:

```java
t1.setText(Integer.toString(count1++));
t2.setText(Integer.toString(count2++));

synchronized void f() { /* ... */ }
synchronized void g() { /* ... */ }
```Каждый объект содержит монитор (или "замок"), который автоматически становится частью объекта (не требуются специальные строки кода для этого). При вызове любого синхронизированного метода объект блокируется, и другие синхронизированные методы того же объекта становятся недоступными, пока первый метод не завершится и не будет разблокирован. В приведённом выше примере, если для объекта вызывается `f()`, то `g()` для того же объекта не может быть вызван, пока `f()` не завершится и не будет разблокирован. Таким образом, все синхронизированные методы одного объекта используют одну общую блокировку, которая предотвращает одновременную запись нескольких потоков в общий участок памяти. Каждый класс также имеет свою собственную локаль (как часть объекта типа `Class` этого класса), поэтому синхронизированные статические методы могут быть взаимно заблокированы в рамках одного класса, чтобы предотвратить доступ к статическим данным.Обратите внимание, что если вы хотите защитить другие ресурсы от одновременного доступа несколькими потоками, можно заставить использовать ключевое слово `synchronized`, чтобы получить доступ к этим ресурсам.

### Синхронизация счетчика

С использованием нового ключевого слова мы можем применять более гибкие подходы: мы можем просто использовать ключевое слово `synchronized` для методов внутри `TwoCounter`. В этом примере представлено изменение предыдущего примера с использованием нового ключевого слова:

```java
//: Sharing2.java
// Использование ключевого слова synchronized для предотвращения
// множественного доступа к определенному ресурсу.
import java.awt.*;
import java.awt.event.*;
import java.applet.*;

class TwoCounter2 extends Thread {
  private boolean started = false;
  private TextField
    t1 = new TextField(5),
    t2 = new TextField(5);
  private Label l =
    new Label("count1 == count2");
  private int count1 = 0, count2 = 0;
  public TwoCounter2(Container c) {
    Panel p = new Panel();
    p.add(t1);
    p.add(t2);
    p.add(l);
    c.add(p);
  }    
  public void start() {
    if (!started) {
      started = true;
      super.start();
    }
  }
  public synchronized void run() {
    while (true) {
      t1.setText(Integer.toString(count1++));
      t2.setText(Integer.toString(count2++));
      try {
        sleep(500);
      } catch (InterruptedException e) {}
    }
  }
  public synchronized void synchTest() {
    Sharing2.incrementAccess();
    if (count1 != count2)
      l.setText("Unsynced");
  }
}
``````java
class Watcher2 extends Thread {
   private Sharing2 p;
   public Watcher2(Sharing2 p) {
     this.p = p;
     start();
   }
   public void run() {
     while (true) {
       for (int i = 0; i < p.s.length; i++) 
         p.s[i].synchTest();
       try {
         sleep(500);
       } catch (InterruptedException e) {}
     }
   }
}

public class Sharing2 extends Applet {
   TwoCounter2[] s;
   private static int accessCount = 0;
   private static TextField aCount =
     new TextField("0", 10);
   public static void incrementAccess() {
     accessCount++;
     aCount.setText(Integer.toString(accessCount));
   }
   private Button
     start = new Button("Start"),
     observer = new Button("Observe");
   private boolean isApplet = true;
   private int numCounters = 0;
   private int numObservers = 0;
   public void init() {
     if(isApplet) {
       numCounters =
         Integer.parseInt(getParameter("size"));
       numObservers =
         Integer.parseInt(getParameter("observers"));
     }
     s = new TwoCounter2[numCounters];
     for(int i = 0; i < s.length; i++)
       s[i] = new TwoCounter2(this);
     Panel p = new Panel();
     start.addActionListener(new StartL());
     p.add(start);
     observer.addActionListener(new ObserverL());
     p.add(observer);
     p.add(new Label("Access count"));
     p.add(aCount);
     add(p);
   }
   class StartL implements ActionListener {
     public void actionPerformed(ActionEvent e) {
       for(int i = 0; i < s.length; i++)
         s[i].start();
     }
   }
   class ObserverL implements ActionListener {
     public void actionPerformed(ActionEvent e) {
       for(int i = 0; i < numObservers; i++)
         new Watcher2(Sharing2.this);
     }
   }
   public static void main(String[] args) {
     Sharing2 applet = new Sharing2();
     // This is not an applet, so set the flag and
     // generate parameter values from arguments:
     applet.isApplet = false;
     applet.numCounters =
       (args.length == 0 ? 5 : Integer.parseInt(args[0]));
     applet.numObservers =
       (args.length < 2 ? 5 : Integer.parseInt(args[1]));
     Frame aFrame = new Frame("Sharing2");
     aFrame.addWindowListener(
       new WindowAdapter() {
         public void windowClosing(WindowEvent e) {
           System.exit(0);
         }
       });
   }
}
``````java
exit(0);
}
});
aFrame.add(applet, BorderLayout.CENTER);
aFrame.setSize(350, applet.numCounters * 100);
applet.init();
applet.start();
aFrame.setVisible(true);
}

Мы заметили, что как `run()`, так и `synchTest()` являются "синхронизированными". Если синхронизировать только один метод, то другой может игнорировать блокировку объекта и вызываться свободно. Поэтому важно помнить одно важное правило: все методы, доступные к одному общедоступному ресурсу, должны быть объявлены как `synchronized`, в противном случае они могут работать некорректно.
```Сейчас мы столкнулись с новой проблемой. `Watcher2` никогда не сможет видеть текущие изменения, поскольку весь метод `run()` объявлен как "синхронизированный". Поскольку каждый объект будет использовать метод `run()`, блокировка всегда будет заблокирована, а `synchTest()` никогда не будет вызван. Это можно понять по тому факту, что значение `accessCount` вообще не меняется.

Чтобы решить эту проблему, одним из подходов является выделение части кода внутри метода `run()`. Эта часть называется "критической секцией", и она должна использоваться с помощью ключевого слова `synchronized` для установки этой критической секции. Java предоставляет поддержку критических секций через "синхронизированные блоки"; в данном случае ключевое слово `synchronized` используется для указания блокировки объекта для синхронизации заключенного в нем кода:

```java
synchronized(syncObject) {
  // Этот код может быть доступен только одной нитью за раз,
  // при условии, что все нити уважают блокировку syncObject
}

Это единственная необходимая модификация файла `Sharing2.java`. Мы увидим, что хотя два счетчика никогда не будут выходить из синхронизации (в зависимости от времени проверки `Watcher`), во время выполнения метода `run()` предоставляется достаточно доступа для `Watcher`.

Таким образом, это единственное изменение, которое требуется сделать для файла `Sharing2.java`. Теперь мы можем наблюдать, что хотя два счетчика никогда не будут выходить из синхронизации (в зависимости от времени проверки `Watcher`), во время выполнения метода `run()` предоставляется достаточно доступа для `Watcher`. Конечно, все синхронизации зависят от того, насколько старательны программисты: каждая часть кода, которая должна получить доступ к общему ресурсу, должна быть заключена в подходящий синхронизированный блок.

### 14.2.3 Обзор Java Beans

Теперь, когда мы понимаем синхронизацию, можно рассмотреть Java Beans с другой точки зрения. Всякий раз, когда создается Bean, следует предположить, что он будет работать в многопоточной среде. Это означает:(1) По возможности все публичные методы Bean должны быть синхронизированы. Конечно, это также привносит "надбавку" по времени выполнения синхронизации. Если вы особенно заботитесь об этом вопросе, методы, которые не вызывают проблем конкуренции, могут быть сделаны "несинхронизированными", но учтите, что это обычно не так легко определить. Подходящие методы часто имеют небольшой размер (например, `getCircleSize()`) и/или являются "микроскопическими". То есть, этот метод выполняется таким малым количеством кода, что объект не может измениться во время его выполнения. Если такой метод сделать "несинхронизированным", это может не оказывать заметного влияния на скорость выполнения программы. Также можно сделать все публичные методы Bean синхронизированными и удалить ключевое слово `synchronized`, только если это действительно необходимо и обеспечивает значительное различие.(2) Если несколько событий передаются последовательно группе слушателей, интересующихся этим событием, следует предположить, что при перемещении по списку слушателей новые слушатели могут быть добавлены или существующие удалены.

Первый пункт легко реализовать, но второй требует более глубокого анализа. Давайте возьмём за пример `BangBean.java` из прошлой главы. В этом примере мы игнорировали ключевое слово `synchronized` (которое тогда ещё не было введено) и установили преобразование как одиночное, чтобы избежать проблем многопоточности. В следующей модифицированной версии мы делаем его способным работать в многопоточной среде и используем технику множественного преобразования для событий:

```markdown
//: BangBean2.java
// Вы должны писать свои Beans таким образом, чтобы они
// могли работать в многопоточной среде.
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import java.io.*;

public class BangBean2 extends Canvas
    implements Serializable {
  private int xm, ym;
  private int cSize = 20; // Размер окружности
  private String text = "Bang! ";
  private int fontSize = 48;
  private Color tColor = Color.red;
  private Vector actionListeners = new Vector();

  public BangBean2() {
    addMouseListener(new ML());
    addMouseMotionListener(new MM());
  }

  public synchronized int getCircleSize() {
    return cSize;
  }

  public synchronized void setCircleSize(int newSize) {
    cSize = newSize;
  }

  public synchronized String getBangText() {
    return text;
  }

  public synchronized void setBangText(String newText) {
    text = newText;
  }
}
```  public synchronized int getFontSize() {
    return fontSize;
  }

  public synchronized void setFontSize(int newSize) {
    fontSize = newSize;
  }

  public synchronized Color getTextColor() {
    return tColor;
  }

  public synchronized void setTextColor(Color newColor) {
    tColor = newColor;
  }

  public void paint(Graphics g) {
    g.setColor(Color.BLACK);
    g.drawOval(xm - cSize / 2, ym - cSize / 2, cSize, cSize);
  }

  // Этот многопоточный слушатель используется чаще, чем однопоточный подход в BangBean.java:
  public synchronized void addActionListener(ActionListener l) {
    actionListeners.addElement(l);
  }

  public synchronized void removeActionListener(ActionListener l) {
    actionListeners.removeElement(l);
  }

  // Обратите внимание, что этот метод не синхронизирован:
  public void notifyListeners() {
    ActionEvent a = new ActionEvent(BangBean2.this, ActionEvent.ACTION_PERFORMED, null);
    Vector lv = null;

    // Создаем копию вектора, так как кто-то может добавить слушатель во время вызова слушателей:
    synchronized(this) {
      lv = (Vector)actionListeners.clone();
    }

    // Вызываем все методы слушателя:
    for(int i = 0; i < lv.size(); i++) {
      ActionListener al = (ActionListener)lv.elementAt(i);
      al.actionPerformed(a);
    }
  }  class ML extends MouseAdapter {
    public void mousePressed(MouseEvent e) {
      Graphics g = getGraphics();
      g.setColor(tColor);
      g.setFont(new Font("TimesRoman", Font.BOLD, fontSize));
      int width = g.getFontMetrics().stringWidth(text);
      g.drawString(text, (getSize().width - width) / 2,

    getSize().height / 2);
    g.dispose();
    notifyListeners();
  }
}
class MM extends MouseMotionAdapter {
  public void mouseMoved(MouseEvent e) {
    xm = e.getX();
    ym = e.getY();
    repaint();
  }
}
// Testing the BangBean2:
public static void main(String[] args) {
  BangBean2 bb = new BangBean2();
  bb.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
      System.out.println("ActionEvent" + e);
    }
  });
  bb.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
      System.out.println("BangBean2 action");
    }
  });
  bb.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
      System.out.println("More action");
    }
  });
  Frame aFrame = new Frame("BangBean2 Test");
  aFrame.addWindowListener(new WindowAdapter() {
    public void windowClosing(WindowEvent e) {
      System.exit(0);
    }
  });
  aFrame.add(bb, BorderLayout.CENTER);
  aFrame.setSize(300, 300);
  aFrame.setVisible(true);
}
} ///:~