当前位置： 首页 > news >正文

零售网站有哪些平台外呼系统电销

news 2025/7/15 18:27:32
零售网站有哪些平台,外呼系统电销,十大设计网站排名,学习电商运营去哪里学1、为什么要使用分布式锁 锁是多线程代码中的概念，只有多任务访问同一个互斥的共享资源时才需要锁。单机应用开发时一般使用synchronized或lock。多线程的运行都是在同一个JVM之下。应用是分布式集群，属于多JVM的工作环境，JVM之间已经无法通过…

1、为什么要使用分布式锁

  1. 锁是多线程代码中的概念，只有多任务访问同一个互斥的共享资源时才需要锁。
  2. 单机应用开发时一般使用synchronized或lock。多线程的运行都是在同一个JVM之下。
  3. 应用是分布式集群，属于多JVM的工作环境，JVM之间已经无法通过多线程的锁解决同步问题。

 

2、分布式锁的几种方式

分布式锁的核心思路是借助外力 解决多JVM进程操作共享数据时需要使用互斥锁的问题。

常见的方式 有：

  1. mysql数据库分布式锁
  2. zookeeper分布式锁
  3. redis分布式锁

3、搭建测试分布式锁的环境

【1】创建工程distributed-lock-study ，pom如下

父工程

<?xml version="1.0" encoding="UTF-8"?>
<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><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.7.6</version><relativePath/> <!-- lookup parent from repository --></parent><groupId>com.lyx</groupId><artifactId>distributed-lock-study</artifactId><version>0.0.1-SNAPSHOT</version><packaging>pom</packaging><name>distributed-lock-study</name><description>distributed-lock-study</description><modules><module>moduleA</module><module>moduleB</module></modules><properties><java.version>8</java.version><dubbo.starter>2.7.6</dubbo.starter><dubbo.registry.zookeeper>2.7.6</dubbo.registry.zookeeper><mysql-connection.version>8.0.26</mysql-connection.version><druid.version>1.2.1</druid.version><mybatis-plus.version>3.5.2</mybatis-plus.version><hutool.version>5.7.17</hutool.version></properties>
<dependencyManagement><dependencies><!-- Dubbo 依赖 --><dependency><groupId>org.apache.dubbo</groupId><artifactId>dubbo-spring-boot-starter</artifactId><version>${dubbo.starter}</version></dependency><!-- zookeeper 注册中心 依赖 --><dependency><groupId>org.apache.dubbo</groupId><artifactId>dubbo-registry-zookeeper</artifactId><version>${dubbo.registry.zookeeper}</version></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>${mysql-connection.version}</version><scope>runtime</scope></dependency><!--druid连接池--><dependency><groupId>com.alibaba</groupId><artifactId>druid-spring-boot-starter</artifactId><version>${druid.version}</version></dependency><!--mybatis-plus依赖--><dependency><groupId>com.baomidou</groupId><artifactId>mybatis-plus-boot-starter</artifactId><version>${mybatis-plus.version}</version></dependency><!--hutool--><dependency><groupId>cn.hutool</groupId><artifactId>hutool-all</artifactId><version>${hutool.version}</version></dependency></dependencies></dependencyManagement></project>

 【2】创建moduleA和moduleB两个模块

依赖：

<?xml version="1.0" encoding="UTF-8"?>
<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 http://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><parent><groupId>com.lyx</groupId><artifactId>distributed-lock-study</artifactId><version>0.0.1-SNAPSHOT</version></parent><groupId>org.example</groupId><artifactId>moduleA</artifactId><properties><maven.compiler.source>8</maven.compiler.source><maven.compiler.target>8</maven.compiler.target><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding></properties><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><optional>true</optional></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><!--mybatis-plus依赖--><dependency><groupId>com.baomidou</groupId><artifactId>mybatis-plus-boot-starter</artifactId></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><scope>runtime</scope></dependency><!--druid连接池--><dependency><groupId>com.alibaba</groupId><artifactId>druid-spring-boot-starter</artifactId></dependency><!--redis依赖--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency><!--common-pool--><dependency><groupId>org.apache.commons</groupId><artifactId>commons-pool2</artifactId></dependency><!--  Redisson分布式锁使用--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency><dependency><groupId>org.redisson</groupId><artifactId>redisson-spring-boot-starter</artifactId><version>3.14.0</version></dependency><!--基于Curator 客户端（zookeeper的）实现分布式锁 --><dependency><groupId>org.apache.curator</groupId><artifactId>curator-framework</artifactId><version>4.0.1</version></dependency><dependency><groupId>org.apache.curator</groupId><artifactId>curator-recipes</artifactId><version>4.0.1</version></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId><configuration><excludes><exclude><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId></exclude></excludes></configuration></plugin></plugins></build></project>

 【3】在两个模块中编写application.yml

spring:datasource:type: com.alibaba.druid.pool.DruidDataSourcedriver-class-name: com.mysql.cj.jdbc.Driverurl: jdbc:mysql://127.0.0.1:3306/lock_db?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghaiusername: rootpassword: 123456redis:host: 192.168.184.200port: 6379lettuce:pool:max-active: 8max-idle: 8min-idle: 0max-wait: 100ms
server:port: 1111 # 两个模块的端口号不一样，其他一样

【4】编写启动类

@SpringBootApplication
@MapperScan("top.psjj.ma.mapper")
public class ModuleAApplication {public static void main(String[] args) {SpringApplication.run(ModuleAApplication.class,args);}
}

 【5】准备数据库local_db,并出入下张表

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;-- ----------------------------
-- Table structure for t_goods
-- ----------------------------
DROP TABLE IF EXISTS `t_goods`;
CREATE TABLE `t_goods`  (`id` int(0) NOT NULL AUTO_INCREMENT COMMENT '主键',`goods` varchar(255) CHARACTER SET utf8 COLLATE utf8_unicode_ci NULL DEFAULT NULL,`count` int(0) NULL DEFAULT NULL,PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_unicode_ci ROW_FORMAT = Dynamic;-- ----------------------------
-- Records of t_goods
-- ----------------------------
INSERT INTO `t_goods` VALUES (1, '手机', -1);
INSERT INTO `t_goods` VALUES (2, '笔记本', 100);SET FOREIGN_KEY_CHECKS = 1;

 【6】编写po 、mapper 、service 、controller,两个模块代码完全一样

@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("t_goods")
public class Goods implements Serializable {@Serialprivate static final long serialVersionUID = -9084934747907815210L;@TableId(type = IdType.AUTO)private Integer id;private String goods;private Integer count;
}
public interface GoodsMapper extends BaseMapper<Goods> {@Update("update t_goods set count = count-1 where id=#{id}")void subCount(Integer id);
}

public interface GoodsService extends IService<Goods> {void updateGoodsCount(Integer id);
}

@Service
public class GoodsServiceImpl extends ServiceImpl<GoodsMapper, Goods> implements GoodsService {@Overridepublic void updateGoodsCount(Integer id) {Goods goods = this.baseMapper.selectById(id);Integer count = goods.getCount();if(count>0){try {Thread.sleep(5000);} catch (InterruptedException e) {throw new RuntimeException(e);}this.baseMapper.subCount(id);}}
}
@RestController
@RequestMapping("/goods")
public class GoodsController {@Autowiredprivate GoodsService goodsService;@RequestMapping("/update")public String updateGoodsCount(Integer id){goodsService.updateGoodsCount(id);return "ok";}
}

 

4、基于Mysql实现的分布式锁

4.1 mysql实现分布式锁原理

  • 首先单独分离出一台mysql数据库，所有服务要想操作文件（共享资源），那么必须先在mysql数据库中插入一个标志，插入标志的服务就持有了锁，并对文件进行操作 。
  • 操作完成后，主动删除标志进行锁释放，其余服务会一直查询数据库，看是否标志有被占用，直到没有标志占用时自己才能写入标志获取锁。

4.2  问题

  1. 如果服务（jvm1）宕机或者卡顿了，会一直持有锁未释放，造成死锁。因此需要一个监视锁进程，时刻监视锁的状态，如果超过一定时间未释放就要进行主动清理锁标记，然后供其他服务继续获取锁。
  2. 如果监视锁字段进程和jvm1同时挂掉，依旧不能解决死锁问题，于是又增加一个监视锁字段进程，这样一个进程挂掉，还有另一个监视锁字段进程可以对锁进行管理。
  3. 但是又诞生一个新的问题，两个监视进程必须进行同步，否则对于过期的情况管理存在不一致问题。

因此存在以下问题，并且方案变得很复杂：

  1. 监视锁字段进程对于锁的监视时间周期过短，仍旧会造成多售（jvm1还没处理完其持有的锁就被主动销毁，造成多个服务同时持有锁进行操作）。

  2. 监视锁字段进程对于锁的监视时间周期过长，会造成整个服务卡顿过长，吞吐低下。

  3. 多个监视锁字段进程间的同步问题。

  4. 当一个jvm持有锁的时候，其余服务会一直访问数据库查看锁，会造成其余jvm的资源浪费。

4.2 基于update实现分布锁（特殊情况）

关于分布式锁，因为代码直接执行语句，有数据库行级锁，不会产生超卖问题。

mysql行锁解决分布锁问题演示修改的代码： 

ServiceImpl中：

//mysql行锁解决分布锁问题
try {Thread.sleep(5000);
} catch (InterruptedException e) {throw new RuntimeException(e);
}
this.baseMapper.subCount2(goods);

mapper中： 

@Update("update t_goods set count=count-1 where id=#{id} and count>0")
void subCount2(Goods goods);

 

5、基于Redis实现分布式锁

 

5.1 Redis实现分布式锁优点

（1）Redis有很高的性能； 

（2）Redis命令对此支持较好，实现起来比较方便

命令介绍:

setnx ：

SETNX key val：当且仅当key不存在时，set一个key为val的字符串，返回1；若key存在，则什么都不做，返回0。

expire :

expire key timeout：为key设置一个超时时间，单位为second，超过这个时间锁会自动释放，避免死锁。

delete :

 delete key：删除key

 在使用Redis实现分布式锁的时候，主要就会使用到这三个命令。

 

5.2 Redis实现分布式锁原理

  1. 获取锁的时候，使用setnx加锁，并使用expire命令为锁添加一个超时时间，超过该时间则自动释放锁，锁的value值为一个随机生成的UUID，通过此在释放锁的时候进行判断。
  2. 获取锁的时候还设置一个获取的超时时间，若超过这个时间则放弃获取锁。
  3. 释放锁的时候，通过UUID判断是不是该锁，若是该锁，则执行delete进行锁释放。

 

5.3 Redisson分布式锁使用

1)引入依赖

<!--  Redisson分布式锁使用-->
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId>
</dependency><dependency><groupId>org.redisson</groupId><artifactId>redisson-spring-boot-starter</artifactId><version>3.14.0</version>
</dependency>

2)配置文件

spring:redis:host: 192.168.220.110port: 6379

3)代码实现

//创建锁
RLock lock = redissonClient.getLock("goods-" + id);
//加锁
try {lock.lock();Goods goods = this.baseMapper.selectById(id);Integer count = goods.getCount();if(count>0){try {Thread.sleep(5000);} catch (InterruptedException e) {throw new RuntimeException(e);}this.baseMapper.subCount(id);}
} catch (RuntimeException e) {throw new RuntimeException("超卖了");
} finally {//释放锁lock.unlock();
}

5.4 总结

可以使用缓存代替数据库实现分布式锁，性能根号。同时多数缓存服务时集群部署，可以避免单点问题。

很多缓存服务提供了实现分布式锁的方法和对数据过期自动删除的支持，如Tair的put方法，redis 的setnx方法(Redisson是Redis官方推荐的Java版的Redis客户端) 。可以设置超时时间控制锁的释放。

使用缓存实现分布式锁的优点：性能好，实现起来较为方便。

使用缓存实现分布式锁的缺点 ：通过超时时间来控制所得失效时间不靠谱。

6、 基于Zookeeper实现的分布式锁

6.1 Zookeeper的特点

Zookeeper的每一个节点，都是一个天然的顺序发号器，zookeeper有以下特点：

  1. 维护了一个有层次的数据节点，类似文件系统。

  2. 有临时节点，持久节点，临时有序节点（分布式锁实现基于的数据节点) ，持久有序节点。

  3. zookeeper可以和client客户端通过心跳机制保持长连接，断开连接自动删除临时节点。

  4. zookeeper的节点上可以注册上用户事件(自定义)，节点数据删除等事件都可以触发自定义事件。

  5. zookeeper保持了统一视图，各服务对于状态信息获取满足一致性。

创建有序节点会有编号：

6.2 Zookeeper实现分布式锁原理

  1. 创建一个目录mylock；

  2. 线程A想获取锁就在mylock目录下创建临时顺序节点；

  3. 获取mylock目录下所有的子节点，然后获取比自己小的兄弟节点，如果不存在，则说明当前线程顺序号最小，获得锁；

  4. 线程B获取所有节点，判断自己不是最小节点，设置监听比自己小的节点；

  5. 线程A处理完，删除自己的节点，线程B监听到变更事件，判断自己是不是最小的节点，如果是则获得锁。

6.3 Zookeeper解决的问题

锁无法释放？

在创建锁的时候，客户端会在ZK中创建一个临时节点，一旦客户端获取到锁之后突然挂掉（Session连接断开），那么这个临时节点就会自动删除掉。锁就会释放。

非阻塞锁？

客户端可以通过在ZK中创建顺序节点，并且在节点上绑定监听器，一旦节点有变化，Zookeeper会通知客户端，客户端可以检查自己创建的节点是不是序号最小，如果是，那么自己就获取到锁。

不可重入？  

客户端在创建节点的时候，把当前客户端的主机信息和线程信息直接写入到节点中，下次想要获取锁的时候和当前最小的节点中的数据比对。如果信息一样，直接获取到锁，如果不一样就再创建一个临时的顺序节点，参与排队。

单点问题？

ZK是集群部署的，只要集群中有半数以上的机器存活，就可以对外提供服务。　　

6.4 基于Curator 客户端实现分布式锁

Curator Framework提供了简化使用zookeeper更高级的API接口。它包涵很多优秀的特性，主要包括以下三点

  1. 自动连接管理：自动处理zookeeper的连接和重试存在一些潜在的问题；可以watch NodeDataChanged event和获取updateServerList;Watches可以自动被Cruator recipes删除；

  2. 更干净的API：简化raw zookeeper方法，事件等；提供现代流式API接口

  3. Recipe实现：leader选举，分布式锁，path缓存，和watcher,分布式队列等。

 依赖：

<dependency><groupId>org.apache.curator</groupId><artifactId>curator-framework</artifactId><version>4.0.1</version>
</dependency>
<dependency><groupId>org.apache.curator</groupId><artifactId>curator-recipes</artifactId><version>4.0.1</version>
</dependency>

代码：

//zookeeper 分布式锁解决超卖问题
//1.创建zookeeper连接
RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3);
CuratorFramework client= CuratorFrameworkFactory.newClient("192.168.184.200:2181", retryPolicy);
client.start();
//创建分布式锁
InterProcessMutex interProcessMutex = new InterProcessMutex(client,"/ordersettinglock");
//加锁
try {interProcessMutex.acquire();Goods goods = this.baseMapper.selectById(id);Integer count = goods.getCount();if(count>0){try {Thread.sleep(5000);} catch (InterruptedException e) {throw new RuntimeException(e);}this.baseMapper.subCount(id);}
} catch (Exception e) {throw new RuntimeException("超卖了");
} finally {//释放锁try {interProcessMutex.release();} catch (Exception e) {throw new RuntimeException(e);}
}

6.5 总结

优点:

有效的解决单点问题、不可重入问题、非阻塞问题、锁无法释放问题。实现起来简单。

缺点：

性能上不如使用缓存实现分布式锁。需要对ZK的原理有所了解，比较复杂 。

7、分布式锁总结

上面几种方式，哪种方式都无法做到完美。就像CAP一样，在复杂性、可靠性、性能等方面无法同时满足，所以，根据不同的应用场景选择最适合自己的才是王道。

理解难易程度：

数据库>缓存（redis) >zookeeper.

复杂性：

zookeeper  >= 缓存 > 数据库

性能：

缓存 > zookeeper >= 数据库

可靠性：
zookeeper > 缓存 >数据库

http://www.mmbaike.com/news/630.html

相关文章：

  • 网上做网站兼职网站统计分析平台
  • 摄影作品展示网站flash全站源码下载百度搜索
  • 网站域名备案查询可以免费投放广告的平台
  • 可以做仿牌网站朝阳区seo搜索引擎优化怎么样
  • 学习做网站建设的学校银川seo
  • 齐河做网站网站设计公司上海
  • 球场 技术支持 东莞网站建设百度指数的特点
  • 网站建设boss都知道广州百度seo优化排名
  • 潍坊网站建设价格低网站推广平台排行
  • 瑞丽网站建设搜索历史记录
  • 建网站哪家好 优帮云马鞍山网站seo
  • 做的网站如何发更新网络营销的培训课程
  • 自己怎么做独立网站seo零基础培训
  • 如何利用开源代码做网站引擎搜索技巧
  • 上线了建站教程网站seo搜索引擎的原理是什么
  • 公司做的网站费用计入什么科目千锋教育前端学费多少
  • 网站抓取诊断南京seo关键词排名
  • 微网站建设代理商怎么做好seo推广
  • 湘潭网站建设公司网店如何推广自己的产品
  • 深圳专业做网站排名公司seo网站诊断价格
  • 柳市做网站建设seo推广系统排名榜
  • 口碑好网站建设定制人工智能培训一般多少钱
  • 哪个网站做外贸比较好站长是什么级别
  • 网址大全黄页男女个人如何优化网站有哪些方法
  • 网站建设靠谱公司淘宝搜索关键词排名
  • 坂田杨美企业网站建设seo查询源码
  • 做网站推广需要多少费用磁力屋torrentkitty
  • 网站抢购外挂软件怎么做注册网站免费注册
  • wordpress+游戏网站上海百度推广代理商
  • 电商网站开发与运营微商引流的最快方法是什么