分布式锁_数据库分布式锁实践

最新推荐文章于 2024-05-21 20:16:28 发布
最新推荐文章于 2024-05-21 20:16:28 发布
阅读量338 收藏 1
点赞数
分类专栏： 分布式 Java 文章标签： 分布式锁 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AndroidMage/article/details/119235852
版权

分布式锁_数据库分布式锁实践

环境说明

ubuntu: 20.04
jdk: 1.8
postgresql: 12
mybatis: 3.5.7

数据库

sudo apt install postgresql

创建数据库用户"myuser"

sudo su postgres -c "createuser -D -A -P myuser"
# 这里需要输入密码，我这里使用"myuser"

创建数据库**“mydb”** 分配权限给"myuser"

sudo su postgres -c "createdb -O myuser mydb"

创建表

登录数据库

sudo su postgres -c "psql -d mydb"

建表语句

CREATE TABLE distribute_lock (
	id int4 NOT NULL GENERATED BY DEFAULT AS IDENTITY,
	resource_code varchar(255) NOT NULL,
	resource_name varchar NULL,
	create_time varchar NOT NULL DEFAULT CURRENT_TIME,
	CONSTRAINT distribute_lock_pk PRIMARY KEY (id)
);
CREATE UNIQUE INDEX distribute_lock_resource_code_idx ON distribute_lock USING btree (resource_code);

COMMENT ON COLUMN distribute_luck.id IS '主键自增';
COMMENT ON COLUMN distribute_luck.resource_code IS '资源code';
COMMENT ON COLUMN distribute_luck.resource_name IS '资源名称';
COMMENT ON COLUMN distribute_lock.create_time IS '创建时间';

ALTER TABLE distribute_lock OWNER TO myuser;

Java代码开发

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.quange</groupId>
	<artifactId>distribute-lock</artifactId>
	<version>1.0</version>

	<dependencies>
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>3.5.7</version>
		</dependency>

		<dependency>
			<groupId>org.postgresql</groupId>
			<artifactId>postgresql</artifactId>
			<version>42.2.23</version>
		</dependency>
        <dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>RELEASE</version>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<properties>
		<maven.compiler.source>8</maven.compiler.source>
		<maven.compiler.target>8</maven.compiler.target>
	</properties>
</project>

数据库分布式锁实现类

DbDistributeLock.java


import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import org.apache.ibatis.session.SqlSession;

public class DbDistributeLock implements DistributeLock {
	// 缓存SqlSession，用于释放锁
    ThreadLocal<SqlSession> cache = new ThreadLocal<>();
	// 用于资源没有时，进行创建资源时控制并发
    static Map<String, String> resourceMap = new ConcurrentHashMap<>();

    /**
     * mybatis 动态的设置超时时间，比较复杂，这里使用另一中方案， 默认超时10s, 多次去获取锁。
     * @param resource
     * @param timeout 单位:每10秒
     * @return
     */
	public boolean lock(String resource, int timeout) {
        do {
        	try {
        		SqlSession sqlSession = MybatisUtil.getSqlSessionFactory().openSession(false);
                DistributeLockMapper mapper = sqlSession.getMapper(DistributeLockMapper.class);
                DistributeLockDO distributeLockDO = null;
                if (timeout == -1) {
                	distributeLockDO = mapper.selectForUpdate(resource);
                } else {
                	distributeLockDO = mapper.selectForUpdateWithTimeout(resource);
                }
                if (distributeLockDO != null) {
                    cache.set(sqlSession);
                    resourceMap.remove(resource);
                    return true;
                } else {
                    if (!resourceMap.containsKey(resource)) {
                        insertResource(mapper, resource);
                        sqlSession.commit(true);
                    }
                    continue;
                }
			} catch (Exception e) {
				Log.d("timeout");
			}
        } while (timeout == -1 || timeout > 0);
        return false;
    }
	// 资源不存在时，插入资源
    private void insertResource(DistributeLockMapper mapper, String resource) {
        try {
            resource = resource.intern();
            synchronized (resource) {
                if (!resourceMap.containsKey(resource)) {
                    Log.d("insert " + resource );
                    DistributeLockDO distributeLockDO = new DistributeLockDO();
                    distributeLockDO.setResourceCode(resource);
                    distributeLockDO.setResourceName("lock " + resource);
                    mapper.insertDistributeLock(distributeLockDO);
                    resourceMap.put(resource, resource);
                    Log.d("insert success");
                }
            }
        } catch (Exception e){
            Log.d("insert error" );
        }
    }

    @Override
    public boolean lock(String resource) {
        return lock(resource, -1);
    }

    
    @Override
    public void unLock(String resource) {
        SqlSession sqlSession = cache.get();
        if (sqlSession != null) {
            sqlSession.commit(true);
            sqlSession.close();
        }
    }
}

工具类

MybatisUtil.java


import org.apache.ibatis.datasource.pooled.PooledDataSource;
import org.apache.ibatis.mapping.Environment;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.apache.ibatis.transaction.TransactionFactory;
import org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory;

import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class MybatisUtil {
    private static class SqlSessionFactoryHolder {
        private static SqlSessionFactory sqlSessionFactory = createSqlSessionFactory();
    }

    private final static SqlSessionFactory createSqlSessionFactory() {
        // 可以从配置文件中获取，这里就简单hard code
        DataSource dataSource = new PooledDataSource("org.postgresql.Driver", "jdbc:postgresql://localhost:5432/mydb", "myuser", "myuser");
        TransactionFactory transactionFactory = new JdbcTransactionFactory();
        Environment environment = new Environment("development", transactionFactory, dataSource);
        Configuration configuration = new Configuration(environment);
        configuration.setMapUnderscoreToCamelCase(true);
        configuration.addMapper(DistributeLockMapper.class);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(configuration);
        return sqlSessionFactory;
    }

    public final static SqlSessionFactory getSqlSessionFactory() {
        return SqlSessionFactoryHolder.sqlSessionFactory;
    }
}

DistributeLockMapper.java

import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Options;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

public interface DistributeLockMapper {
	// 因为简单，使用注解的方式
    @Options(timeout = 10)
    @Select("select id, resource_code, resource_name from distribute_lock where resource_code = #{resourceCode} for update")
    DistributeLockDO selectForUpdateWithTimeout(@Param("resourceCode") String resourceCode);
	
    @Select("select id, resource_code, resource_name from distribute_lock where resource_code = #{resourceCode} for update")
    DistributeLockDO selectForUpdate(@Param("resourceCode") String resourceCode);

    
    @Insert("insert into distribute_lock (resource_code, resource_name) values ('${resourceCode}', '${resourceName}')")
    int insertDistributeLock(DistributeLockDO distributeLockDO);
}

DistributeLockDO.java

public class DistributeLockDO {
    private Long id;
    private String resourceCode;
    private String resourceName;
	// 省略get set 方法
}

其他不重要类

点击查看 

public interface DistributeLock {
    boolean lock(String resource);
    boolean unLock(String resource);
}

public enum DistributeLockType {
DB,
REDIS,
ZOOKEEPER
}
public class DistributeLockFactory {
public static DistributeLock getDistributeLock() {
return new DbDistributeLock();
}
public static DistributeLock getDistributeLock(DistributeLockType type) {
switch (type) {
case REDIS:
return new RedisDistributeLock();
case ZOOKEEPER:
return new ZkDistributeLock();
default:
return new DbDistributeLock();
}
}
}
public class Log {
public static void d(String msg) {
System.out.println(System.currentTimeMillis() + " - " + Thread.currentThread().getName() + " - " + msg );
}
}

单进程测试

DbDistributeLockTest.java

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;

import org.junit.Test;

public class DbDistributeLockTest {
    public volatile static int j = 1;
    @Test
    public void testDbDistributeLock() {
        DistributeLock distributeLock = DistributeLockFactory.getDistributeLock();
        int threadCount = 10;
        CyclicBarrier cyclicBarrier = new CyclicBarrier(threadCount);// 控制开始
        CountDownLatch countDownLatch = new CountDownLatch(threadCount); // 控制等待并发结束
        for (int i = 0; i <threadCount; i++) {
            new Thread(()->{
                try {
                    cyclicBarrier.await();// 控制并发
                    String resource = "testcode22";
                    Log.d("to get lock: " + resource);
                    boolean locked = distributeLock.lock(resource);
                    if (locked) {
                    	Log.d("has get lock: " + resource);
                        Thread.sleep(1000); // 模拟业务耗时
                        distributeLock.unLock(resource);
                        Log.d("release lock: " + resource);
                    } else {
                    	Log.d("not get lock: " + resource);
                    }
                    countDownLatch.countDown();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }
        try {
            countDownLatch.await();  // 等待并发结束
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

多进程测试

Main.java


import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;

public class Main {
	public static void main(String[] args) { 
        String resource = (args != null && args.length > 0)? args[0] : "testcode"; // 资源
        String tid = (args != null && args.length > 1)? args[1] : "0"; // 线程标识
        int threadCount = Integer.parseInt((args != null && args.length > 2)? args[2] : "5"); // 并发线程

        CyclicBarrier cyclicBarrier = new CyclicBarrier(threadCount);
        CountDownLatch countDownLatch = new CountDownLatch(threadCount);
        MybatisUtil.getSqlSessionFactory(); // 提前初始化SqlSessionFactory
        DistributeLock distributeLock = DistributeLockFactory.getDistributeLock();
        for (int i = 0; i <threadCount; i++) {
            new Thread(()->{
                try {
                    cyclicBarrier.await();
                    Log.d("to get lock: " + resource);
                    boolean locked = distributeLock.lock(resource);
                    if (locked) {
                    	Log.d("has get lock: " + resource);
                        Thread.sleep(1000);
                        distributeLock.unLock(resource);
                        Log.d("release lock: " + resource);
                    } else {
                    	Log.d("not get lock: " + resource);
                    }
                    countDownLatch.countDown();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "Thread-"+ tid + "-"+i).start();
        }
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
	}
}

打包：

cd <项目代码路径>
mkdir -p $HOME/Test/DistributeLock/lib
mvn dependency:copy-dependencies -DoutputDirectory=$HOME/Test/DistributeLock/lib
mvn clean package
cp target/distribute-lock-1.0.jar $HOME/Test/DistributeLock/lib

启动脚本：

在**$HOME/Test/DistributeLock/目录下编写启动脚本app.sh**

app.sh

#!/bin/bash

# main入口类
main=com.quange.Main
resource=$1
if [ "$resource" == "" ]; then
resource=testcode$(($RANDOM%100))
fi

workdir=$(dirname $0)
cd $workdir
app_classpath=`find lib -name "*.jar" | xargs | sed "s/ /:/g"`
echo $app_classpath

for ((i=1;i<=5;i++));
do
nohup java -cp $app_classpath $main $resource $i 2>&1 >> test.log &
done

将所有的进程日志都保存到test.log中便于查询而已。

测试：

./app.sh resource_11

结果：

点击查看test.log 
 
1627369194450 - Thread-4-3 - to get lock: resourc_11
1627369194451 - Thread-4-0 - to get lock: resourc_11
1627369194451 - Thread-4-2 - to get lock: resourc_11
1627369194451 - Thread-4-1 - to get lock: resourc_11
1627369194451 - Thread-4-4 - to get lock: resourc_11
1627369194563 - Thread-5-3 - to get lock: resourc_11
1627369194564 - Thread-5-0 - to get lock: resourc_11
1627369194566 - Thread-5-2 - to get lock: resourc_11
1627369194567 - Thread-5-4 - to get lock: resourc_11
1627369194563 - Thread-5-1 - to get lock: resourc_11
1627369194626 - Thread-1-4 - to get lock: resourc_11
1627369194627 - Thread-1-1 - to get lock: resourc_11
1627369194627 - Thread-1-2 - to get lock: resourc_11
1627369194627 - Thread-1-3 - to get lock: resourc_11
1627369194627 - Thread-1-0 - to get lock: resourc_11
1627369194652 - Thread-3-4 - to get lock: resourc_11
1627369194653 - Thread-3-0 - to get lock: resourc_11
1627369194653 - Thread-3-2 - to get lock: resourc_11
1627369194654 - Thread-3-1 - to get lock: resourc_11
1627369194664 - Thread-3-3 - to get lock: resourc_11
1627369194960 - Thread-2-0 - to get lock: resourc_11
1627369194961 - Thread-2-1 - to get lock: resourc_11
1627369194962 - Thread-2-4 - to get lock: resourc_11
1627369194975 - Thread-2-2 - to get lock: resourc_11
1627369194975 - Thread-2-3 - to get lock: resourc_11
1627369195897 - Thread-1-4 - insert resourc_11
1627369195906 - Thread-4-2 - insert resourc_11
1627369195911 - Thread-5-1 - insert resourc_11
1627369196123 - Thread-1-4 - insert success
1627369196207 - Thread-1-3 - has get lock: resourc_11
1627369196287 - Thread-4-1 - insert resourc_11
1627369196290 - Thread-4-1 - insert error
1627369196290 - Thread-4-4 - insert resourc_11
1627369196292 - Thread-4-4 - insert error
1627369196294 - Thread-4-3 - insert resourc_11
1627369196298 - Thread-4-3 - insert error
1627369196311 - Thread-4-2 - insert error
1627369196366 - Thread-5-0 - insert resourc_11
1627369196372 - Thread-5-0 - insert error
1627369196373 - Thread-5-4 - insert resourc_11
1627369196375 - Thread-5-4 - insert error
1627369196382 - Thread-5-1 - insert error
1627369197213 - Thread-1-3 - release lock: resourc_11
1627369197217 - Thread-4-0 - has get lock: resourc_11
1627369198272 - Thread-4-0 - release lock: resourc_11
1627369198273 - Thread-1-2 - has get lock: resourc_11
1627369199335 - Thread-1-2 - release lock: resourc_11
1627369199338 - Thread-5-3 - has get lock: resourc_11
1627369200472 - Thread-5-3 - release lock: resourc_11
1627369200472 - Thread-4-1 - has get lock: resourc_11
1627369201609 - Thread-4-1 - release lock: resourc_11
1627369201610 - Thread-4-2 - has get lock: resourc_11
1627369202741 - Thread-4-2 - release lock: resourc_11
1627369202741 - Thread-5-2 - has get lock: resourc_11
1627369203871 - Thread-5-2 - release lock: resourc_11
1627369203871 - Thread-1-4 - has get lock: resourc_11
1627369205006 - Thread-1-4 - release lock: resourc_11
1627369205006 - Thread-4-3 - has get lock: resourc_11
1627369206103 - Thread-4-3 - release lock: resourc_11
1627369206104 - Thread-1-0 - has get lock: resourc_11
1627369207108 - Thread-1-0 - release lock: resourc_11
1627369207109 - Thread-4-4 - has get lock: resourc_11
1627369208147 - Thread-4-4 - release lock: resourc_11
1627369208148 - Thread-5-1 - has get lock: resourc_11
1627369209284 - Thread-5-1 - release lock: resourc_11
1627369209285 - Thread-1-1 - has get lock: resourc_11
1627369210315 - Thread-1-1 - release lock: resourc_11
1627369210342 - Thread-3-2 - has get lock: resourc_11
1627369211478 - Thread-3-2 - release lock: resourc_11
1627369211478 - Thread-5-0 - has get lock: resourc_11
1627369212612 - Thread-5-0 - release lock: resourc_11
1627369212612 - Thread-5-4 - has get lock: resourc_11
1627369213747 - Thread-5-4 - release lock: resourc_11
1627369213747 - Thread-3-4 - has get lock: resourc_11
1627369214802 - Thread-3-4 - release lock: resourc_11
1627369214802 - Thread-3-0 - has get lock: resourc_11
1627369215805 - Thread-3-0 - release lock: resourc_11
1627369215834 - Thread-2-0 - has get lock: resourc_11
1627369216839 - Thread-2-0 - release lock: resourc_11
1627369216840 - Thread-3-1 - has get lock: resourc_11
1627369217846 - Thread-3-1 - release lock: resourc_11
1627369217846 - Thread-2-3 - has get lock: resourc_11
1627369218855 - Thread-2-3 - release lock: resourc_11
1627369218856 - Thread-3-3 - has get lock: resourc_11
1627369219859 - Thread-3-3 - release lock: resourc_11
1627369219861 - Thread-2-1 - has get lock: resourc_11
1627369220864 - Thread-2-1 - release lock: resourc_11
1627369220865 - Thread-2-4 - has get lock: resourc_11
1627369221870 - Thread-2-4 - release lock: resourc_11
1627369221870 - Thread-2-2 - has get lock: resourc_11
1627369222877 - Thread-2-2 - release lock: resourc_11

总结：

Mybatis动态控制查询的超时时间比较复杂，这里使用默认超时10s, 循环获取锁。

IT泉哥
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
postgresql锁
归来仍少年
03-06 1411
postgresql锁 postgresql中根据不同的对象，不同使用场景，使用三种不同的锁，spinLock,LWLock,Lock spinLock:自旋锁，是并发场景下，保护共享资源的有一种机制。实现的成本最低，一般是使用基于硬件的TAS（test-and-set）操作。 SpinLock不能用于需要长久持有锁的逻辑，在postgresql中，spinlock主要用于对于临界变量的并发访问控制，所保护的临界区通常是简单的赋值语句来，读取语句等等。 特点： 申请锁的进程一直在额尝试能否加锁成功，只有等
数据库(DataBase)-SQL注入问题代码举例
EdwinD的博客
05-24 525
SQL注入问题 sql存在漏洞，容易导致数据泄露 本文数据库： CREATE DATABASE JdbcStudy CHARACTER SET utf8 COLLATE utf8_general_ci; USE JdbcStudy; CREATE TABLE `users`( `id` INT PRIMARY KEY, `NAME` VARCHAR(40), `PASSWORD` VARCHAR(40), `email` VARCHAR(60), `birthday` DATE ); INS
Postgresql源码（132）分布式行锁的原理分析
最新发布
InternalsOf
05-21 1104
PG中的行锁在上一片中做了分析，本篇对分布式PG（PGXL）中的行锁做一些分析。（版本：Postgres-XL 10alpha2）
PostgreSQL锁详解
myneth的博客
06-29 1353
postgresql锁
PostgreSQL中的锁
Lee Hom 's Column
02-18 1559
#0. 基础介绍---spinLock.   PostgreSQL中关于spinLock的描述被放在spin.h和spin.c中。spin.h 中为硬件（平台）无关spinlock的实现的描述.    在实现时尤其需要注意是volatile 类型的使用；在使用该类型时候，在变量在内存中发生变化时候，不能够在使用该限定符来修饰变量，对于其中原因见：Lock-free Queue Impl
Docker单点部署Seata(2.0.0) + Nacos(v2.3.0) + Mysql(5.7)
m0_51390969的博客
12-30 2727
系统环境mysqlseata三者都在bridge网络中。
新浪：基于MySQL的分布式数据库实践1
08-08
"新浪基于MySQL的分布式数据库实践1" 分布式数据库实践是指在多个服务器上部署和管理数据库，以提高数据库的性能、可扩展性和可靠性。在这个实践中，新浪使用了基于MySQL的分布式数据库实践，实现了高性能、可扩展...
分布式图数据库NebulaGraph的Index实践
03-03
虽然索引可以带来更高的查询性能，但是也存在一些缺点，例如：NebulaGraph作为一个高性能的分布式图数据库，对于属性值的高性能查询，同样也实现了索引功能。本文将对NebulaGraph的索引功能做一个详细介绍。开始之前...
分布式相关面试题汇总：分布式锁、分布式事务、分布式缓存、分布式ID
01-12
常见的分布式锁实现包括基于Zookeeper、Redis或数据库的分布式锁，它们通常采用乐观锁或悲观锁策略，确保在多个节点间安全地进行资源访问。 分布式事务则涉及多个节点之间的数据一致性保证。本地事务在单一资源管理...
详解一种用django_cache实现分布式锁的方式
09-18
在实践中，作者选择了结合 SETNX 和 SET 命令的策略，通过键名设置锁，并设置过期时间。在 Django 中，这可以通过 `add` 方法实现类似 SETNX 的效果，通过 `set` 方法设置过期时间。 **代码实现** 作者定义了一个 ...
分布式数据库--30讲
10-17
分布式数据库是学术研究与工业实践的完美结合，深入其中你会看到很多极致的设计方法。 分布式数据库的学习路径可以从数据库开始，包括存储设计、事务模型、查询引擎、复制和其他几个方面。学习分布式数据库可以帮助...
pals:使用PostgreSQL咨询锁轻松进行分布式锁
05-14
PostgreSQL咨询锁（PAL） 介绍 PAL使使用轻松进行分布式应用程序级锁定。 不要将这种类型的锁定与PostgreSQL中的表或行锁定混淆。 这不是同一回事。 可以通过使用Redis，Memcache，ZeroMQ等来实现分布式应用程序级别锁定。 但是对于那些已经在使用PostgreSQL人来说，无需其他服务的设置和管理。 用法 安装方式： pip install PALs 然后用法如下： import datetime as dt import pals # Think of the Locker instance as a Lock factory. locker = pals . Locker ( 'my-app-name' , 'postgresql://user:pass@server/dbname' ) lock1 = locker . lock ( 'my-
distlock:Postgres支持的分布式锁
04-14
DistLock Dist锁通过postgres实现了分布式锁。 目标 没有交易。 单个管理器使用单个DB连接。 清理数据库会在进程死亡时锁定。 在数据库断开连接时清理应用程序簿记。 基于ctx的api。 分配友好 当前的1m轮廓 54625 1347103 ns/op 517 B/op 11 allocs/op 分配 DistLock希望表现出色。 不幸的是，利用上下文实现意味着您无法合并使用已完成的通道。 它们必须关闭并且不能重复使用。 尽管如此，我们仍可以汇总自己的频道使用情况，以向卫队提出请求和做出响应。 ROUTINE ======================== github.com/ldelossa/distlock.(*Manager).Lock in /home/louis/git/go/di
java7源码-distributed-lock:分布式锁
06-04
java7 源码 现在面试都会聊聊分布式系统，通常面试官都会从服务框架（Spring Cloud、Dubbo），一路聊到分布式事务、分布式锁、ZooKeeper等知识。今天就来聊聊分布式锁这块的知识，先具体的来看看Redis分布式锁的实现原理。 如果在公司里落地生产环境用分布式锁的时候，一定是会用开源类库的，比如Redis分布式锁，一般就是用Redisson框架就好了，非常的简便易用。感兴趣可以去Redisson官网看看如何在项目中引入Redisson的依赖，然后基于Redis实现分布式锁的加锁与释放锁。 一段简单的使用代码片段，先直观的感受一下： 是不是感觉简单的不行！此外，还支持Redis单实例、Redis哨兵、Redis Cluster、redis master-slave等各种部署架构，都可以完美实现。 一、Redisson实现Redis分布式锁的底层原理 现在通过一张手绘图，说说Redisson这个开源框架对Redis分布式锁的实现原理。 1、加锁机制 看上面那张图，现在某个客户端要加锁。如果该客户端面对的是一个Redis Cluster集群，他首先会根据Hash节点选择一台
咨询锁：使用PostgreSQL咨询锁（Node.js）进行分布式锁
02-05
咨询锁 使用分布式。 一些用例： 您有一个并且要绝对确保在任何给定时间都不会有多个进程处于活动状态。 如果由于意外事件或在部署过程中按比例扩大了时钟进程，这种情况会使旧版本保持运行，直到新版本响应运行状况检查，则可能会出现这种情况。 在服务器启动时运行数据库迁移。 如果您的应用程序得到扩展，则多个进程将同时尝试运行数据库迁移，这可能会导致问题。 领导人选举。 假设您有一个Web应用程序，并且想每30分钟向Slack发布一条包含一些统计信息的消息（例如，最近30分钟内的新注册）。 您可能正在运行10个进程，但不想在Slack中获得10条相同的消息。 您可以使用该库来选择一个“主”进程
基于SpringBoot与数据库表记录的方式实现分布式锁
qq3164069700的博客
01-08 1013
同一进程内的不同线程操作共享资源时，我们只需要对资源加锁，比如利用JUC下的工具，就可以保证操作的正确性。对JUC不熟悉的同学，可以看看以下的几篇文章： 浅说Synchronized Synchronized的优化 JUC基石——Unsafe类 但是，为了高可用，我们的系统总是多副本的，分布在不同的机器上，以上同进程内的锁机制就不再起作用。为了保证多副本系统对共享资源的访问，我们引入了分布式锁。 分布式锁主要的实现方式有以下几种： 基于数据库的，其中又细分为基于数据库的表记录、悲观锁、乐观锁 ..
基于数据库的分布式锁实现
热门推荐
lmb55的专栏
11-10 1万+
一、基于数据库表 要实现分布式锁，最简单的方式可能就是直接创建一张锁表，然后通过操作该表中的数据来实现了。当我们要锁住某个方法或资源的时候，我们就在该表中增加一条记录，想要释放锁的时候就删除这条记录。 创建这样一张数据库表： CREATE TABLE `methodLock` ( `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键', ...
Postgresql杂谈 16—Postgresql中的锁机制
Hyman的博客
08-13 6439
今天，我们学习下Postgresql中的锁机制。锁是数据库事务的基础，通过锁才能保证数据库在并发时能够保证数据的安全和一致，才能够达到事务的一致性和隔离性。但是任何事物都有它的两面性，引入锁同样会增加性能开销和可能的死锁问题，不过好在都存在解决方法。Postgresql和其它数据库一样，从锁作用的对象上来说可以分为表锁、行锁两种，从排他性来说可以大体分为共享锁和排他锁，但是由于Postgresql是通过多版本的方式对数据库进行更新，它也引入了Access锁。接下来我们就对这些内容分类进行学习。...
分布式锁-进阶
Eddie'Blog
02-06 260
文章目录distributed-lockdistribute-demo （单体项目）模拟一超卖现象一超卖现象二Synchronized 方法锁Synchronized 块锁ReentrantLock锁 （并发包中的锁）distribute-lock （分布式锁）单体应用锁存在的问题演示代码数据库实现分布式锁 (悲观锁)Navicat演示效果代码演示基于Redis的Setnx实现分布式锁实现原理LUA脚本原理图解代码演示Zookeeper分布式锁代码实现代码演示基于Zookeeper的Curator客户端实现
悲观锁 版本号机制 redis分布式锁
09-17
在具体实践中，选择悲观锁还是版本号机制还是Redis分布式锁，需要根据具体应用场景和需求来决定。如果资源冲突较为频繁，可以考虑使用悲观锁；如果资源冲突较少，可使用版本号机制；如果需要在分布式环境下控制并发...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值