Source code interpretation of PowerJob LockService method workflow

public interface LockService {
    /**
      * Lock (acquire lock), return immediately, will not block waiting for lock
      * @param name Lock name
      * @param maxLockTime Maximum lock-holding time, unit milliseconds (ms)
      * @return true -> Lock was obtained, false -> Lock was not obtained
      */
    boolean tryLock(String name, long maxLockTime);
    /**
      * Release the lock
      * @param name Lock name
      */
    void unlock(String name);
}

@Slf4j
@Service
public class DatabaseLockService implements LockService {
    private final String ownerIp;
    private final OmsLockRepository omsLockRepository;
    @Autowired
    public DatabaseLockService(OmsLockRepository omsLockRepository) {
         = ();
         = omsLockRepository;
        ().addShutdownHook(new Thread(() -> {
            int num = (ownerIp);
            ("[DatabaseLockService] execute shutdown hook, release all lock(owner={},num={})", ownerIp, num);
        }));
    }
    @Override
    public boolean tryLock(String name, long maxLockTime) {
        OmsLockDO newLock = new OmsLockDO(name, ownerIp, maxLockTime);
        try {
            (newLock);
            return true;
        } catch (DataIntegrityViolationException ignore) {
        } catch (Exception e) {
            ("[DatabaseLockService] write lock to database failed, lockName = {}.", name, e);
        }
        OmsLockDO omsLockDO = (name);
        long lockedMillions = () - ().getTime();
        // The lock timed out, force release the lock and try to obtain it again        if (lockedMillions > ()) {
            ("[DatabaseLockService] The lock[{}] already timeout, will be unlocked now.", omsLockDO);
            unlock(name);
            return tryLock(name, maxLockTime);
        }
        return false;
    }
    @Override
    public void unlock(String name) {
        try {
            CommonUtils.executeWithRetry0(() -> (name));
        }catch (Exception e) {
            ("[DatabaseLockService] unlock {} failed.", name, e);
        }
    }
}

public static String getLocalHost() {
        if (HOST_ADDRESS != null) {
            return HOST_ADDRESS;
        }
        String addressFromJVM = (PowerJobDKey.BIND_LOCAL_ADDRESS);
        if ((addressFromJVM)) {
            ("[Net] use address from[{}]: {}", PowerJobDKey.BIND_LOCAL_ADDRESS, addressFromJVM);
            return HOST_ADDRESS = addressFromJVM;
        }
        InetAddress address = getLocalAddress();
        if (address != null) {
            return HOST_ADDRESS = ();
        }
        return LOCALHOST_VALUE;
    }
    public static InetAddress getLocalAddress() {
        if (LOCAL_ADDRESS != null) {
            return LOCAL_ADDRESS;
        }
        InetAddress localAddress = getLocalAddress0();
        LOCAL_ADDRESS = localAddress;
        return localAddress;
    }    
    private static InetAddress getLocalAddress0() {
        // @since 2.7.6, choose the {@link NetworkInterface} first
        try {
            InetAddress addressOp = getFirstReachableInetAddress( findNetworkInterface());
            if (addressOp != null) {
                return addressOp;
            }
        } catch (Throwable e) {
            ("[Net] getLocalAddress0 failed.", e);
        }
        InetAddress localAddress = null;
        try {
            localAddress = ();
            Optional<InetAddress> addressOp = toValidAddress(localAddress);
            if (()) {
                return ();
            }
        } catch (Throwable e) {
            ("[Net] getLocalAddress0 failed.", e);
        }
        return localAddress;
    }

@Data
@Entity
@NoArgsConstructor
@Table(uniqueConstraints = {@UniqueConstraint(name = "uidx01_oms_lock", columnNames = {"lockName"})})
public class OmsLockDO {

    @Id
    @GeneratedValue(strategy = , generator = "native")
    @GenericGenerator(name = "native", strategy = "native")
    private Long id;

    private String lockName;

    private String ownerIP;
    /**
      * Maximum lock-holding time
      */
    private Long maxLockTime;

    private Date gmtCreate;

    private Date gmtModified;

    public OmsLockDO(String lockName, String ownerIP, Long maxLockTime) {
         = lockName;
         = ownerIP;
         = maxLockTime;
         = new Date();
         = ;
    }
}

public interface OmsLockRepository extends JpaRepository<OmsLockDO, Long> {

    @Modifying
    @Transactional(rollbackOn = )
    @Query(value = "delete from OmsLockDO where lockName = ?1")
    int deleteByLockName(String lockName);

    OmsLockDO findByLockName(String lockName);

    @Modifying
    @Transactional(rollbackOn = )
    int deleteByOwnerIP(String ip);
}