在微服务架构中实施分布式事务锁的几个方案比较 - Prasanth Gullapalli

package common.concurrent.lock;
 
import java.util.concurrent.TimeUnit;
 
/**
 * Provides interface for the distributed lock implementations based on Zookeeper and Hazelcast.
 * @author pgullapalli
 */
public interface DistributedLock {
    /**
     * Acquires the lock. If the lock is not available, the current thread until the lock has been acquired.
     * The distributed lock acquired by a thread has to be released by same thread only.
     **/
    void lock();
 
    /**
     * This is a non-blocking version of lock() method; it attempts to acquire the lock immediately, return true if locking succeeds.
     * The distributed lock acquired by a thread has to be released by same thread only.
     **/
    boolean tryLock();
 
    /**
     * Acquires the lock. Blocks until the lock is available or timeout is expired.
     * The distributed lock acquired by a thread has to be released by same thread only.
     **/
    boolean tryLock(long timeout, TimeUnit unit);
 
    /**
     * Checks if current thread has already acquire the lock.
     * @return
     */
    boolean isLocked();
 
    /**
     * Releases the lock. This method has to be called by same thread as which has acquired the lock.
     */
    void release();
}
 
public interface DistributedLocker {
 
    /**
     * This method only fetches the lock object but does not explicitly lock. Lock has to be acquired and released.
     * specifically
     * @param key Fetch the lock object based on the key provided.
     * @return Implementation of DistributedLock object
     */
    DistributedLock getLock(String key);
 
}

package common.concurrent.lock.impl;
 
import common.concurrent.lock.DistributedLock;
import common.concurrent.lock.DistributedLocker;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.locks.InterProcessLock;
import org.apache.curator.framework.recipes.locks.InterProcessSemaphoreMutex;
import org.apache.curator.retry.ExponentialBackoffRetry;
 
import java.util.concurrent.TimeUnit;
 
public class ZKBasedDistributedLocker implements DistributedLocker {
    private final CuratorFramework curatorClient;
    private final String basePath;
 
    public ZKBasedDistributedLocker(){
        curatorClient = CuratorFrameworkFactory.newClient("localhost:2181",
                new ExponentialBackoffRetry(1000, 3));
        basePath = new StringBuilder("/config/sample-app/distributed-locks/").toString();
    }
 
    @Override
    public DistributedLock getLock(String key) {
        String lock = new StringBuilder(basePath).append(key).toString();
        return new ZKLock(new InterProcessSemaphoreMutex(curatorClient, lock));
    }
 
    private class ZKLock implements DistributedLock {
        private final InterProcessLock lock;
 
        public ZKLock(InterProcessLock lock){
            this.lock = lock;
        }
 
        @Override
        public void lock() {
            try {
                lock.acquire();
            } catch (Exception e) {
                throw new RuntimeException("Error while acquiring lock", e);
            }
        }
 
        @Override
        public boolean tryLock() {
            return tryLock(10, TimeUnit.MILLISECONDS);
        }
 
        @Override
        public boolean tryLock(long timeout, TimeUnit unit) {
            try {
                return lock.acquire(timeout, unit);
            } catch (Exception e) {
                throw new RuntimeException("Error while acquiring lock", e);
            }
        }
 
        @Override
        public boolean isLocked() {
            return lock.isAcquiredInThisProcess();
        }
 
        @Override
        public void release() {
            try {
                lock.release();
            } catch (Exception e) {
                throw new RuntimeException("Error while releasing lock", e);
            }
        }
    }
}

insert into lock_requests(resource_id,lock_status,created_on) values('ABC', 'Locked', toTimestamp(now())) if not exists;

create table lock_requests(resource_id text,lock_status text, created_on timestamp, primary key(resource_id)) with gc_grace_seconds=86400 and default_time_to_live=600;

package common.concurrent.lock.impl;
 
import com.datastax.oss.driver.api.core.CqlSession;
import com.datastax.oss.driver.api.core.cql.BoundStatement;
import com.datastax.oss.driver.api.core.cql.PreparedStatement;
import com.datastax.oss.driver.api.core.cql.ResultSet;
import com.datastax.oss.driver.api.core.cql.Row;
import common.concurrent.lock.DistributedLock;
import common.concurrent.lock.DistributedLocker;
import org.apache.commons.lang3.time.StopWatch;
 
import java.net.InetSocketAddress;
import java.time.Instant;
import java.util.concurrent.TimeUnit;
 
public class CassandraDistributedLocker implements DistributedLocker {
    private final CqlSession session;
    private final PreparedStatement selectStatement, insertStatement, deleteStatement;
 
    public CassandraDistributedLocker(){
        session = CqlSession.builder()
                .addContactPoint(new InetSocketAddress("127.0.0.1", 9042))
                .withKeyspace("sample").build();
        selectStatement = session.prepare(
                "select * from lock_requests where resource_id=?");
        insertStatement = session.prepare(
                "insert into lock_requests(resource_id,lock_status,created_on) values(?,?,?) if not exists");
        deleteStatement = session.prepare(
                "delete from lock_requests where resource_id=? if exists");
    }
 
    @Override
    public DistributedLock getLock(String key) {
        return new CassandraLock(key);
    }
 
    private class CassandraLock implements DistributedLock{
        private final String key;
 
        public CassandraLock(String key) {
            this.key = key;
        }
 
        @Override
        public void lock() {
            insertLock();
        }
 
        private boolean insertLock() {
            BoundStatement boundStatement = insertStatement.bind()
                    .setString(0, key)
                    .setString(1, "LOCKED")
                    .setInstant(2, Instant.now());
            ResultSet resultSet = session.execute(boundStatement);
            return resultSet.wasApplied();// this is equivalent to row.getBool("applied")
        }
 
        @Override
        public boolean tryLock() {
            return tryLock(10, TimeUnit.MILLISECONDS);
        }
 
        @Override
        public boolean tryLock(long timeout, TimeUnit unit) {
            try {
                boolean locked = false;
                StopWatch stopWatch = StopWatch.createStarted();
                while(stopWatch.getTime(TimeUnit.SECONDS) < timeout) {
                    if(insertLock()) {
                        locked = true;
                        break;
                    }
                }
                return locked;
            } catch (Exception e) {
                throw new RuntimeException("Error while acquiring lock", e);
            }
        }
 
        @Override
        public boolean isLocked() {
            BoundStatement boundStatement = selectStatement.bind().setString(0, key);
            ResultSet resultSet = session.execute(boundStatement);
            Row row = resultSet.one();
            return row != null ? "LOCKED".equals(row.getString("lock_status")) : false;
        }
 
        @Override
        public void release() {
            try {
                BoundStatement boundStatement = deleteStatement.bind().setString(0, key);
                session.execute(boundStatement);
            } catch (Exception e){
                throw new RuntimeException("Error while releasing lock", e);
            }
        }
    }
}

package common.concurrent.lock.impl;
 
import com.hazelcast.core.Hazelcast;
import com.hazelcast.core.HazelcastInstance;
import com.hazelcast.core.IMap;
import common.concurrent.lock.DistributedLock;
import common.concurrent.lock.DistributedLocker;
 
import java.util.concurrent.TimeUnit;
 
public class HzMapBasedDistributedLocker implements DistributedLocker {
    private IMap txLockMap;
 
    public HzMapBasedDistributedLocker(){
        HazelcastInstance hazelcastInstance = Hazelcast.newHazelcastInstance();
        txLockMap = hazelcastInstance.getMap("txLockMap");
    }
 
    @Override
    public DistributedLock getLock(String lockKey) {
        return new HzMapBasedLock(lockKey);
    }
 
    private class HzMapBasedLock implements DistributedLock{
        private final String key;
 
        public HzMapBasedLock(String key) {
            this.key = key;
        }
 
        @Override
        public void lock() {
            txLockMap.lock(key);
        }
 
        @Override
        public boolean tryLock() {
            return txLockMap.tryLock(key);
        }
 
        @Override
        public boolean tryLock(long timeout, TimeUnit unit) {
            try {
                return txLockMap.tryLock(key, timeout, unit);
            } catch (Exception e) {
                throw new RuntimeException("Error while acquiring lock", e);
            }
        }
 
        @Override
        public boolean isLocked() {
            return txLockMap.isLocked(key);
        }
 
        @Override
        public void release() {
            try {
                txLockMap.unlock(key);
            } catch (Exception e){
                throw new RuntimeException("Error while releasing lock", e);
            }
        }
    }
}

package common.concurrent.lock.impl;
 
import com.hazelcast.config.Config;
import com.hazelcast.core.Hazelcast;
import com.hazelcast.core.HazelcastInstance;
import com.hazelcast.cp.lock.FencedLock;
import common.concurrent.lock.DistributedLock;
import common.concurrent.lock.DistributedLocker;
 
import java.util.concurrent.TimeUnit;
 
public class HzLockBasedDistributedLocker implements DistributedLocker {
    private HazelcastInstance hazelcastInstance;
 
    public HzLockBasedDistributedLocker(int cpMemberCount){
        Config config = new Config();
        config.getCPSubsystemConfig().setCPMemberCount(3);
        config.getCPSubsystemConfig().setGroupSize(3);
        hazelcastInstance = Hazelcast.newHazelcastInstance(config);
    }
 
    @Override
    public DistributedLock getLock(String key) {
        return wrapHzLock(key);
    }
 
    private DistributedLock wrapHzLock(String key){
        return new HzLock(key);
    }
 
    private class HzLock implements DistributedLock {
        private final FencedLock lock;
 
        public HzLock(String key) {
            this.lock = hazelcastInstance.getCPSubsystem().getLock(key);
        }
 
        @Override
        public void lock() {
            lock.lock();
        }
 
        @Override
        public boolean tryLock() {
            return lock.tryLock();
        }
 
        @Override
        public boolean tryLock(long timeout, TimeUnit unit) {
            try {
                return lock.tryLock(timeout, unit);
            } catch (Exception e) {
                throw new RuntimeException("Error while acquiring lock", e);
            }
        }
 
        @Override
        public boolean isLocked() {
            return lock.isLocked();
        }
 
        @Override
        public void release() {
            try {
                lock.unlock();
                //((DistributedObject) lock).destroy();
            } catch (Exception e){
                throw new RuntimeException("Error while releasing lock", e);
            }
        }
    }
}