zoukankan html css js c++ java

MyFirstDay_答案_1.**猫(自己整理)

1>***猫：

python基础类：

字符串反转的常用处理方式:

# 方法一:使用字符串切片
s = "hello python"
result = s[::-1]
print(result)
# [Out]nohtyp olleh


# 方法二:使用列表的reverse方法
l = list(s)
l.reverse()
result = "".join(l)
print(result)

# 方法三:使用reduce
from functools import reduce

s = "hello python"

result = reduce(lambda x, y: y + x, s)

print(result)


# 方法四:使用递归函数
def func(s):
    if len(s) < 1:
        return s
    return func(s[1:]) + s[0]


result = func(s)
print(result)


# 方法五:使用栈
def func(s):
    l = list(s)  # 模拟全部入栈
    result = ""
    while len(l) > 0:
        result += l.pop()  # 模拟出栈
    return result


result = func(s)
print(result)


# 方法六:for循环
def func(s):
    result = ""
    max_index = len(s) - 1
    for index, value in enumerate(s):
        result += s[max_index - index]
    return result


result = func(s)
print(result)

你说一下python中的迭代器、生成器、装饰器

# 可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator
　　
# 在Python中，这种一边循环一边计算的机制，称为生成器：generator

# 在代码运行期间动态增加功能的方式，称之为“装饰器”: Decorator

# 生成器和迭代器的区别：
#     1、语法方面来讲：
#         生成器是用函数中yield语句来创建的。迭代器的创建首先跟函数无关，可以用iter([1,2])来创建。
#     2、使用方面来讲：
#         由于生成器是使用函数的方式创建的，所以生成器里面的所有过程都会被执行，但请注意生成器里面的过程只有在被next()调用或者for循环调用时，里面的过程才会被执行

如果让你实现一个迭代器，你会怎么做

# 迭代器有两个基本的方法：iter() 和 next()。
# 字符串，列表或元组对象都可用于创建迭代器：
list = [1, 2, 3, 4]
it = iter(list)
print(next(it))
print(next(it))
# 迭代器对象可以使用常规for语句进行遍历：
list = [1, 2, 3, 4]
it = iter(list)
for x in it:
    print(x, end=" ")

# 也可以使用 next() 函数：
import sys

list = [1, 2, 3, 4]
it = iter(list)
while True:
    try:
        print(next(it))
    except StopIteration:
        sys.exit()

# 创建一个迭代器
# 把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__() 。
# # 如果你已经了解的面向对象编程，就知道类都有一个构造函数，Python 的构造函数为 __init__(), 它会在对象初始化的时候执行。
# __iter__() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 __next__() 方法并通过 StopIteration 异常标识迭代的完成.
# __next__() 方法（Python 2 里是 next()）会返回下一个迭代器对象。
# 创建一个返回数字的迭代器，初始值为 1，逐步递增 1：
# StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 __next__() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。
# 在 20 次迭代后停止执行：


class MyNumbers:
    def __iter__(self):
        self.a = 1
        return self

    def __next__(self):
        if self.a <= 20:
            x = self.a
            self.a += 1
            return x
        else:
            raise StopIteration


myclass = MyNumbers()
myiter = iter(myclass)

for x in myiter:
    print(x)

怎么样获取一个生成器？

# 在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。

你有用过yield对象吗？得到的是一个什么样的对象？

# 调用一个生成器函数，返回的是一个迭代器对象。
# 以下实例使用 yield 实现斐波那契数列：
import sys


def fibonacci(n):
    a, b, counter = 0, 1, 0
    while True:
        if(counter > n):
            return
        yield a
        a, b = b, a + b
        counter += 1
f = fibonacci(10)   # f 是一个迭代器，由生成器返回生成

while True:
    try:
        print(next(f), end=" ")
    except StopIteration:
        sys.exit()

你有了解过python中的协程吗？

# 协程，又称微线程，纤程。英文名Coroutine。
# 协程的概念很早就提出来了，但直到最近几年才在某些语言（如Lua）中得到广泛应用。
# 子程序，或者称为函数，在所有语言中都是层级调用，比如A调用B，B在执行过程中又调用了C，C执行完毕返回，B执行完毕返回，最后是A执行完毕。
# 所以子程序调用是通过栈实现的，一个线程就是执行一个子程序。
# 子程序调用总是一个入口，一次返回，调用顺序是明确的。而协程的调用和子程序不同。
# 协程看上去也是子程序，但执行过程中，在子程序内部可中断，然后转而执行别的子程序，在适当的时候再返回来接着执行。
def consumer():
    r = ''
    while True:
        n = yield r
        if not n:
            return
        print('[CONSUMER] Consuming %s...' % n)
        r = '200 OK'

def produce(c):
    c.send(None)
    n = 0
    while n < 5:
        n = n + 1
        print('[PRODUCER] Producing %s...' % n)
        r = c.send(n)
        print('[PRODUCER] Consumer return: %s' % r)
    c.close()

c = consumer()
produce(c)

技能类：

你有用过git吗？

Git是分布式版本控制系统
集中式VS分布式：
集中式版本控制系统，版本库集中存放在中央服务器，必须要联网才能工作,没有历史版本库。
分布式版本控制系统，没有“中央服务器”，每个开发人员电脑上都有一个完整的版本库。
分布式优势：安全性更高，无需联网，若“中央服务器”故障，任何一个其他开发者本地都有最新的带历史记录的版本库。
主要区别在于历史版本库的存放，集中式历史版本只存在于中央服务器，而分布式中每个本地库都有历史记录存放。

你有合过代码吗?

git status  
查看下当前代码状态，有需要提交的就提交，没有需要提交的就保持原样
git pull
拉取远程代码，使得本地代码保持最新
git branch -a 
查看最新代码所在分支
remotes/origin/HEAD -> origin/master
最新的分支会有remotes/origin/HEAD ->指明
git merge origin/master
执行合并命令把最新分支代码合并到本地当前分支
git diff
查看冲突信息
git status 
查看下状态看看那些文件需要手工调整
git add .
把修改好的文件添加到索引
git commit -m '合并XXX分支代码'
提交代码
git push
把合并好的代码推送到远程

如果合并过程中出现问题，可以使用以下命令回退到日志的合并之前的位置
git reset --hard commit_id

你有布署过代码吗？

布署的步骤是怎样的？你是怎么样把你的代码放到服务器中的？

# 1、提交代码当在本地开发&测试完毕后，将代码合并到 master 分支，并 Push 到远程的 Git 仓库。
# 通常在开发中使用 Git 作为代码版本管理工具，通过创建一个 dev 分支来进行开发工作，在发布的时候再将代码合并到 master 分支，这样可以保证 master 分支永远都是稳定的版本
git push origin master
# 2、拉取并部署代码到预发机通过以下命令从 Git 仓库获取到最新的代码
git pull
# 因为开发运行环境和线上运行环境的数据库、缓存等配置的差异，拉取的代码一般无法直接在预发机上直接运行。通常的做法是，在预发机上执行一个 shell 脚本，将线上的配置覆盖开发环境的配置。
cp code/path/to/config-dist code/path/to/config
# 预发机的主要作用是留出缓冲的空间，检验代码是否在线上环境可以正常工作。对于一个 Web 项目，我们可以设置域名的 host 配置，直接访问预发机。
# 3、同步代码到线上一般情况下，一个 Web 项目都会有多个业务机，通过负载均衡将请求流量平均分配的 N 台机器，以提高服务的承载能力和可用性。
# 因此，这里面临着一个发布代码到 N 台机器的问题。显然，我们不能一台台的发布，这样效率太低了。通常，我们通过在预发机上执行 shell 脚本，将代码 Rsync 到 N 台机器上。
rsync /path/to/code user@127.0.0.1::path/to/code --exclude-list=exclude.list
# 4、快速回滚发布完代码后，我们会在预发机的 Git 仓库上执行 ：
git tag v20160522
# 记录此次发布的版本。如果在发布后发现出了问题，可以在预发机的 Git 仓库执行如下命令：
git tag -l
# 找出上一次发布的版本，并回滚代码：
git reset --hard v20160521
# 然后，再通过步骤 3 的方式，将回滚的代码同步到 N 台业务机上。
#
# 作者：Ceelog
# 链接：https://www.jianshu.com/p/79dc6e0278e2
# 来源：简书
# 简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。

docker你有使用过吗？谈一谈

# docker镜像可以完全看作一台全新的电脑使用，无论什么镜像都是对某一东西进行了配置，然后打包后可以快速移植到需要的地方直接使用
# 省去复杂的配置工作
# 比如python web项目部署，如果是新部署，需要装系统，配置各类环境，费时费力还容易出错，
# 而docker就可以省去配置环境的麻烦，直接把所需的包丢进去，实现分分钟部署一个项目
# 给ubuntu安装docker，我安装的是docker ee:
wget -qO- https://get.docker.com/ | sh
# 安装好之后，便是启动docker
sudo service docker start
# 启动后，是没有任何镜像的，不过可以通过pull命令获取相关镜像
sudo docker images
sudo docker pull nginx
sudo docker pull nginx 默认获取最新版本，即TAG为latest的，如果要获取其他版本，则需要使用 sudo docker pull nginx:xxxx
# 获取镜像后，通过docker run使其运行起来
sudo docker ps -a 列出所有容器， 不加 -a 仅列出正在运行的，像退出了的或者仅仅只是创建了的就不列出来
sudo docker run -d -p 8800:80 --name nginx_xiao  nginx  #运行指定的镜像
dudo docker run -d --privileged=true -p 83:80 --name nginx83 nginx   #提升权限
#宿主主机端口：容器内部端口
# 　　-d  后台运行
# 　　-p 8800:80 是指定对外暴露的端口  容器内部用80 对应外部宿主主机的的8800  代理一样
# 　　--name指定容器的名字  最后的nginx 代码要运行的镜像名字  有tag的加上tag 如 nginx：xxx  默认为latest
# 然后访问宿主主机地址+8800端口
# pull到的镜像肯定有很多需要修改的地方，比如配置文件等或者要自己增加些什么玩意儿进去
sudo docker exec -it 54d26bbce3d6 /bin/bash
# 通过exec命令进入到容器内部进行操作， 其中字符串部分可以是容器id或容器名字
# 进入之后就和操作新的系统一样，操作完成之后输入exit退出
# 那么问题又来了， 进入容器内部并修改了东西后，怎么生成新的镜像供下次直接使用
sudo docker commit nginx_huang huang/nginx:v1.0
　　nginx_huang 表示我们刚修改的容器名字或者id
    huang/nginx:v1.0 为保存的镜像名字 ：后面为tag

# 刚刚commit的镜像仅仅是保存在本地的，如果要提交到网络上供其他人pull 使用呢？ 如 https://cloud.docker.com/
# 1.在https://cloud.docker.com/上注册一个账号
# 2.提交本地镜像到https://cloud.docker.com/上去
# 这样别人就可以通过docker pull xiaochangwei/nginx:v1.0 来获取并使用这个镜像了
sudo docker commit nginx_huang huang/nginx:v1.0 镜像名里面包含了 我注册的账户名，这里需要一致，否则无法push

# 到这里镜像怎么获取，查看，启动，编辑，保存，提交 容器查看 都知道了，但是怎么停止、启动、删除容器呢
# 1.通过 sudo docker ps -a查看存在的容器信息
# 2.通过 sudo docker start/stop/restart xxx 来启动、停止、重启指定的容器
# 2.通过 sudo docker rm xxx 指定容器名或者容器id来删除，删除前请先停止容器，保证在非运行状态
# 同样镜像的删除按如下操作
# 1.通过sudo docker images 列出所有镜像
# 2.通过sudo docker rmi xxx 来删除指定的镜像，镜像存在依赖关系，先删除最下层，最后删除顶层，建议根据镜像名字来删除

你平时是怎么去debug你的代码的？比如说有些代码是第一次写，你不知道你写的是不是对的，一但出现了问题，你要怎么去定位它，检测它？

# 1.操作步骤：
# 1-1.添加断点：直接在标记处点击鼠标左键即可。（删除断点只需再点击断点处即可）
def add(x, y):
    z = x + y
    return z

def sub(x, y):
    z = x - y
    return z

def debug_test():           # 点击左侧，添加断点
    a = 10
    b = 5
    Sum = add(a, b)
    Sub = sub(a, b)
    print(Sum)
    print(Sub)

if __name__ == "__main__":
    debug_test()

# 1-2.Debug下运行代码：七星瓢虫shift + F9
# 1-3.按照所需调试进行代码调试。Debug的调试方式如下所示：
# 分别为：
# 1.show execution point (F10)  显示当前所有断点
# 2.step over(F8)  单步调试(若函数A内存在子函数a时，不会进入子函数a内执行单步调试，而是把子函数a当作一个整体，一步执行。)
def add(x, y):
    z = x + y
    return z

def sub(x, y):
    z = x - y
    return z

def debug_test():           # 3 # 断点处
    a = 10                  # 4
    b = 5                   # 5
    Sum = add(a, b)         # 6
    Sub = sub(a, b)         # 7
    print(Sum)              # 8
    print(Sub)              # 9

if __name__ == "__main__":  # 1
    debug_test()            # 2 # 10

# 4.step into my code(Alt + Shift +F7) 执行下一行但忽略libraries（导入库的语句）（目前感觉没什么用）
def add(x, y):
    z = x + y               # 7
    return z                # 8

def sub(x, y):
    z = x - y               # 11
    return z                # 12

def debug_test():           # 3 # 断点处
    a = 10                  # 4
    b = 5                   # 5
    Sum = add(a, b)         # 9
    Sub = sub(a, b)         # 13
    print(Sum)              # 14
    print(Sub)              # 15

if __name__ == "__main__":  # 1
    debug_test()            # 2 # 16
# 5.force step into(Alt + Shift +F7) 执行下一行忽略lib和构造对象等  （目前感觉没什么用）
# 6.step out（Shift+F8）当目前执行在子函数a中时，选择该调试操作可以直接跳出子函数a，而不用继续执行子函数a中的剩余代码。并返回上一层函数。
# 7.run to cursor(Alt +F9) 直接跳到下一个断点
# ---------------------
# 作者：放下扳手&拿起键盘
# 来源：CSDN
# 原文：https://blog.csdn.net/william_hehe/article/details/80898031

你有多长时间的软件开发经验？

业务类:

你对电商的业务了解吗？

# 电商项目用户部分：主要分为三大类——1、用户浏览商品 ，2、购买商品 ，3、管理订单
# 电商项目管理部分：主要也为三大类——1、商品数据整合网站 ，2、接受用户信息数据存入后台（注册和管理），3、处理用户订单问题

我问你一个具体的电商的业务啊：电商在大多数领域中都是有库存的，我在下订单的时候，我的库存的变化，你知道吗？(我问的是你怎么去处理库存的变化?)因为客户下单的时候，有些是去减库存了，有些不减对吧？你的理解呢?

# 电商项目用户部分：主要分为三大类——1、用户浏览商品 ，2、购买商品 ，3、管理订单
# 电商项目管理部分：主要也为三大类——1、商品数据整合网站 ，2、接受用户信息数据存入后台（注册和管理），3、处理用户订单问题

#  一个简单的使用场景：一件商品的库存只有5件，同时A用户买了5个，B用户买了5个，都提交数据，照成库存不足的问题。
#         逻辑：根据一般电商商品的模型类，生成订单一般包括订单类（Order）和订单详情类（DetailOrder)，这两张表根据外键order_id 进行关联，所以是同生共死的关系，所以我们在这里用事务来控制。那么python如何解决库存问题呢？
#         python 提供了2种方法解决该问题的问题：1，悲观锁；2，乐观锁
#         悲观锁：在查询商品储存的时候加锁 select_for_update()  在发生事务的commit或者是事务的rollback时，自动释放该锁，这样其他用户就可以接着查询该商品。
#         乐观锁：乐观锁不是真正的锁，在创建订单之前查询商品的库存，在创建订单详情表前，update更新查询数据，如果两次查询的库存量一样就创建详情表，并减去库存，否则，循环三次，如果都不一样，就发生rollback。
#         使用场景：并发量高的时候使用悲观锁，缺点：加锁消耗资源
#              并发量低的时候使用乐观锁，缺点：乐观锁循环耗费时间。
# ---------------------
# 作者：huangyali_python
# 来源：CSDN
# 原文：https://blog.csdn.net/huangyali_python/article/details/79511654

你事务的时候有没有出现死锁的情况?

# 所谓死锁： 是指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程，如下就是死锁
# 解决方法，递归锁，在Python中为了支持在同一线程中多次请求同一资源，python提供了可重入锁RLock。
from threading import Thread,Lock
import time
mutexA=Lock()
mutexB=Lock()

class MyThread(Thread):
    def run(self):
        self.func1()
        self.func2()
    def func1(self):
        mutexA.acquire()
        print('33[41m%s 拿到A锁33[0m' %self.name)

        mutexB.acquire()
        print('33[42m%s 拿到B锁33[0m' %self.name)
        mutexB.release()

        mutexA.release()

    def func2(self):
        mutexB.acquire()
        print('33[43m%s 拿到B锁33[0m' %self.name)
        time.sleep(2)

        mutexA.acquire()
        print('33[44m%s 拿到A锁33[0m' %self.name)
        mutexA.release()

        mutexB.release()

if __name__ == '__main__':
    for i in range(10):
        t=MyThread()
        t.start()
# 这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。上面的例子如果使用RLock代替Lock，则不会发生死锁，二者的区别是：递归锁可以连续acquire多次，而互斥锁只能acquire一次
from threading import Thread,RLock
import time

mutexA=mutexB=RLock() #一个线程拿到锁，counter加1,该线程内又碰到加锁的情况，则counter继续加1，这期间所有其他线程都只能等待，等待该线程释放所有锁，即counter递减到0为止

class MyThread(Thread):
    def run(self):
        self.func1()
        self.func2()
    def func1(self):
        mutexA.acquire()
        print('33[41m%s 拿到A锁33[0m' %self.name)

        mutexB.acquire()
        print('33[42m%s 拿到B锁33[0m' %self.name)
        mutexB.release()

        mutexA.release()

    def func2(self):
        mutexB.acquire()
        print('33[43m%s 拿到B锁33[0m' %self.name)
        time.sleep(2)

        mutexA.acquire()
        print('33[44m%s 拿到A锁33[0m' %self.name)
        mutexA.release()

        mutexB.release()

if __name__ == '__main__':
    for i in range(10):
        t=MyThread()
        t.start()

你刚刚说到的下单之后的库存锁的问题？你是在下单的时候去扣库存，还是在支付完成了以后去扣?

# 一、扣减库存的三种方案
# （1）下单减库存
# 　　用户下单时减库存
# 　　优点：实时减库存，避免付款时因库存不足减库存的问题
# 　　缺点：恶意买家大量下单，将库存用完，但是不付款，真正想买的人买不到
# （2）付款减库存
# 　　下单页面显示最新的库存，下单时不会立即减库存，而是等到支付时才会减库存。
# 　　优点：防止恶意买家大量下单用光库存，避免下单减库存的缺点
# 　　缺点：下单页面显示的库存数可能不是最新的库存数，而库存数用完后，下单页面的库存数没有刷新，出现下单数超过库存数，若支付的订单数超过库存数，则会出现支付失败。
# （3）预扣库存
# 　　下单页面显示最新的库存，下单后保留这个库存一段时间（比如10分钟），超过保留时间后，库存释放。若保留时间过后再支付，如果没有库存，则支付失败。例如：要求30分钟内支付订单。
# 　　优点：结合下单减库存的优点，实时减库存，且缓解恶意买家大量下单的问题，保留时间内未支付，则释放库存。
# 　　缺点：保留时间内，恶意买家大量下单将库存用完。并发量很高的时候，依然会出现下单数超过库存数。
# 二、如何解决恶意买家下单的问题
# 这里的恶意买家指短时间内大量下单，将库存用完的买家。
# （1）限制用户下单数量
# 　　优点：限制恶意买家下单
# 　　缺点：用户想要多买几件，被限制了，会降低销售量
# （2）标识恶意买家
# 　　优点：卖家设定一个备用库存，当支付时，库存已用完，扣减备用库存数，这就是常见的补货场景
# 　　缺点：因高并发场景下，数据可能存在不一致性的问题
# 三、如何解决下单成功而支付失败（库存不足）的问题
# （1）备用库存
# 　　商品库存用完后，如果还有用户支付，直接扣减备用库存。
# 　　优点：缓解部分用户支付失败的问题
# 　　缺点：备用库存只能缓解问题，不能从根本上解决问题。另外备用库存针对普通商品可以，针对特殊商品这种库存少的，备用库存量也不会很大，还是会出现大量用户下单成功却因库存不足而支付失败的问题。
# 四、如何解决高并发下库存超卖的场景
# 库存超卖最简单的解释就是多成交了订单而发不了货。
# 场景：
# 用户A和B成功下单，在支付时扣减库存，当前库存数为10。因A和B查询库存时，都还有库存数，所以A和B都可以付款。
# A和B同时支付，A和B支付完成后，可以看做两个请求回调后台系统扣减库存，有两个线程处理请求，两个线程查询出来的库存数 inventory=10，
# 然后A线程更新最终库存数 lastInventory=inventory - 1 = 9，
# B线程更新库存数 lastInventory=inventory - 1 = 9。
# 而实际最终的库存应是8才对，这样就出现库存超卖的情况，而发不出货。
# 那如何解决库存超卖的情况呢？
# 1.SQL语句更新库存时，如果扣减库存后，库存数为负数，直接抛异常，利用事务的原子性进行自动回滚。
# 2.利用SQL语句更新库存，防止库存为负数
#  UPDATE [库存表] SET 库存数 - 1 WHERE 库存数 - 1 > 0
#  如果影响条数大于1，则表示扣减库存成功，否则订单失败，并退款。
# 五、秒杀场景下如何扣减库存
# （1）下单减库存
# 因秒杀场景下，大部分用户都是想直接购买商品的，可以直接用下单减库存。
# 大量用户和恶意用户都是同时进行的，区别是正常用户会直接购买商品，恶意用户虽然在竞争抢购的名额，但是获取到的资格和普通用户一样，所以下单减库存在秒杀场景下，恶意用户下单并不能造成之前说的缺点。
# 而且下单直接扣减库存，这个方案更简单，在第一步就扣减库存了。
# （2）将库存放到redis缓存中
# 　　查询缓存要比查询数据库快，所以将库存数放在缓存中，直接在缓存中扣减库存。然后在通过MQ异步完成数据库处理。
# （3）使用量自增方式
# 可以先增加已使用量，然后与设定的库存进行比较，如果超出，则将使用量减回去。
#
# 项目中用到了很多机制，但是没有总结出来，学习架构需要不断地总结。
#
# 六 第三方支付
# 1 支付成功多次回调：把减库存放在微信支付的成功回调URL的方法里面。但是微信支付成功之后微信支付平台会发送8次请求到回调地址。这样的做法就会导致库存减少，一定要验证返回的编号是否已经完成扣减。

如果用户不支付，你的库存怎么办?（我还是没有听到你说，处理库存的点）

# 设置支付时间，下单应该是锁定库存但是不减库存。如果你整个下单支付是队列方式的话，就支付完成之后立即减库存。超时就释放掉锁

如果支付失败了，你对库存有一个什么样的动作?

# 支付完成后对库存进行更新，更新库存在事务中进行同时加锁，加的锁要避免堵塞，支付失败或者支付异常回滚，重新更新库存

# 方案1：在下单就锁定库存
#     优点：可以解决库存减扣问题
#     缺点：体验差，如果只下单未付款，库存被锁定，让有意愿购买的用户无从下单，对销售业务有很大影响；
# 
# 方案2：支付后减扣库存
#     优点：防止恶意下单，只要有足够的实际库存，随便多少意向客户下单
#     缺点：下单页面显示的库存数可能不是最新的库存数，其他用户可能提示库存不足，可能出现超卖问题。
# 
# 方案3：调起支付界面前锁定库存
# 
#     优点：防止恶意下单，只要有足够的实际库存，随便多少意向客户下单
#     缺点：体验差，有可能在支付时提示库存被其他用户锁定，提示库存不足
# 
# 方案4：下单占库存根据库存大小决定库存锁定时间
# 
#      库存充足下单占库存，设定库存最大占用时间，按库存大小限购数量按策略缩减库存占用时间
# 
#  
# 
#  
# 
# 具体以哪种方案为主还是要看公司的业务做决定
# 
# 
#  
# 
# 下面主要讲解方案3 支付前锁定库存的的实现步骤，以下是使用到的关键表
# 
# -------------------------------------------------------------------------------------
# 订单表
# 订单唯一编号     库存锁定状态（1库存已锁定 2库存已释放 3库存已确认,库存减扣成功）
# -------------------------------------------------------------------------------------
# 订单详细表
# 订单编号      商品id     购买数量
# -------------------------------------------------------------------------------------
# 商品库存表
# 商品id     库存数量     实际锁定库存数量  预锁定库存数量   限购数量
# -------------------------------------------------------------------------------------
# 
# A商品库存 1个
# 
# 
# 用户1  下单1个
# 用户2  下单1个
# 
# 
# 业务场景及解决方式:
# 1.支付前预占库存 ：用户1和用户2可能同时点击支付按钮，此时对于商品锁定库存来说只能有一个用户会锁定A商品的库存，剩下一个肯定锁定失败，此时应该提示其中一个用户（库存可能不足，请稍后再试），这里更新库存减扣应该都有前置条件的或者说版本号
# 
# 2.限制支付时间，需要设置一个支付时间
# 
# （设置三方支付过期时间为30分钟）调起支付页面锁定库存30分钟，30分钟后还未支付则还原预减库存
# 
# 3.检测恶意下单用户加入到店铺黑名单
# 
# 4.加入限购
# 
# 5.优化方式
# 另一个用户跳转到三方支付界面，
# 如果此用户取消支付，客户端应该发送一条消息告诉服务端恢复库存锁定，
# 如果此用户支付成功，客户端应该发送一条消息告诉服务端确认减扣库存，
# 客户端可能因某种情况发送失败，此时要考虑使用定时任务恢复超过多久库存还处于（根据锁定状态）锁定中的订单商品库存，应该先调用支付系统关闭原有未完成支付的订单，然后再恢复商品锁定库存
# 支付系统异步通知支付成功修改库存，此时根据库存锁定状态进行不同的业务处理（1库存已锁定 2库存已释放 3库存已确认,库存减扣成功）
# --------------------- 
# 作者：www.weixuehu.com 
# 来源：CSDN 
# 原文：https://blog.csdn.net/t_332741160/article/details/80340188 
# 版权声明：本文为博主原创文章，转载请附上博文链接！

查看全文

相关阅读:
POJ 2923 Relocation （状态压缩，01背包）
HDU 2126 Buy the souvenirs （01背包，输出方案数）
hdu 2639 Bone Collector II （01背包，求第k优解）
UVA 562 Dividing coins （01背包）
POJ 3437 Tree Grafting
Light OJ 1095 Arrange the Numbers(容斥)
BZOJ 1560 火星藏宝图(DP)
POJ 3675 Telescope
POJ 2986 A Triangle and a Circle
BZOJ 1040 骑士

原文地址：https://www.cnblogs.com/wangxue533/p/10626558.html