Esempio n. 1
0
  public void rename(String oldName, String newName) throws SystemException {
    CounterRegister counterRegister = getCounterRegister(oldName);

    synchronized (counterRegister) {
      if (_counterRegisterMap.containsKey(newName)) {
        throw new SystemException("Cannot rename " + oldName + " to " + newName);
      }

      Connection connection = null;
      PreparedStatement preparedStatement = null;

      try {
        connection = getConnection();

        preparedStatement = connection.prepareStatement(_SQL_UPDATE_NAME_BY_NAME);

        preparedStatement.setString(1, newName);
        preparedStatement.setString(2, oldName);

        preparedStatement.executeUpdate();
      } catch (ObjectNotFoundException onfe) {
      } catch (Exception e) {
        throw processException(e);
      } finally {
        DataAccess.cleanUp(connection, preparedStatement);
      }

      counterRegister.setName(newName);

      _counterRegisterMap.put(newName, counterRegister);
      _counterRegisterMap.remove(oldName);
    }
  }
Esempio n. 2
0
  private long _competeIncrement(CounterRegister counterRegister, int size) throws SystemException {

    CounterHolder counterHolder = counterRegister.getCounterHolder();

    // Try to use the fast path

    long newValue = counterHolder.addAndGet(size);

    if (newValue <= counterHolder.getRangeMax()) {
      return newValue;
    }

    // Use the slow path

    CompeteLatch completeLatch = counterRegister.getCompeteLatch();

    if (!completeLatch.compete()) {

      // Loser thread has to wait for the winner thread to finish its job

      try {
        completeLatch.await();
      } catch (InterruptedException ie) {
        throw processException(ie);
      }

      // Compete again

      return _competeIncrement(counterRegister, size);
    }

    // Winner thread

    try {

      // Double check

      counterHolder = counterRegister.getCounterHolder();
      newValue = counterHolder.addAndGet(size);

      if (newValue > counterHolder.getRangeMax()) {
        CounterHolder newCounterHolder =
            _obtainIncrement(counterRegister.getName(), counterRegister.getRangeSize(), 0);

        newValue = newCounterHolder.addAndGet(size);

        counterRegister.setCounterHolder(newCounterHolder);
      }
    } catch (Exception e) {
      throw processException(e);
    } finally {

      // Winner thread opens the latch so that loser threads can continue

      completeLatch.done();
    }

    return newValue;
  }