Java HashedBytes类代码示例

import org.apache.hadoop.hbase.util.HashedBytes; //导入依赖的package包/类
/**
 * Returns existing row lock if found, otherwise obtains a new row lock and returns it.
 * @param lockid requested by the user, or null if the user didn't already hold lock
 * @param row the row to lock
 * @param waitForLock if true, will block until the lock is available, otherwise will simply
 *          return null if it could not acquire the lock.
 * @return lockid or null if waitForLock is false and the lock was unavailable.
 */
protected Integer getLock(Integer lockid, HashedBytes row, boolean waitForLock)
    throws IOException {
  Integer lid;
  if (lockid == null) {
    lid = internalObtainRowLock(row, waitForLock);
  } else {
    HashedBytes rowFromLock = lockIds.get(lockid);
    if (!row.equals(rowFromLock)) {
      throw new IOException("Invalid row lock: LockId: " + lockid + " holds the lock for row: "
          + rowFromLock + " but wanted lock for row: " + row);
    }
    lid = lockid;
  }
  return lid;
}
 

import org.apache.hadoop.hbase.util.HashedBytes; //导入依赖的package包/类
/**
 * Release the row lock!
 * @param lockId  The lock ID to release.
 */
public void releaseRowLock(final Integer lockId) {
  if (lockId == null) return; // null lock id, do nothing
  HashedBytes rowKey = lockIds.remove(lockId);
  if (rowKey == null) {
    LOG.warn("Release unknown lockId: " + lockId);
    return;
  }
  CountDownLatch rowLatch = lockedRows.remove(rowKey);
  if (rowLatch == null) {
    LOG.error("Releases row not locked, lockId: " + lockId + " row: "
        + rowKey);
    return;
  }
  rowLatch.countDown();
}
 

import org.apache.hadoop.hbase.util.HashedBytes; //导入依赖的package包/类
/**
 * Release the row lock!
 * @param lockId The lock ID to release.
 */
public void releaseRowLock(final Integer lockId) {
  if (lockId == null) return; // null lock id, do nothing
  HashedBytes rowKey = lockIds.remove(lockId);
  if (rowKey == null) {
    LOG.warn("Release unknown lockId: " + lockId);
    return;
  }
  CountDownLatch rowLatch = lockedRows.remove(rowKey);
  if (rowLatch == null) {
    LOG.error("Releases row not locked, lockId: " + lockId + " row: " + rowKey);
    return;
  }
  rowLatch.countDown();
}
 

import org.apache.hadoop.hbase.util.HashedBytes; //导入依赖的package包/类
@Test
public void testGettingTheLockMatchesMyRow() throws Exception {
  MockHRegion region = getMockHRegion();
  HashedBytes rowKey = new HashedBytes(Bytes.toBytes(1));
  assertEquals(Integer.valueOf(2), region.getLock(null, rowKey, false));
  assertEquals(Integer.valueOf(2), region.getLock(2, rowKey, false));
}
 

import org.apache.hadoop.hbase.util.HashedBytes; //导入依赖的package包/类
@Override
public Integer getLock(Integer lockid, HashedBytes row, boolean waitForLock) throws IOException {
  if (testStep == TestStep.CHECKANDPUT_STARTED) {
    latch.countDown();
  }
  return super.getLock(lockid, row, waitForLock);
}
 

import org.apache.hadoop.hbase.util.HashedBytes; //导入依赖的package包/类
/**
 * A version of getRowLock(byte[], boolean) to use when a region operation has already been
 * started (the calling thread has already acquired the region-close-guard lock).
 */
protected RowLock getRowLockInternal(byte[] row, boolean waitForLock) throws IOException {
    checkRow(row, "row lock");
    HashedBytes rowKey = new HashedBytes(row);
    RowLockContext rowLockContext = new RowLockContext(rowKey);

    // loop until we acquire the row lock (unless !waitForLock)
    while (true) {
        RowLockContext existingContext = lockedRows.putIfAbsent(rowKey, rowLockContext);
        if (existingContext == null) {
            // Row is not already locked by any thread, use newly created context.
            break;
        } else if (existingContext.ownedByCurrentThread()) {
            // Row is already locked by current thread, reuse existing context instead.
            rowLockContext = existingContext;
            break;
        } else {
            if (!waitForLock) {
                return null;
            }
            try {
                // Row is already locked by some other thread, give up or wait for it
                if (!existingContext.latch.await(this.rowLockWaitDuration, TimeUnit.MILLISECONDS)) {
                    throw new IOException("Timed out waiting for lock for row: " + rowKey);
                }
            } catch (InterruptedException ie) {
                LOG.warn("Thread interrupted waiting for lock on row: " + rowKey);
                InterruptedIOException iie = new InterruptedIOException();
                iie.initCause(ie);
                throw iie;
            }
        }
    }

    // allocate new lock for this thread
    return rowLockContext.newLock();
}
 

import org.apache.hadoop.hbase.util.HashedBytes; //导入依赖的package包/类
/**
 * Returns existing row lock if found, otherwise
 * obtains a new row lock and returns it.
 * @param lockid requested by the user, or null if the user didn't already hold lock
 * @param row the row to lock
 * @param waitForLock if true, will block until the lock is available, otherwise will
 * simply return null if it could not acquire the lock.
 * @return lockid or null if waitForLock is false and the lock was unavailable.
 */
protected Integer getLock(Integer lockid, HashedBytes row, boolean waitForLock)
throws IOException {
  Integer lid;
  if (lockid == null) {
    lid = internalObtainRowLock(row, waitForLock);
  } else {
    HashedBytes rowFromLock = lockIds.get(lockid);
    if (!row.equals(rowFromLock)) {
      throw new IOException("Invalid row lock: LockId: " + lockid + " holds the lock for row: " + rowFromLock + " but wanted lock for row: " + row);
    }
    lid = lockid;
  }
  return lid;
}
 

import org.apache.hadoop.hbase.util.HashedBytes; //导入依赖的package包/类
/**
 * Release the row lock!
 * @param lockId  The lock ID to release.
 */
public void releaseRowLock(final Integer lockId) {
  HashedBytes rowKey = lockIds.remove(lockId);
  if (rowKey == null) {
    LOG.warn("Release unknown lockId: " + lockId);
    return;
  }
  CountDownLatch rowLatch = lockedRows.remove(rowKey);
  if (rowLatch == null) {
    LOG.error("Releases row not locked, lockId: " + lockId + " row: "
        + rowKey);
    return;
  }
  rowLatch.countDown();
}
 

import org.apache.hadoop.hbase.util.HashedBytes; //导入依赖的package包/类
/**
 * Get a row lock for the specified row. All locks are reentrant. Before calling this function
 * make sure that a region operation has already been started (the calling thread has already
 * acquired the region-close-guard lock).
 *
 * @param row      The row actions will be performed against
 * @param readLock is the lock reader or writer. True indicates that a non-exlcusive lock is
 *                 requested
 */
public RowLock getRowLock(byte[] row, boolean readLock) throws IOException {
  // Make sure the row is inside of this region before getting the lock for
  // it.
  checkRow(row, "row lock");
  // create an object to use a a key in the row lock map
  HashedBytes rowKey = new HashedBytes(row);

  RowLockContext rowLockContext = null;
  RowLockImpl result = null;
  TraceScope traceScope = null;

  // If we're tracing start a span to show how long this took.
  if (Trace.isTracing()) {
    traceScope = Trace.startSpan("HRegion.getRowLock");
    traceScope.getSpan()
        .addTimelineAnnotation("Getting a " + (readLock ? "readLock" : "writeLock"));
  }

  try {
    // Keep trying until we have a lock or error out.
    // TODO: do we need to add a time component here?
    while (result == null) {

      // Try adding a RowLockContext to the lockedRows.
      // If we can add it then there's no other transactions currently
      // running.
      rowLockContext = new RowLockContext(rowKey);
      RowLockContext existingContext = lockedRows.putIfAbsent(rowKey, rowLockContext);

      // if there was a running transaction then there's already a context.
      if (existingContext != null) {
        rowLockContext = existingContext;
      }

      // Now try an get the lock.
      //
      // This can fail as
      if (readLock) {
        result = rowLockContext.newReadLock();
      } else {
        result = rowLockContext.newWriteLock();
      }
    }
    if (!result.getLock().tryLock(this.rowLockWaitDuration, TimeUnit.MILLISECONDS)) {
      if (traceScope != null) {
        traceScope.getSpan().addTimelineAnnotation("Failed to get row lock");
      }
      result = null;
      // Clean up the counts just in case this was the thing keeping the
      // context alive.
      rowLockContext.cleanUp();
      throw new IOException("Timed out waiting for lock for row: " + rowKey);
    }
    return result;
  } catch (InterruptedException ie) {
    LOG.warn("Thread interrupted waiting for lock on row: " + rowKey);
    InterruptedIOException iie = new InterruptedIOException();
    iie.initCause(ie);
    if (traceScope != null) {
      traceScope.getSpan().addTimelineAnnotation("Interrupted exception getting row lock");
    }
    Thread.currentThread().interrupt();
    throw iie;
  } finally {
    if (traceScope != null) {
      traceScope.close();
    }
  }
}
 

import org.apache.hadoop.hbase.util.HashedBytes; //导入依赖的package包/类
RowLockContext(HashedBytes row) {
  this.row = row;
}
 

import org.apache.hadoop.hbase.util.HashedBytes; //导入依赖的package包/类
/**
 * Obtains or tries to obtain the given row lock.
 * @param waitForLock if true, will block until the lock is available. Otherwise, just tries to
 *          obtain the lock and returns null if unavailable.
 */
private Integer internalObtainRowLock(final HashedBytes rowKey, boolean waitForLock)
    throws IOException {
  checkRow(rowKey.getBytes(), "row lock");
  startRegionOperation();
  try {
    CountDownLatch rowLatch = new CountDownLatch(1);

    // loop until we acquire the row lock (unless !waitForLock)
    while (true) {
      CountDownLatch existingLatch = lockedRows.putIfAbsent(rowKey, rowLatch);
      if (existingLatch == null) {
        break;
      } else {
        // row already locked
        if (!waitForLock) {
          return null;
        }
        try {
          if (!existingLatch.await(this.rowLockWaitDuration, TimeUnit.MILLISECONDS)) {
            throw new IOException("Timed out on getting lock for row=" + rowKey);
          }
        } catch (InterruptedException ie) {
          // Empty
        }
      }
    }

    // loop until we generate an unused lock id
    while (true) {
      Integer lockId = lockIdGenerator.incrementAndGet();
      HashedBytes existingRowKey = lockIds.putIfAbsent(lockId, rowKey);
      if (existingRowKey == null) {
        return lockId;
      } else {
        // lockId already in use, jump generator to a new spot
        lockIdGenerator.set(rand.nextInt());
      }
    }
  } finally {
    closeRegionOperation();
  }
}
 

import org.apache.hadoop.hbase.util.HashedBytes; //导入依赖的package包/类
@Override
public Integer getLock(Integer lockid, HashedBytes row, boolean waitForLock) throws IOException {
  acqioredLockCount++;
  return super.getLock(lockid, row, waitForLock);
}
 

import org.apache.hadoop.hbase.util.HashedBytes; //导入依赖的package包/类
RowLockContext(HashedBytes row) {
    this.row = row;
    this.thread = Thread.currentThread();
}
 

import org.apache.hadoop.hbase.util.HashedBytes; //导入依赖的package包/类
/**
 * Tries to acquire a lock on the given row.
 * @param waitForLock if true, will block until the lock is available.
 *        Otherwise, just tries to obtain the lock and returns
 *        false if unavailable.
 * @return the row lock if acquired,
 *   null if waitForLock was false and the lock was not acquired
 * @throws IOException if waitForLock was true and the lock could not be acquired after waiting
 */
public RowLock getRowLock(byte[] row, boolean waitForLock) throws IOException {
  checkRow(row, "row lock");
  startRegionOperation();
  try {
    HashedBytes rowKey = new HashedBytes(row);
    RowLockContext rowLockContext = new RowLockContext(rowKey);

    // loop until we acquire the row lock (unless !waitForLock)
    while (true) {
      RowLockContext existingContext = lockedRows.putIfAbsent(rowKey, rowLockContext);
      if (existingContext == null) {
        // Row is not already locked by any thread, use newly created context.
        break;
      } else if (existingContext.ownedByCurrentThread()) {
        // Row is already locked by current thread, reuse existing context instead.
        rowLockContext = existingContext;
        break;
      } else {
        // Row is already locked by some other thread, give up or wait for it
        if (!waitForLock) {
          return null;
        }
        try {
          if (!existingContext.latch.await(this.rowLockWaitDuration, TimeUnit.MILLISECONDS)) {
            throw new IOException("Timed out waiting for lock for row: " + rowKey);
          }
        } catch (InterruptedException ie) {
          LOG.warn("Thread interrupted waiting for lock on row: " + rowKey);
          InterruptedIOException iie = new InterruptedIOException();
          iie.initCause(ie);
          throw iie;
        }
      }
    }

    // allocate new lock for this thread
    return rowLockContext.newLock();
  } finally {
    closeRegionOperation();
  }
}
 

import org.apache.hadoop.hbase.util.HashedBytes; //导入依赖的package包/类
RowLockContext(HashedBytes row) {
  this.row = row;
  this.thread = Thread.currentThread();
}