Simple redis lock

@Component
public class DistributedLock {

    private static final Logger LOGGER = LoggerFactory.getLogger(DistributedLock.class);

    @Resource(name = "cscRedisClient")
    private RedisStoreClient redisStoreClient;

    private static final String LOCK_CATEGORY = "oms_distribut_lock";

    private static final String APP_KEY = "csc-oms-task-process-service";

    /**
     *  Lock 
     * @param locaName   The lock key
     * @param acquireTimeout   Get timeout 
     * @param timeout    The timeout of the lock 
     * @return  Lock logo 
     */
    public String lockWithTimeout(String locaName,
                                  long acquireTimeout, int timeout) {
        String retIdentifier = null;
        try {

            //  Randomly generate one value
            String identifier = UUID.randomUUID().toString();
            //  Lock name , namely key value 
            String lockKey = "lock:" + locaName;
            //  Timeout time , After locking, the lock will be released automatically 
//            int lockExpire = (int)(timeout / 1000);

            //  The timeout for obtaining the lock , After this time, the lock is abandoned 
            long end = System.currentTimeMillis() + acquireTimeout * 1000;
            final StoreKey storeKey = new StoreKey(LOCK_CATEGORY, APP_KEY, lockKey);
            while (System.currentTimeMillis() < end) {
                if (redisStoreClient.setnx(storeKey, identifier)) {
                    redisStoreClient.expire(storeKey, timeout);
                    //  return value value , Used to release lock time confirmation 
                    retIdentifier = identifier;
                    return retIdentifier;
                }
                //  return -1 representative key No timeout set , by key Set a timeout 
                if (redisStoreClient.ttl(storeKey) == -1) {
                    redisStoreClient.expire(storeKey, timeout);
                }

                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        } catch (Exception e) {
            LOGGER.error(" Lock acquisition failed " + locaName, e);
            Cat.logError(" Lock acquisition failed " + locaName, e);
        }
        return retIdentifier;
    }

    /**
     *  Release the lock 
     * @param lockName  The lock key
     * @param identifier     Release the lock logo 
     * @return
     */
    public boolean releaseLock(String lockName, long acquireTimeout, String identifier) {

        String lockKey = "lock:" + lockName;
        boolean retFlag = false;
        try {
            final StoreKey storeKey = new StoreKey(LOCK_CATEGORY, APP_KEY, lockKey);
            long end = System.currentTimeMillis() + acquireTimeout * 1000;
            while (System.currentTimeMillis() < end) {
                if (redisStoreClient.compareAndDelete(storeKey, identifier)) {
                    LOGGER.info("delelte lock");
                    break;
                }
            }
        } catch (Exception e) {
            LOGGER.warn("releaseLock,{}",e);
        }
        return retFlag;
    }
}