关键词：
1、技术选型：
SpringBoot
2、案例：
实体类：
package com.zhangwl.complicatedemo.pojo;
import java.sql.Timestamp;
/**
* @ClassName Goods
* @Description
* @Author zhangwl
* @Date 2019/10/3 0:54
* @Version 1.0
**/
public class Goods
private String goodsName;
private Timestamp goodsDate;
private String goodsCode;
private String serialNumber;
public Goods()
public Goods(String goodsName, Timestamp goodsDate, String goodsCode, String serialNumber)
this.goodsName = goodsName;
this.goodsDate = goodsDate;
this.goodsCode = goodsCode;
this.serialNumber = serialNumber;
public String getGoodsName()
return goodsName;
public void setGoodsName(String goodsName)
this.goodsName = goodsName;
public Timestamp getGoodsDate()
return goodsDate;
public void setGoodsDate(Timestamp goodsDate)
this.goodsDate = goodsDate;
public String getGoodsCode()
return goodsCode;
public void setGoodsCode(String goodsCode)
this.goodsCode = goodsCode;
public String getSerialNumber()
return serialNumber;
public void setSerialNumber(String serialNumber)
this.serialNumber = serialNumber;
@Override
public String toString()
return "Goods" +
"goodsName=‘" + goodsName + ‘\‘‘ +
", goodsDate=" + goodsDate +
", goodsCode=‘" + goodsCode + ‘\‘‘ +
", serialNumber=‘" + serialNumber + ‘\‘‘ +
‘‘;
package com.zhangwl.complicatedemo.pojo;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
/**
* @ClassName Request
* @Description 封装请求的实体，达到批量求的目的
* @Author zhangwl
* @Date 2019/10/5 17:22
* @Version 1.0
**/
public class Request
private String goodsCode;
CompletableFuture<Map<String, Object>> future = null;
public Request()
public Request(String goodsCode, CompletableFuture<Map<String, Object>> future)
this.goodsCode = goodsCode;
this.future = future;
public CompletableFuture<Map<String, Object>> getFuture()
return future;
public void setFuture(CompletableFuture<Map<String, Object>> future)
this.future = future;
public String getGoodsCode()
return goodsCode;
public void setGoodsCode(String goodsCode)
this.goodsCode = goodsCode;
@Override
public String toString()
return "Request" +
"goodsCode=‘" + goodsCode + ‘\‘‘ +
‘‘;
******************************************************************************************************************************************
业务层：
package com.zhangwl.complicatedemo.service;
import com.zhangwl.complicatedemo.pojo.Goods;
import java.util.Map;
import java.util.concurrent.ExecutionException;
/**
* @ClassName GoodsService
* @Description
* @Author zhangwl
* @Date 2019/10/3 0:52
* @Version 1.0
**/
public interface GoodsService
Map<String, Goods> findGoodsByGoodsCode(String goodsCode);
Map<String ,Object> getGoodsByGoodsCode(String goodsCode) throws ExecutionException, InterruptedException;
package com.zhangwl.complicatedemo.service;
import com.zhangwl.complicatedemo.pojo.Goods;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Map;
/**
* @ClassName RemoteGoodsServiceCall
* @Description 远程调用接口
* @Author zhangwl
* @Date 2019/10/6 11:33
* @Version 1.0
**/
public interface RemoteGoodsService
Map<String, Goods> findGoodsByGoodsCode(String goodsCode);
List<Map<String, Object>> findGoodsByBatchGoodsCode(List<String> goodsCodes);
package com.zhangwl.complicatedemo.service.impl;
import com.zhangwl.complicatedemo.pojo.Goods;
import com.zhangwl.complicatedemo.pojo.Request;
import com.zhangwl.complicatedemo.service.GoodsService;
import com.zhangwl.complicatedemo.service.RemoteGoodsService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.annotation.PostConstruct;
import java.util.*;
import java.util.concurrent.*;
/**
* @ClassName GoodsServiceImpl
* @Description
* @Author zhangwl
* @Date 2019/10/3 0:52
* @Version 1.0
**/
@Service
public class GoodsServiceImpl implements GoodsService
@Autowired
private RemoteGoodsService remoteGoodsService;
private LinkedBlockingQueue<Request> linkedBlockingQueue = new LinkedBlockingQueue<>();
@Override
public Map<String, Goods> findGoodsByGoodsCode(String goodsCode)
Map<String, Goods> map = remoteGoodsService.findGoodsByGoodsCode(goodsCode);
return map;
@Override
public Map<String, Object> getGoodsByGoodsCode(String goodsCode) throws ExecutionException, InterruptedException
/*jdk8将请求结果一一映射(通知)到线程*/
CompletableFuture<Map<String, Object>> future = new CompletableFuture<Map<String, Object>>();
Request request = new Request(goodsCode, future);
linkedBlockingQueue.add(request);
/*一直阻塞等待,有结果则返回结果*/
return future.get();
@PostConstruct
public void init()
/*创建一个定时器*/
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);
scheduledExecutorService.scheduleAtFixedRate(() ->
int size = linkedBlockingQueue.size();
if (size == 0)
return;
List<Request> requests = new LinkedList<>();
/*说明队列中有数据*/
linkedBlockingQueue.forEach(o ->
/*从队列中获取数据*/
Request request = linkedBlockingQueue.poll();
requests.add(request);
);
List<String> params = new LinkedList<>();
/*批量处理调用接口*/
requests.forEach(o ->
params.add(o.getGoodsCode());
);
List<Map<String, Object>> goodsMapList = remoteGoodsService.findGoodsByBatchGoodsCode(params);
Map<String, Map<String, Object>> mapResult = new HashMap<>();
goodsMapList.forEach(o ->
Set<String> keys = o.keySet();
keys.forEach(o1 ->mapResult.put(o1,o));
);
requests.forEach(o ->
Map<String, Object> result = mapResult.get(o.getGoodsCode());
o.getFuture().complete(result);
);
, 0, 10, TimeUnit.MILLISECONDS);
package com.zhangwl.complicatedemo.service.impl;
import com.zhangwl.complicatedemo.pojo.Goods;
import com.zhangwl.complicatedemo.service.RemoteGoodsService;
import com.zhangwl.complicatedemo.utils.CommonUtils;
import org.springframework.stereotype.Service;
import java.sql.Timestamp;
import java.time.Instant;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
/**
* @ClassName RemoteGoodsServiceCallImpl
* @Description
* @Author zhangwl
* @Date 2019/10/6 11:34
* @Version 1.0
**/
@Service
public class RemoteGoodsServiceImpl implements RemoteGoodsService
@Override
public Map<String, Goods> findGoodsByGoodsCode(String goodsCode)
String uuid = CommonUtils.getUUIDString();
Goods goods = new Goods();
long mills = System.currentTimeMillis();
goods.setGoodsName("name" + mills + uuid.substring(0, 3));
goods.setGoodsDate(Timestamp.from(Instant.now()));
goods.setSerialNumber(uuid);
Map<String, Goods> map = new HashMap<>();
map.put(goodsCode, goods);
return map;
@Override
public List<Map<String, Object>> findGoodsByBatchGoodsCode(List<String> goodsCodes)
List<Map<String, Object>> resultList = new LinkedList<>();
goodsCodes.forEach(o ->
String uuid = CommonUtils.getUUIDString();
Goods goods = new Goods();
long mills = System.currentTimeMillis();
goods.setGoodsName("name" + mills + uuid.substring(0, 3));
goods.setGoodsDate(Timestamp.from(Instant.now()));
goods.setGoodsCode(o);
goods.setSerialNumber(uuid);
Map<String, Object> map = new HashMap<>();
map.put(o, goods);
resultList.add(map);
);
return resultList;
******************************************************************************************************************************************
测试类：
package com.zhangwl.complicatedemo;
import com.alibaba.fastjson.JSON;
import com.zhangwl.complicatedemo.pojo.Goods;
import com.zhangwl.complicatedemo.service.GoodsService;
import com.zhangwl.complicatedemo.utils.CommonUtils;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
@RunWith(SpringRunner.class)
@SpringBootTest
public class ComplicatedemoApplicationTests
private static final int T_NUM = 10000;
/*同步计数器*/
private CountDownLatch countDownLatch1 = new CountDownLatch(T_NUM);
private CountDownLatch countDownLatch2 = new CountDownLatch(T_NUM);
@Autowired
private GoodsService goodsService;
@Test
public void contextLoads_01() throws InterruptedException
for (int i = 0; i < T_NUM; i++)
Thread t = new Thread(() ->
try
countDownLatch1.await();
Map<String, Goods> goodsMap = goodsService.findGoodsByGoodsCode(CommonUtils.getUUIDString());
Set<String> keys = goodsMap.keySet();
keys.forEach(o ->
String goodsJson = JSON.toJSONString(goodsMap.get(o));
System.out.println(goodsJson);
);
catch (InterruptedException e)
e.printStackTrace();
);
t.start();
countDownLatch1.countDown();
Thread.sleep(3000);
/*
* 利用jdk8提高并发处理的能力
*/
@Test
public void contextLoads_02() throws InterruptedException
for (int i = 0; i < T_NUM; i++)
Thread t = new Thread(() ->
try
countDownLatch2.await();
Map<String, Object> goodsMap = goodsService.getGoodsByGoodsCode(CommonUtils.getUUIDString());
Set<String> keys = goodsMap.keySet();
keys.forEach(o ->
String goodsJson = JSON.toJSONString(goodsMap.get(o));
System.out.println(goodsJson);
);
catch (InterruptedException e)
e.printStackTrace();
catch (ExecutionException e)
e.printStackTrace();
);
t.start();
countDownLatch2.countDown();
Thread.sleep(2000);
运行结果：
测试类中,
contextLoads_02测试方法的性能优于contextLoads_01方法。
redis实现高并发下的抢购秒杀功能
...很常见的一个应用场景，主要需要解决的问题有两个：1高并发对数据库产生的压力2竞争状态下如何解决库存的正确减少（"超卖"问题）对于第一个问题，已经很容易想到用缓存来处理抢购，避免直接操作数据库，例如使用Redis。... 查看详情
1.网站高并发下的测试指标及优化泛谈
网站高并发下的测试指标：1.并发量：可以承接多少次请求。2.服务器负载：服务器的cpu/内存消耗。3.平均响应时间：处理一次请求花费的时间。测试高并发时，一般的测试标准是在服务器负载为70%的时候可以处理多少次请求还... 查看详情
hashmap在高并发下如果没有处理线程安全会有怎样的安全隐患，具体表现是什么
Hashmap在并发环境下，可能出现的问题：1、多线程put时可能会导致get无限循环，具体表现为CPU使用率100%；原因：在向HashMapput元素时，会检查HashMap的容量是否足够，如果不足，则会新建一个比原来容量大两倍的Hash表，然后把数组... 查看详情
【golang】高并发下tcp常见问题解决方案
...户端，即connectionresetbypeer。在linux平台上，客户端在进行高并发TCP连接处理时，最高并发数量都要受系统对用户单一进程同时打开文件数量的限制（这是因为系统每个TCP都是SOCKET句柄，每个soker句柄都是一个文件），当打开连接... 查看详情
java8新特性：利用lambda处理list集合
Java8新增的Lambda表达式，我们可以用简洁高效的代码来处理List。1、遍历publicstaticvoidmain(String[]args){List<User>userList=Lists.newArrayList();Useruser1=newUser(1L,"张三",24);Useruser2=newUser(2L,"李四",27);Useruser3=newUser 查看详情
高并发下的内存管理技巧
1、为何高并发下容易oom 1）首先我们了解当执行垃圾回收的时候，会导致进程暂停，从而使我们的程序卡死；进程长时间暂停，又会导致大量的请求积压等待处理，垃圾回收刚刚结束，更多的请求立刻涌进来，迅速... 查看详情
高并发下的缓存一致性问题
数据读取的时候：先查缓存，缓存查不到查数据库，然后把查到的结果放到缓存中。这些都基本上没有争议。 但是数据更新的时候：到底是先更新数据库，还是再更新（or删除）缓存or先更新（or删除）缓存，再更新数据库。... 查看详情
jdk8的新特性-流和内部iteration(代码片段)
...循环的时候基本上都是用for(StudentIdListidList:studentIdList)//处理业务这么写在我的理解来看不够优雅如果用stream结合foreach来写studentIdList.parallelStream().forEach(studentIdList1->//处理业务);如上所述代码好像也并没有太大的差别但是我们... 查看详情
easyswoole+elasticsearch打造高性能小视频服务系统
...介绍首页视频页面、利用easyswoole开发首页视频API业务、高并发下性能优化-首页页面API数据优化等，带大家使用easyswoole的websocket打造小视频信息推送服务。第7章打造高性能API服务系统-EasySwooleAPI篇本章讲解swooletable场景在API高并... 查看详情
深入理解分布式事务,高并发下分布式事务的解决方案
这两天正在研究微服务架构中分布式事务的处理方案,做一个小小的总结,作为备忘.如有错误,欢迎指正!概念澄清事务补偿机制:在事务链中的任何一个正向事务操作,都必须存在一个完全符合回滚规则的可逆事务.CAP理论:CAP(Consistency... 查看详情
涂装设备前处理具体分类有哪些
...不断的作用于工件表面，工作连续性强，效率高，适合大批量的作业要求，处 查看详情
全网最全的高并发下常见的限流算法！(代码片段)
限流简介现在说到高可用系统，都会说到高可用的保护手段：缓存、降级和限流，本博文就主要说说限流。限流是流量限速（RateLimit）的简称，是指只允许指定的事件进入系统，超过的部分将被拒绝服... 查看详情
高并发下常见的限流算法都在这了！(代码片段)
限流简介现在说到高可用系统，都会说到高可用的保护手段：缓存、降级和限流，本博文就主要说说限流。限流是流量限速（RateLimit）的简称，是指只允许指定的事件进入系统，超过的部分将被拒绝服... 查看详情
学习-jdk8特性(代码片段)
...数式编程风格引入到Java中。DateTimeAPI加强对日期与时间的处理。Optional类Optional类已经成为Java8类库的一部分，用来解决空指针异常。Nashorn,JavaScript引擎Java8提供了一个新的Nashornjavascript引擎，它允许我们在JVM上运行特定的javascript... 查看详情
java秒会技术之java8新特性利用流快速处理集合的常见操作
例子1：对集合进行排序List<Integer>list=Lists.newArrayList(1,1,2,2,5,3,4,6,6,5,2,7);list.sort(null);list.forEach(e->System.out.print(e));//输出结果：112223455667例子2：对集合过滤List<Inte 查看详情
java秒会技术之java8新特性利用流快速处理集合的常见操作
例子1：对集合进行排序List<Integer>list=Lists.newArrayList(1,1,2,2,5,3,4,6,6,5,2,7);list.sort(null);list.forEach(e->System.out.print(e));//输出结果：112223455667例子2：对集合过滤List<Inte 查看详情
高并发下接口幂等性解决方案
一、幂等性概念在编程中.一个幂等操作的特点是其任意多次执行所产生的影响均与一次执行的影响相同。幂等函数，或幂等方法，是指可以使用相同参数重复执行，并能获得相同结果的函数。这些函数不会影响系统状态，也不... 查看详情
高并发下缓存失效问题及解决方案
缓存穿透介绍：当查询一个不存在的数据，此时缓存是不命中的，就会去查询db，这将导致每次查询这个不存在的数据都要去访问db，缓存就没有意义了。如果不怀好意的人利用不存在的数据进行攻击，可能导致数据库崩溃解决... 查看详情