面试总结:秒杀设计、AQS 、synchronized相关问题

1、面试官:如何设计一个秒杀系统?请你阐述流程?

这一面试题答案参考自三太子敖丙的文章:阿里面试官问我:如何设计秒杀系统?我给出接近满分的回答

秒杀系统要解决的几个问题?

① 高并发

秒杀的特点是时间极短、 瞬间用户量大。在秒杀活动持续时间内,Redis 服务器需要承受大量的用户请求,在大量请求条件下,缓存雪崩,缓存击穿,缓存穿透这些问题都是有可能发生的。

一旦缓存失效,或者缓存无效,每秒上万甚至十几万的QPS(每秒请求数)直接打到数据库,基本上都要把库打挂掉,而且你的服务不单单是做秒杀的还涉及其他的业务,你没做降级、限流、熔断啥的,别的一起挂,小公司的话可能全站崩溃404。

为此,在设计秒杀系统时,首先要考虑并发安全和用户访问效率,二者缺一不可!

② 超卖

但凡设计到商品购买,秒杀购物问题,最需要注意的就是超卖问题,因为一旦由于程序不安全,导致超卖问题产生,不光需要赔付商家损失,还需要追究秒杀系统的开发者的责任!

③ 恶意请求

在秒杀购物时,商品价格比较低,价值较高的商品可能会被一些恶意的第三方,开多台机器执行抢购脚本,机器抢购肯定要比我们人手动点击要快,所以,在设计秒杀系统时,要防止 不良程序员 的恶意抢购。

④ 链接暴露

假如设置定时秒杀开启,在未到秒杀开启时间之前,下单购买按钮应该是禁用的(不可点击),但是,如果我们请求下单的链接没有经过网关加密封装,而是直接以原链接的方式依附于下单购买按钮,那么 F12 时,就可以获取下单购买链接 URL,然后直接去请求下单链接,跳过点击方式直接购买商品!

如何解决上面遇到的几个问题?

① 秒杀模块微服务化

对于秒杀抢购系统,将其设计成单独一个模块,单独部署一台或者多太服务器,这样可以避免服务崩溃时,公司其他项目可以正常运行不受影响。

与此同时,要单独给秒杀系统建立一个数据库,现在的互联网架构部署都是分库的,一样的就是订单服务对应订单库,秒杀我们也给他建立自己的秒杀数据库,防止服务崩溃对其他数据库造成影响。

② 秒杀链接加盐

URL动态化,通过 MD5 之类的加密算法加密随机的字符串去做 URL,然后通过前端代码获取 URL 后台校验后才能通过。

③ Redis集群

如果在大请求量下,单机的Redis顶不住,那就多找几个兄弟,秒杀本来就是读多写少,通过 Redis 集群,主从同步、读写分离,再加上 哨兵、开启 持久化,来保证 Redis 服务高可用!

④ 通过 Nginx 做负载均衡

Nginx高性能的web服务器,并发随便顶几万不是梦,但是我们的 Tomcat 只能顶几百的并发,我们可以通过Nginx 负载均衡,平分大并发量的请求给多台服务器的 Tomcat,在秒杀开启的时候可以多租点流量机

⑤ 秒杀页面资源静态化

秒杀一般都是特定的商品还有页面模板,现在一般都是前后端分离的,所以页面一般都是不会经过后端的,但是前端也要自己的服务器啊,那就把能提前放入**cdn服务器 **的东西都放进去,反正把所有能提升效率的步骤都做一下,减少真正秒杀时候服务器的压力。

⑥ 下单按钮控制

在没到秒杀开始时间之前,一般下单按钮都是置灰的,只有时间到了,才能点击。这是因为怕大家在时间快到的最后几秒秒疯狂请求服务器,然后还没到秒杀的时候基本上服务器就挂了。

这个时候就需要前端的配合,定时去请求你的后端服务器,获取最新的北京时间,到时间点再给按钮可用状态。按钮可以点击之后也得给他置灰几秒,不然他一样在开始之后一直点的。

⑦ 前后端限流

限流可以分为 前端限流后端限流。

前端限流:这个很简单,一般秒杀抢购,下单按钮不会让你一直点的,一般都是点击一下或者两下然后几秒之后才可以继续点击,这也是保护服务器的一种手段。

后端限流:秒杀的时候肯定是涉及到后续的订单生成和支付等操作,但是都只是成功的幸运儿才会走到那一步,那一旦 100 个产品卖光了,return 了一个 false,前端直接秒杀结束,然后你后端也关闭后续无效请求的介入了。

⑧ 库存预热

秒杀的本质就是对库存的抢夺。如果每个秒杀下单的用户请求过来,都去数据库查询库存校验库存,然后扣减库存,这样不光效率低下,而且数据库压力也是巨大的!

既然数据库顶不住,但是他的兄弟非关系型的数据库 Redis 能顶啊!

超卖问题:

我们要在开始秒杀之前,通过定时任务提前把商品的库存加载到 Redis 中去,让整个库存校验流程都在 Redis 里面去做,然后等到秒杀活动结束了,再异步的去修改数据库中库存就好了。

但是用了 Redis 就有一个问题了,我们上面说了我们采用 主从 Redis,就是我们会先去读取库存,再判断库存,当有库存时才会去减库存,正常情况没问题,但是高并发的情况问题就很大了。

就比如现在库存只剩下 1 个了,我们高并发嘛,4 个服务器一起查询了发现都是还有 1 个,那大家都觉得是自己抢到了,就都去扣库存,那结果就变成了 -3,这种情况下,只有一个请求是真的抢到商品了,其他 3 个都是超卖的。

如何解决?

可以通过使用 Lua 脚本来解决超卖问题。

**Lua 脚本是类似Redis事务,有一定的原子性,不会被其他命令插队,可以完成一些 Redis 事务性的操作。**这点是关键!

把判断库存、扣减库存的操作都写在一个 Lua 脚本中,并将该脚本交给 Redis 去执行,当 Redis 中库存数量减到 0 之后,后面扣库存的请求都直接 return false

⑨ 限流&降级&熔断&隔离

不怕一万就怕万一,万一秒杀系统真的顶不住了,限流,顶不住就挡一部分出去。但是不能说不行,降级,降级了还是被打挂了,熔断,至少不要影响别的系统,隔离,你本身就独立的,但是你会调用其他的系统嘛,你快不行了你别拖累兄弟们啊。

2、面试官:AQS源码有了解过吗?请你说一下加锁和释放锁的流程

这一面试题答案参考自三太子敖丙的文章:我画了35张图就是为了让你深入 AQS

① AQS绍

AQS中 维护 基本介了一个volatile int state(代表共享资源)和一个 FIFO 线程等待队列(多线程争用资源被阻塞时会进入此队列)。

这里volatile能够保证多线程下的可见性,当state = 1则代表当前对象锁已经被占有,其他线程来加锁时则会失败,加锁失败的线程会被放入一个 FIFO的等待队列中,并会被 UNSAFE.park() 操作挂起,等待其他获取锁的线程释放锁才能够被唤醒。

另外state的操作都是通过CAS来保证其并发修改的安全性。

如图所示:

AQS 中提供了很多关于锁的实现方法:

getState():获取锁的标志 state 值。

setState():设置锁的标志 state 值。

tryAcquire(int):独占方式获取锁。尝试获取资源,成功则返回 true,失败则返回 false。

tryRelease(int):独占方式释放锁。尝试释放资源,成功则返回 true,失败则返回 false。

② 加锁与竞争锁使用场景分析

如果同时有三个线程并发抢占锁,此时线程一抢占锁成功,线程二和线程三抢占锁失败,具体执行流程如下:

此时AQS内部数据为:

具体看下抢占锁代码实现:java.util.concurrent.locks.ReentrantLock .NonfairSync

static final class NonfairSync extends Sync {
    // 加锁
    final void lock() {
        // CAS 修改 state 的值为 1
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1);
    }
    // 尝试竞争资源
    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}

这里使用的 ReentrantLock 非公平锁,线程进来直接利用CAS尝试抢占锁,如果抢占成功state值回被改为 1,且设置独占锁线程对象为当前线程。

// CAS 尝试抢占锁
protected final boolean compareAndSetState(int expect, int update) {
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}
// 设置独占锁线程对象为当前线程
protected final void setExclusiveOwnerThread(Thread thread) {
    exclusiveOwnerThread = thread;
}

线程一抢占锁成功后,state变为 1,线程二通过CAS修改state变量必然会失败。此时AQSFIFO(First In First Out 先进先出)队列中。

public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

tryAcquire() 方法的具体实现是通过内部调用nonfairTryAcquire()方法,这个方法执行的逻辑如下:

首先会获取state的值,如果不为0则说明当前对象的锁已经被其他线程所占有。

接着判断占有锁的线程是否为当前线程,如果是则累加state值,这就是可重入锁的具体实现,累加state值,释放锁的时候也要依次递减state值。

如果state为 0,则执行CAS操作,尝试更新state值为 1,如果更新成功则代表当前线程加锁成功。

③ 释放锁使用场景分析

释放锁的过程,首先是线程一释放锁,释放锁后会唤醒head节点的后置节点,也就是我们现在的线程二,具体操作流程如下:

执行完后等待队列数据如下:

此时线程二已经被唤醒,继续尝试获取锁,如果获取锁失败,则会继续被挂起。

线程释放锁的代码:

java.util.concurrent.locks.AbstractQueuedSynchronizer.release():

public final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

这里首先会执行tryRelease()方法,这个方法具体实现在ReentrantLock中,如果tryRelease()执行成功,则继续判断 head 节点的 waitStatus 是否为 0,前面我们已经看到过,headwaitStatue为SIGNAL(-1),这里就会执行 unparkSuccessor() 方法来唤醒 head 的后置节点,也就是上面图中线程二对应的Node节点。

ReentrantLock.tryRelease():

protected final boolean tryRelease(int releases) {
    int c = getState() - releases;
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    if (c == 0) {
        free = true;
        setExclusiveOwnerThread(null);
    }
    setState(c);
    return free;
}

执行完ReentrantLock.tryRelease()后,state被设置成 0,Lock 对象的独占锁被设置为 null。

接着执行java.util.concurrent.locks.AbstractQueuedSynchronizer.unparkSuccessor()方法,唤醒head的后置节点:

private void unparkSuccessor(Node node) {
    int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);
    Node s = node.next;
    if (s == null || s.waitStatus > 0) {
        s = null;
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    if (s != null)
        LockSupport.unpark(s.thread);
}

这里主要是将head节点的waitStatus设置为 0,然后解除head节点next的指向,使head节点空置,等待着被垃圾回收。

此时重新将head指针指向线程二对应的Node节点,且使用LockSupport.unpark方法来唤醒线程二

被唤醒的线程二会接着尝试获取锁,用CAS指令修改state数据。

3、面试官:请你谈一谈synchronized的实现原理

这一面试题答案参考文章:死磕 java同步系列之synchronized解析

synchronized 加锁解锁原理分析

sychronized 锁,在Java内存模型层面,涉及到 2 个指令(JMM 定义了8 个操作来完成主内存工作内存的交互操作,参考文章:搜集了这么多资料,不信你还理解不了 JMM 内存模型、volatile 关键字保证有序性和可见性实现原理!),lockunlock

  • lock,锁定,作用于主内存的变量,它把主内存中的变量标识为线程独占状态。
  • unlock,解锁,作用于主内存的变量,它把锁定的变量释放出来,释放出来的变量才可以被其它线程锁定。

这两个指令并没有直接提供给用户使用,而是提供了两个更高层次的指令 monitorenter monitorexit 来隐式地使用 lock unlock 指令。而 synchronized 就是使用 monitorenter monitorexit 这两个指令来实现的。

根据JVM规范的要求,在执行 monitorenter 指令的时候,首先要去尝试获取对象的锁,如果这个对象没有被锁定,或者当前线程已经拥有了这个对象的锁,就把锁的计数器加1,相应地,在执行 monitorexit 的时候会把计数器减 1,当计数器减小为 0 时,锁就释放了。

sychronized 锁是如何保证,原子性、可见性、和一致性呢?

还是回到Java内存模型上来,synchronized关键字底层是通过 monitorenter monitorexit 实现的,而这两个指令又是通过 lockunlock 来实现的。

lock unlock 在Java内存模型中是必须满足下面四条规则的:

  • ① 一个变量同一时刻只允许一条线程对其进行 lock 操作,但 lock 操作可以被同一个线程执行多次,多次执行 lock 后,只有执行相同次数的 unlock 操作,变量才能被解锁。
  • ② 如果对一个变量执行 lock 操作,将会清空工作内存中此变量的值,在执行引擎使用这个变量前,需要重新执行 load assign 操作初始化变量的值;
  • ③ 如果一个变量没有被 lock 操作锁定,则不允许对其执行 unlock 操作,也不允许 unlock 一个其它线程锁定的变量;
  • ④ 对一个变量执行 unlock 操作之前,必须先把此变量同步回主内存中,即执行 storewrite 操作;

通过规则 ①,我们知道对于 lock unlock 之间的代码,同一时刻只允许一个线程访问,所以,synchronized 是具有原子性的。

通过规则 ① ② 和 ④,我们知道每次 lockunlock 时都会从主内存加载变量或把变量刷新回主内存,而 lock 和 unlock 之间的变量(这里是指锁定的变量)是不会被其它线程修改的,所以,synchronized 是具有可见性的。

通过规则 ① 和 ③ ,我们知道所有对变量的加锁都要排队进行,且其它线程不允许解锁当前线程锁定的对象,所以,synchronized 是具有有序性的。

综上所述,synchronized 是可以保证原子性、可见性和有序性的。

synchronized 锁优化

Java在不断进化,同样地,Java 中像 synchronized 这种关键字也在不断优化,synchronized 有如下三种状态:

  • 偏向锁,是指一段同步代码一直被一个线程访问,那么这个线程会自动获取锁,降低获取锁的代价。
  • 轻量级锁,是指当锁是偏向锁时,被另一个线程所访问,偏向锁会升级为轻量级锁,这个线程会通过自旋的方式尝试获取锁,不会阻塞,提高性能。
  • 重量级锁,是指当锁是轻量级锁时,当自旋的线程自旋了一定的次数后,还没有获取到锁,就会进入阻塞状态,该锁升级为重量级锁,重量级锁会使其他线程阻塞,性能降低。

总结

(1)synchronized 在编译时会在同步块前后生成 monitorenter monitorexit 字节码指令;

(2)monitorentermonitorexit 字节码指令需要一个引用类型的参数,基本类型不可以哦;

(3)monitorentermonitorexit 字节码指令更底层是使用Java内存模型的 lock 和 unlock 指令;

(4)synchronized 是可重入锁;

(5)synchronized 是非公平锁;

(6)synchronized 可以同时保证原子性、可见性、有序性;

(7)synchronized 有三种状态:偏向锁、轻量级锁、重量级锁;

本篇文章就到这里了,希望能给你带来帮助,也希望你能够多多关注我们的更多内容!

(0)

相关推荐

  • 深入浅出学习AQS组件

    首先AQS的基本执行过程就是尝试获取锁,成功则返回,如果失败就进入同步队列进行锁资源的等待.基于这个流程可以看出队列跟队列中的节点应该是两个重点. 首先来看下AQS里队列节点Node的结构: 该类中有五个字段,依次来看一下: 1.prev,next:指向它的前置节点跟后继节点,由此看出AQS中的同步队列是个双向链表. 2.thread:当前线程对象. 3.waitStatus:当前节点的状态,是个int类型变量,依次有如下几种: 值 类型 说明 -1 SIGNAL 当前节点的后继节点被阻塞,因此

  • Java并发 结合源码分析AQS原理

    前言: 如果说J.U.C包下的核心是什么?那我想答案只有一个就是AQS.那么AQS是什么呢?接下来让我们一起揭开AQS的神秘面纱 AQS是什么? AQS是AbstractQueuedSynchronizer的简称.为什么说它是核心呢?是因为它提供了一个基于FIFO的队列和state变量来构建锁和其他同步装置的基础框架.下面是其底层的数据结构. AQS的特点 1.其内使用Node实现FIFO(FirstInFirstOut)队列.可用于构建锁或者其他同步装置的基础框架 2.且利用了一个int类表示

  • 详解Java并发编程之内置锁(synchronized)

    简介 synchronized在JDK5.0的早期版本中是重量级锁,效率很低,但从JDK6.0开始,JDK在关键字synchronized上做了大量的优化,如偏向锁.轻量级锁等,使它的效率有了很大的提升. synchronized的作用是实现线程间的同步,当多个线程都需要访问共享代码区域时,对共享代码区域进行加锁,使得每一次只能有一个线程访问共享代码区域,从而保证线程间的安全性. 因为没有显式的加锁和解锁过程,所以称之为隐式锁,也叫作内置锁.监视器锁. 如下实例,在没有使用synchronize

  • Java 多线程Synchronized和Lock的区别

    引言 在多线程中,为了使线程安全,我们经常会使用synchronized和Lock进行代码同步和加锁,但是具体两者有什么区别,什么场景下适合用什么可能还不大清楚,主要的区别大致如下: 区别 1.synchronized是java关键字,而Lock是java中的一个接口 2.synchronized会自动释放锁,而Lock必须手动释放锁 3.synchronized是不可中断的,Lock可以中断也可以不中断 4.通过Lock可以知道线程有没有拿到锁,而synchronized不能 5.synchr

  • Java的Synchronized关键字学习指南(全面 & 详细)

    前言 在Java中,有一个常被忽略 但 非常重要的关键字Synchronized今天,我将详细讲解 Java关键字Synchronized的所有知识,希望你们会喜欢 目录 1. 定义 Java中的1个关键字 2. 作用 保证同一时刻最多只有1个线程执行 被Synchronized修饰的方法 / 代码 其他线程 必须等待当前线程执行完该方法 / 代码块后才能执行该方法 / 代码块 3. 应用场景 保证线程安全,解决多线程中的并发同步问题(实现的是阻塞型并发),具体场景如下: 修饰 实例方法 / 代

  • 面试总结:秒杀设计、AQS 、synchronized相关问题

    1.面试官:如何设计一个秒杀系统?请你阐述流程? 这一面试题答案参考自三太子敖丙的文章:阿里面试官问我:如何设计秒杀系统?我给出接近满分的回答 秒杀系统要解决的几个问题? ① 高并发 秒杀的特点是时间极短. 瞬间用户量大.在秒杀活动持续时间内,Redis 服务器需要承受大量的用户请求,在大量请求条件下,缓存雪崩,缓存击穿,缓存穿透这些问题都是有可能发生的. 一旦缓存失效,或者缓存无效,每秒上万甚至十几万的QPS(每秒请求数)直接打到数据库,基本上都要把库打挂掉,而且你的服务不单单是做秒杀的还涉及

  • web面试常问http缓存解析相关

    目录 为什么要有http缓存? http缓存之 强制缓存 http缓存之 协商缓存(对比缓存) 协商缓存中的资源标识 为什么要有http缓存? 1.当输入网址到加载出页面, 电脑会经过"CPU计算.网络请求.页面渲染"等一系列步骤; 2."网络请求"是其中最不确定.最耗时的一个环节, 针对这个环节, 我们可以通过"减少网络请求的体积和数量", 来更快加载出页面, 这是"缓存"存在的原因; 3.通过"缓存"可

  • java锁synchronized面试常问总结

    目录 synchronized都问啥? synchronized是什么? synchronized锁什么? synchronized怎么用? 结语 synchronized都问啥? 如果Java面试有什么是必问的,synchronized必定占据一席之地.初出茅庐时synchronized的用法,成长后synchronized的原理,可谓是Java工程师的“一生之敌”. 按照惯例,先来看synchronized的常见问题(在线Excel同步更新中): 根据统计数据可以总结出synchronize

  • 浅谈Java并发之同步器设计

    前言: 在 Java并发内存模型详情了解到多进程(线程)读取共享资源的时候存在竞争条件. 计算机中通过设计同步器来协调进程(线程)之间执行顺序.同步器作用就像登机安检人员一样可以协调旅客按顺序通过. 在Java中,同步器可以理解为一个对象,它根据自身状态协调线程的执行顺序.比如锁(Lock),信号量(Semaphore),屏障(CyclicBarrier),阻塞队列(Blocking Queue). 这些同步器在功能设计上有所不同,但是内部实现上有共通的地方. 1.同步器 同步器的设计一般包含几

  • java分布式面试系统限流最佳实践

    目录 引言 1.面试官: 哪些场景系统使用了限流?为什么要使用限流? 2.面试官: 那你了解哪些常用限流算法? 1.计数器方法: 2.漏斗算法: 3.令牌桶算法: 3.面试官: 那具体这值该如何评估,说到现在我还是不知道限流到底要怎么设置,可以给我一点经验方法吗? 深入分析 使用线程池实现: 借助Guava实现: 总结 引言 前面讲了系统中的降级熔断设计和对 Hystrix 组件的功能了解,关于限流降级还有一个比较重要的知识点就是限流算法. 如果你面试的是电商相关公司,这一块就显得更加重要了,秒

  • JS面试之异步模拟超时重传机制详解

    目录 引言 题目分析 代码设计 核心讲解 引言 前面我讲解了两篇有关异步的逻辑思维题目,一个是红绿灯转换,还有一个是异步并发限制.有小伙伴私信我说不过瘾,希望还能再出一篇异步超时重传的讲解.为了满足这位粉丝的小小要求(我尼玛),我查询了相关资料和面试题,确实发现这是某大肠面试的代码设计题.不得不说这位粉丝发现的这个题目是相当亮眼,相当给力. 题目分析 超时重传机制,看到这个词语想必科班同学都十分十分熟悉吧.大家第一时间肯定会想到计算机网络中tcp的超时重传.不错,此处的异步模拟超时重传机制和计算

  • 详解基于java的Socket聊天程序——初始设计(附demo)

    写在前面: 可能是临近期末了,各种课程设计接踵而来,最近在csdn上看到2个一样问答,那就是编写一个基于socket的聊天程序,正好最近刚用socket做了一些事,出于兴趣,自己抽了几个晚上的空闲时间敲了一个,目前仅支持单聊,群聊,文件传送这些功能.首先,贴出一个丑丑的程序图(UI是用java swing写的,这个早就忘光了,无奈看着JDK的API写了一个),如下图:  服务端设计: 服务端主要有两个操作,一是阻塞接收客户端的socket并做响应处理,二是检测客户端的心跳,如果客户端一段时间内没

  • 腾讯面试:一条SQL语句执行得很慢的原因有哪些?---不看后悔系列(推荐)

    说实话,这个问题可以涉及到 MySQL 的很多核心知识,可以扯出一大堆,就像要考你计算机网络的知识时,问你"输入URL回车之后,究竟发生了什么"一样,看看你能说出多少了. 之前腾讯面试的实话,也问到这个问题了,不过答的很不好,之前没去想过相关原因,导致一时之间扯不出来.所以今天,我带大家来详细扯一下有哪些原因,相信你看完之后一定会有所收获,不然你打我. 开始装逼:分类讨论 一条 SQL 语句执行的很慢,那是每次执行都很慢呢?还是大多数情况下是正常的,偶尔出现很慢呢?所以我觉得,我们还得

  • Vue 级联下拉框的设计与实现

    目录 1.数据库设计 2.前端页面 3.一个完整的demo ​ 在前端开发中,级联选择框是经常用到的,这样不仅可以增加用户输入的友好性,还能减少前后端交互的数据量.本文以elementUI为例,使用其余UI组件大致思想也都相同. 1.数据库设计 ​ 所有的相关数据皆可存在一张表中,这样数据就可以不受层级的限制. ​ 表结构可以参考如下建表SQL: CREATE TABLE `supplies_type` ( `id` int(11) NOT NULL AUTO_INCREMENT, `categ

  • MySQL系列数据库设计三范式教程示例

    目录 一.数据库设计三范式相关知识说明 1.什么是设计范式? 2.为什么要学习数据库的三个范式? 3.三范式都有哪些? 二.数据库表的经典设计方案 一对一怎么设计? 一.数据库设计三范式相关知识说明 1.什么是设计范式? 设计表的依据,按照这三个范式设计出来的表,不会出现数据的冗余. 2.为什么要学习数据库的三个范式? 数据库的设计范式是数据库设计所需要满足的规范,满足这些规范的数据库是简洁的.结构明晰的,同时,不会发生插入(insert).删除(delete)和更新(update)操作异常.反

随机推荐