1 秒杀系统模拟基础实现，使用DB实现
本文根据动脑学院的一节类似的课程，改编实现。分别使用DB和redis来完成。
隔离的解释
业务隔离：将秒杀业务独立出来，尽量不与其他业务关联，以减少对其他业务的依赖性。譬如秒杀业务只保留用户id，商品id，数量等重要属性，通过中间件发送给业务系统，完成后续的处理。
系统隔离：将秒杀业务单独部署，以减少对其他业务服务器的压力。
数据隔离：由于秒杀对DB的压力很大，将DB单独部署，不与其他业务DB放一起，避免对DB的压力。
本篇讲使用DB完成秒杀系统。下一篇使用redis完成持久层。
一 初始化项目
以Springboot，mysql，jpa为技术方案。
新建Springboot项目，pom如下
4.0.0
com.tianyalei
common
0.0.1-SNAPSHOT
jar
common
Demo project for Spring Boot
org.springframework.boot
spring-boot-starter-parent
1.5.2.RELEASE
UTF-8
UTF-8
1.8
org.springframework.boot
spring-boot-devtools
true
org.springframework.boot
spring-boot-starter-data-jpa
org.springframework.boot
spring-boot-starter-data-redis
mysql
mysql-connector-java
runtime
com.alibaba
druid
1.0.18
org.springframework.boot
spring-boot-starter-test
test
org.springframework.boot
spring-boot-maven-plugin
javaBean
package com.tianyalei.model;
import javax.persistence.*;
/**
* Created by wuwf on 17/7/5.
*/
@Entity
public class GoodInfo {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Integer id;
//数量
private int amount;
//商品编码
@Column(unique = true)
private String code;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public int getAmount() {
return amount;
}
public void setAmount(int amount) {
this.amount = amount;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
}
package com.tianyalei.repository;
import com.tianyalei.model.GoodInfo;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;
/**
* Created by admin on 17/7/5.
*/
public interface GoodInfoRepository extends CrudRepository {
@Query("update GoodInfo set amount = amount - ?2 where code = ?1 and amount - ?2 >= 0")
@Modifying
int updateAmount(String code, int count);
}
service接口
package com.tianyalei.service;
import com.tianyalei.model.GoodInfo;
/**
* Created by wuwf on 17/7/5.
*/
public interface GoodInfoService {
void add(GoodInfo goodInfo);
void delete(GoodInfo goodInfo);
int update(String code, int count);
}
Service实现类
package com.tianyalei.service;
import com.tianyalei.model.GoodInfo;
import com.tianyalei.repository.GoodInfoRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
/**
* Created by wuwf on 17/7/5.
*/
@Service("db")
public class GoodInfoDbService implements GoodInfoService {
@Autowired
private GoodInfoRepository goodInfoRepository;
@Transactional
public int update(String code, int count) {
return goodInfoRepository.updateAmount(code, count);
}
public void add(GoodInfo goodInfo) {
goodInfoRepository.save(goodInfo);
}
public void delete(GoodInfo goodInfo) {
goodInfoRepository.deleteAll();
}
}
spring:
jpa:
database: mysql
show-sql: true
hibernate:
ddl-auto: update
datasource:
type: com.alibaba.druid.pool.DruidDataSource
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql://localhost:3306/test
username: root
password:
redis:
host: localhost
port: 6379
password:
pool:
max-active: 8
max-idle: 8
min-idle: 0
max-wait: 10000
profiles:
active: dev
server:
port: 8080
二 模拟并发访问抢购
新建junit测试类
package com.tianyalei;
import com.tianyalei.model.GoodInfo;
import com.tianyalei.service.GoodInfoService;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
/**
* Created by wuwf on 17/7/5.
*/
@RunWith(SpringRunner.class)
@SpringBootTest
public class MyTest {
@Resource(name = "db")
private GoodInfoService service;
private String goodCode = "iphone7";
/**
* 机器总数量
*/
private int goodAmount = 100;
/**
* 并发量
*/
private int threadNum = 200;
//销售量
private int goodSale = 0;
//买成功的数量
private int accountNum = 0;
//买成功的人的ID集合
private List successUsers = new ArrayList<>();
private GoodInfo goodInfo;
/*当创建 CountDownLatch 对象时，对象使用构造函数的参数来初始化内部计数器。每次调用 countDown() 方法,
CountDownLatch 对象内部计数器减一。当内部计数器达到0时， CountDownLatch 对象唤醒全部使用 await() 方法睡眠的线程们。*/
private CountDownLatch countDownLatch = new CountDownLatch(threadNum);
@Test
public void contextLoads() {
for (int i = 0; i < threadNum; i++) {
new Thread(new UserRequest(goodCode, 7, i)).start();
countDownLatch.countDown();
}
//让主线程等待200个线程执行完，休息2秒，不休息的话200条线程还没执行完，就打印了
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("-----------购买成功的用户数量----------为" + accountNum);
System.out.println("-----------销售量--------------------为" + goodSale);
System.out.println("-----------剩余数量------------------为" + (goodAmount - goodSale));
System.out.println(successUsers);
}
private class UserRequest implements Runnable {
private String code;
private int buyCount;
private int userId;
public UserRequest(String code, int buyCount, int userId) {
this.code = code;
this.buyCount = buyCount;
this.userId = userId;
}
@Override
public void run() {
try {
//让线程等待，等200个线程创建完一起执行
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
//如果更新数据库成功，也就代表购买成功了
if (service.update(code, buyCount) > 0) {
//对service加锁，因为很多线程在访问同一个service对象，不加锁将导致购买成功的人数少于预期，且数量不对，可自行测试
synchronized (service) {
//销售量
goodSale += buyCount;
accountNum++;
//收录购买成功的人
successUsers.add(userId);
}
}
}
}
@Before
public void add() {
goodInfo = new GoodInfo();
goodInfo.setCode(goodCode);
goodInfo.setAmount(goodAmount);
service.add(goodInfo);
}
@After
public void delete() {
service.delete(goodInfo);
}
}
注意，由于是模拟并发，需要保证200个线程同时启动去访问数据库，所以使用了CountDownLatch类，在调用UserRequest线程的start方法后，会先进入await状态，等待200个线程创建完毕后，一起执行。
注意，由于是多线程操作service，必然导致数据不同步，所以需要对service加synchronize锁，来保证service的update方法能够正确执行。如果不加，可以自行测试，会导致少卖。
运行该测试类，看打印的结果。
可以多次运行，并修改每个人的购买数量、总商品数量、线程数，看看结果是否正确。
如修改为每人购买8个
mysql支持的并发访问量有限，倘若并发量较小，可以采用上面的update的sql就能控制住，倘若量大，可以考虑使用nosql。
下一篇讲一下redis模拟的方式。