Implementing a distributed lock using MySQL

CREATE TABLE `globallocktable` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `lockKey` varchar(60) NOT NULL COMMENT 'Lock name',
 `createTime` datetime NOT NULL COMMENT 'Creation time',
 PRIMARY KEY (`id`),
 UNIQUE KEY `lockKey` (`lockKey`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC COMMENT='Global lock';

@Component
public class GlobalLockComponent {
 @Resource
 GlobalLockTableDAO globalLockDAO;
 /**
  * Try to get the lock, true if successful, false if failed
  */
 public boolean tryLock(String key) {
  return GlobalLockUtil.tryLock(this.globalLockDAO, key);
 }
 /**
  * If another program has occupied the lock and it exceeds timeoutMs (milliseconds), the lock will be cleared by force. * That is, delete the record according to the key first, and then add the record */
 public boolean tryLockWithClear(String key, Long timeoutMs) {
  return GlobalLockUtil.tryLockWithClear(this.globalLockDAO, key, timeoutMs);
 }
 /**
  * Release the lock and delete the record according to the key */
 public void releasLock(String key) {
  GlobalLockUtil.releasLock(this.globalLockDAO, key);
 }
}

public class GlobalLockTable {

 private Integer id;
 private String lockKey;
 private Date createTime;
 // Omit get and set methods}

GlobalLockTableDAO is defined as follows public interface GlobalLockTableDAO {
 int deleteByPrimaryKey(Integer id);
 int deleteByLockKey(String lockKey);
 GlobalLockTable selectByLockKey(String key);
 int insertSelectiveWithTest(GlobalLockTable record);
}

public class GlobalLockUtil {
 private static Logger logger = LoggerFactory.getLogger(GlobalLockUtil.class);
 private static GlobalLockTable tryLockInternal(GlobalLockTableDAO lockDAO, String key) {
  GlobalLockTable insert = new GlobalLockTable();
  insert.setCreateTime(new Date());
  insert.setLockKey(key);
  // Note 1
  int count = lockDAO.insertSelectiveWithTest(insert);
  if (count == 0) {
   GlobalLockTable ready = lockDAO.selectByLockKey(key);
   logger.warn("can not lock the key: {}, {}, {}", insert.getLockKey(), ready.getCreateTime(),
     ready.getId());
   return ready;
  }
  logger.info("yes got the lock by key: {}", insert.getId(), insert.getLockKey());
  return null;
 }
 /** Timeout to clear the lock and re-lock**/
 public static boolean tryLockWithClear(GlobalLockTableDAO lockDAO, String key, Long timeoutMs) {
  GlobalLockTable lock = tryLockInternal(lockDAO, key);
  if (lock == null) return true;
  if (System.currentTimeMillis() - lock.getCreateTime().getTime() <= timeoutMs) {
   logger.warn("sorry, can't get the key. : {}, {}, {}", key, lock.getId(), lock.getCreateTime());
   return false;
  }
  logger.warn("the key already timed out before : {}, {}, will clear", key, timeoutMs);
  // Note 2
  int count = lockDAO.deleteByPrimaryKey(lock.getId());
  if (count == 0) {
   logger.warn("sorry, the key already preemptived by others: {}, {}", lock.getId(), lock.getLockKey());
   return false;
  }
  lock = tryLockInternal(lockDAO, key);
  return lock != null ? false : true;
 }
 /** Lock **/
 public static boolean tryLock(GlobalLockTableDAO lockDAO, String key) {
  return tryLockInternal(lockDAO, key) == null ? true : false;
 }
 /** Unlock **/
 public static void releasLock(GlobalLockTableDAO lockDAO, String key) {
  lockDAO.deleteByLockKey(key);
 }
}

<insert id="insertSelectiveWithTest" useGeneratedKeys="true" keyProperty="id" parameterType="com.javashitang.middleware.lock.mysql.pojo.GlobalLockTable">
 insert into `globallocktable` (`id`,
 `lockKey`, `createTime` )
  select #{id,jdbcType=INTEGER}, #{lockKey,jdbcType=VARCHAR}, #{createTime,jdbcType=TIMESTAMP}
  from dual where not exists
  (select 1 from globallocktable where lockKey = #{lockKey,jdbcType=VARCHAR})
</insert>

if (!globalLockComponent.tryLock(name)) {
 // Return if the lock is not acquired;
}
try {
 // Write business logic here} catch (Exception e) {
finally
 globalLockComponent.releasLock(name)