表结构如下:
1 |
|
application.yaml
项目的全部API在根目录下的postman文件夹中,可以在postman中导入
当线程被创建并启动以后,它既不是一启动就进入了执行状态,也不是一直处于执行状态。线程对象在不同的时期有不同的状态。那么Java中的线程存在哪几种状态呢?Java中的线程
状态被定义在了java.lang.Thread.State枚举类中,State枚举类的源码如下:
1 | public class Thread { |
通过源码我们可以看到Java中的线程存在6种状态,每种线程状态的含义如下
线程状态 | 具体含义 |
---|---|
NEW | 一个尚未启动的线程的状态。也称之为初始状态、开始状态。线程刚被创建,但是并未启动。还没调用start方法。MyThread t = new MyThread()只有线程象,没有线程特征。 |
RUNNABLE | 当我们调用线程对象的start方法,那么此时线程对象进入了RUNNABLE状态。那么此时才是真正的在JVM进程中创建了一个线程,线程一经启动并不是立即得到执行,线程的运行与否要听令与CPU的调度,那么我们把这个中间状态称之为可执行状态(RUNNABLE)也就是说它具备执行的资格,但是并没有真正的执行起来而是在等待CPU的度。 |
BLOCKED | 当一个线程试图获取一个对象锁,而该对象锁被其他的线程持有,则该线程进入Blocked状态;当该线程持有锁时,该线程将变成Runnable状态。 |
WAITING | 一个正在等待的线程的状态。也称之为等待状态。造成线程等待的原因有两种,分别是调用Object.wait()、join()方法。处于等待状态的线程,正在等待其他线程去执行一个特定的操作。例如:因为wait()而等待的线程正在等待另一个线程去调用notify()或notifyAll();一个因为join()而等待的线程正在等待另一个线程结束。 |
TIMED_WAITING | 一个在限定时间内等待的线程的状态。也称之为限时等待状态。造成线程限时等待状态的原因有三种,分别是:Thread.sleep(long),Object.wait(long)、join(long)。 |
TERMINATED | 一个完全运行完成的线程的状态。也称之为终止状态、结束状态 |
各个状态的转换,如下图所示:
为了验证上面论述的状态即状态转换的正确性,也为了加深对线程状态转换的理解,下面通过三个案例演示线程间中的状态转换。
本案例主要演示TIME_WAITING的状态转换。
需求:编写一段代码,依次显示一个线程的这些状态:NEW -> RUNNABLE -> TIME_WAITING -> RUNNABLE -> TERMINATED
为了简化我们的开发,本次我们使用匿名内部类结合lambda表达式的方式使用多线程。
代码实现
1 | public class ThreadStateDemo01 { |
控制台输出
1 | 1.通过new初始化一个线程,但是还没有start()之前,线程的状态:NEW |
本案例主要演示WAITING的状态转换。
需求:编写一段代码,依次显示一个线程的这些状态:NEW -> RUNNABLE -> WAITING -> RUNNABLE -> TERMINATED
1 | public class ThreadStateDemo02 { |
控制台输出结果
1 | 1.通过new初始化一个线程,但是还没有start()之前,线程的状态:NEW |
本案例主要演示BLOCKED的状态转换。
需求:编写一段代码,依次显示一个线程的这些状态:NEW -> RUNNABLE -> BLOCKED -> RUNNABLE -> TERMINATED
1 | public class ThreadStateDemo03 { |
控制台输出结果
1 | 1.通过new初始化一个线程,但是还没有thread.start()之前,线程的状态:NEW |
通过上面3个案例的代码演示,我们可以证明开始章节说所述的线程状态以及线程状态转换都是正确的。
提到池,大家应该能想到的就是水池。水池就是一个容器,在该容器中存储了很多的水。那么什么是线程池呢?线程池也是可以看做成一个池子,在该池子中存储很多个线程。
线程池存在的意义:
系统创建一个线程的成本是比较高的,因为它涉及到与操作系统交互,当程序中需要创建大量生存期很短暂的线程时,频繁的创建和销毁线程对系统的资源消耗有可能大于业务处理是对系
统资源的消耗,这样就有点”舍本逐末”了。针对这一种情况,为了提高性能,我们就可以采用线程池。线程池在启动的时,会创建大量空闲线程,当我们向线程池提交任务的时,线程池就
会启动一个线程来执行该任务。等待任务执行完毕以后,线程并不会死亡,而是再次返回到线程池中称为空闲状态。等待下一次任务的执行。
线程池的思路和生产者消费者模型是很接近的
在整个过程中,都不需要创建新的线程,而是循环使用这些已经存在的线程。
实现思路:
线程池类
1 | public class ThreadPool { |
测试类
1 | public class ThreadPoolDemo01 { |
使用无参构造方法创建线程池对象,控制台输出结果
1 | 线程--->0---->>>处理了任务 |
通过控制台的输出,我们可以看到在线程池中存在两个线程,通过这2个线程处理了10个任务。
使用有参构造方法创建线程池对象,传递的参数是5,控制台输出结果
1 | 线程--->3---->>>处理了任务 |
通过控制台的输出,我们可以看到在线程池中存在两个线程,通过这5个线程处理了10个任务。
JDK对线程池也进行了相关的实现,在真实企业开发中我们也很少去自定义线程池,而是使用JDK中自带的线程池。
我们可以使用Executors中所提供的静态方法来创建线程池。
获取线程池的方法:
//通过不同的方法创建出来的线程池具有不同的特点。
1 | ExecutorService newCachedThreadPool(): 创建一个可缓存线程池,可灵活的去创建线程,并且灵活的回收线程,若无可回收,则新建线程。 |
这个方法返回的都是ExecutorService类型的对象(ScheduledExecutorService继承ExecutorService),而ExecutorService可以看做就是一个线程池,那么ExecutorService
给我们提供了哪些方法供我们使用呢?
ExecutorService中的常见方法:
1 | Future<?> submit(Runnable task):提交任务方法 |
案例1:演示newCachedThreadPool方法所获取到的线程池的特点
测试类
1 | public class ExecutorsDemo01 { |
控制台输出结果
1 | pool-1-thread-2---执行了任务 |
针对每一个任务,线程池为其分配一个线程去执行,我们可以在第二次提交任务的时候,让主线程休眠一小会儿,看程序的执行结果。
1 | public class ExecutorsDemo02 { |
控制台输出结果
1 | pool-1-thread-1---执行了任务 |
我们发现是通过一个线程执行了两个任务。此时就说明线程池中的线程”pool-1-thread-1”被线程池回收了,成为了空闲线程,当我们再次提交任务的时候,该线程就去执行新的任务。
案例2:演示newFixedThreadPool方法所获取到的线程池的特点
测试类
1 | public class ExecutorsDemo03 { |
控制台输出结果
1 | pool-1-thread-1----->>>执行了任务 |
通过控制台的输出结果,我们可以看到5个任务是通过3个线程进行执行的,说明此线程池中存在三个线程对象
案例3:演示newSingleThreadExecutor方法所获取到的线程池的特点
测试类
1 | public class ExecutorsDemo04 { |
控制台输出结果
1 | pool-1-thread-1----->>>执行了任务 |
通过控制台的输出结果,我们可以看到5个任务是通过1个线程进行执行的,说明此线程池中只存在一个线程对象。
案例4: 演示newSingleThreadScheduledExecutor方法所获取到的线程池的特点(初始化一个具有一个线程的线程池)
测试类
1 | public class ExecutorsDemo05 { |
控制台输出结果
1 | pool-1-thread-1---->>执行了任务 |
通过控制台的输出结果,我们可以看到5个任务是通过1个线程进行执行的,说明此线程池中只存在一个线程对象。
案例5: 演示newSingleThreadScheduledExecutor方法所获取到的线程池的特点(支持定时及周期性任务执行)
ScheduledExecutorService中和定时以及周期性执行相关的方法
1 | /* |
测试类1(演示定时执行)
1 | public class ExecutorsDemo06 { |
测试类2(演示周期性执行)
1 | public class ExecutorsDemo07 { |
刚才我们是通过Executors中的静态方法去创建线程池的,通过查看源代码我们发现,其底层都是通过ThreadPoolExecutor构建的。比如:newFixedThreadPool方法的源码
1 | public static ExecutorService newFixedThreadPool(int nThreads) { |
那么也可以使用ThreadPoolExecutor去创建线程池。
ThreadPoolExecutor最完整的构造方法:
1 | public ThreadPoolExecutor(int corePoolSize, |
参数说明
1 | corePoolSize: 核心线程的最大值,不能小于0 |
案例演示通过ThreadPoolExecutor创建线程池
1 | public class ThreadPoolExecutorDemo01 { |
接下来我们就来研究一下线程池的工作原理,如下图所示
当我们通过submit方法向线程池中提交任务的时候,具体的工作流程如下:
举例说明:
假如有一个工厂,工厂里面有10个工人(正式员工),每个工人同时只能做一件任务。因此只要当10个工人中有工人是空闲的,来了任务就分配给空闲的工人做;当10个工人都有任务在做时,
如果还来了任务,就把任务进行排队等待;如果说新任务数目增长的速度远远大于工人做任务的速度,那么此时工厂主管可能会想补救措施,比如重新招4个临时工人进来;然后就将任务也分配
给这4个临时工人做;如果说着14个工人做任务的速度还是不够,此时工厂主管可能就要考虑不再接收新的任务或者抛弃前面的一些任务了。当这14个工人当中有人空闲时,而新任务增长的速度
又比较缓慢,工厂主管可能就考虑辞掉4个临时工了,只保持原来的10个工人,毕竟请额外的工人是要花钱的。
这里的工厂可以看做成是一个线程池,每一个工人可以看做成是一个线程。其中10个正式员工,可以看做成是核心线程池中的线程,临时工就是非核心线程池中的线程。当临时工处于空闲状态
的时候,那么如果空闲的时间超过keepAliveTime所指定的时间,那么就会被销毁。
接下来我们就通过一段代码的断点测试,来演示一下线程池的工作原理。
案例代码
1 | public class ThreadPoolExecutorDemo01 { |
初次debug方式启动线程,查看变量值
由于此时还没有提交任务,因此线程池中的线程数量为0,工作队列的任务数量也为0;提交一个任务
再次查看各个值的变化
再次提交一个任务
再次查看各个值的变化
此时会把第二个任务存储到工作队列中,因此工作队列的值为1了。再次提交一个任务
再次查看各个值的变化
此时3个任务都以及提交完毕,断点跳过。经过20s以后,再次查看该进程中的线程。
我们发现非核心线程已经被线程池回收了。
RejectedExecutionHandler是jdk提供的一个任务拒绝策略接口,它下面存在4个子类。
1 | ThreadPoolExecutor.AbortPolicy: 丢弃任务并抛出RejectedExecutionException异常。是默认的策略。 |
注:明确线程池对多可执行的任务数 = 队列容量 + 最大线程数
案例演示1:演示ThreadPoolExecutor.AbortPolicy任务处理策略
1 | public class ThreadPoolExecutorDemo01 { |
控制台输出结果
1 | Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task java.util.concurrent.FutureTask@566776ad[Not completed, task = java.util.concurrent.Executors$RunnableAdapter [Wrapped task = com.itheima.javase.thread.pool.demo04.ThreadPoolExecutorDemo01$$Lambda$14/0x0000000100066840@2f7a2457]] rejected from java.util.concurrent.ThreadPoolExecutor@6108b2d7[Running, pool size = 3, active threads = 3, queued tasks = 1, completed tasks = 0] |
控制台报错,仅仅执行了4个任务,有一个任务被丢弃了
案例演示2:演示ThreadPoolExecutor.DiscardPolicy任务处理策略
1 | public class ThreadPoolExecutorDemo02 { |
控制台输出结果
1 | pool-1-thread-1---->> 执行了任务 |
控制台没有报错,仅仅执行了4个任务,有一个任务被丢弃了
案例演示3:演示ThreadPoolExecutor.DiscardOldestPolicy任务处理策略
1 | public class ThreadPoolExecutorDemo02 { |
控制台输出结果
1 | pool-1-thread-2---->> 执行了任务2 |
由于任务1在线程池中等待时间最长,因此任务1被丢弃。
案例演示4:演示ThreadPoolExecutor.CallerRunsPolicy任务处理策略
1 | public class ThreadPoolExecutorDemo04 { |
控制台输出结果
1 | pool-1-thread-1---->> 执行了任务 |
通过控制台的输出,我们可以看到次策略没有通过线程池中的线程执行任务,而是直接调用任务的run()方法绕过线程池直接执行。
分析如下程序,说出在控制台的输出结果。
Thread的子类
1 | public class VolatileThread extends Thread { |
测试类
1 | public class VolatileThreadDemo01 { |
控制台输出结果
1 | 前面是false,过了一段时间之后就变成了true |
按照我们的分析,当我们把volatileThread线程启动起来以后,那么volatileThread线程开始执行。在volatileThread线程的run方法中,线程休眠1s,休眠一秒以后那么flag的值应该为
true,此时我们在主线程中不停的获取flag的值。发现前面释放false,后面是true
信息,那么这是为什么呢?要想知道原因,那么我们就需要学习一下JMM。
概述:JMM(Java Memory Model)Java内存模型,是java虚拟机规范中所定义的一种内存模型。
Java内存模型(Java Memory Model)描述了Java程序中各种变量(线程共享变量)的访问规则,以及在JVM中将变量存储到内存和从内存中读取变量这样的底层细节。
特点:
所有的共享变量都存储于主内存(计算机的RAM)这里所说的变量指的是实例变量和类变量。不包含局部变量,因为局部变量是线程私有的,因此不存在竞争问题。
每一个线程还存在自己的工作内存,线程的工作内存,保留了被线程使用的变量的工作副本。
线程对变量的所有的操作(读,写)都必须在工作内存中完成,而不能直接读写主内存中的变量,不同线程之间也不能直接访问对方工作内存中的变量,线程间变量的值的传递需要通过主
内存完成。
了解了一下JMM,那么接下来我们就来分析一下上述程序产生问题的原因。
产生问题的流程分析:
VolatileThread线程从主内存读取到数据放入其对应的工作内存
将flag的值更改为true,但是这个时候flag的值还没有回写主内存
此时main线程读取到了flag的值并将其放入到自己的工作内存中,此时flag的值为false
VolatileThread线程将flag的值写回到主内存,但是main函数里面的while(true)调用的是系统比较底层的代码,速度快,快到没有时间再去读取主内存中的值,所以while(true)
读取到的值一直是false。(如果有一个时刻main线程从主内存中读取到了flag的最新值,那么if语句就可以执行,main线程何时从主内存中读取最新的值,我们无法控制)
我们可以让主线程执行慢一点,执行慢一点以后,在某一个时刻,可能就会读取到主内存中最新的flag的值,那么if语句就可以进行执行。
测试类
1 | public class VolatileThreadDemo02 { |
控制台输出结果
1 | flag=true |
此时我们可以看到if语句已经执行了。当然我们在真实开发中可能不能使用这种方式来处理这个问题,那么这个问题应该怎么处理呢?我们就需要学习下一小节的内容。
第一种处理方案,我们可以通过加锁的方式进行处理。
测试类
1 | public class VolatileThreadDemo03 { |
控制台输出结果
1 | flag=true |
工作原理说明
对上述代码加锁完毕以后,某一个线程支持该程序的过程如下:
a.线程获得锁
b.清空工作内存
c.从主内存拷贝共享变量最新的值到工作内存成为副本
d.执行代码
e.将修改后的副本的值刷新回主内存中
f.线程释放锁
第二种处理方案,我们可以通过volatile关键字来修饰flag变量。
线程类
1 | public class VolatileThread extends Thread { |
控制台输出结果
1 | flag=true |
工作原理说明
执行流程分析
总结: volatile保证不同线程对共享变量操作的可见性,也就是说一个线程修改了volatile修饰的变量,当修改写回主内存时,另外一个线程立即看到最新的值。
但是volatile不保证原子性(关于原子性问题,我们在下面的小节中会介绍)。
volatile与synchronized的区别:
volatile只能修饰实例变量和类变量,而synchronized可以修饰方法,以及代码块。
volatile保证数据的可见性,但是不保证原子性(多线程进行写操作,不保证线程安全);而synchronized是一种排他(互斥)的机制(因此有时我们也将synchronized这种锁称
之为排他(互斥)锁),synchronized修饰的代码块,被修饰的代码块称之为同步代码块,无法被中断可以保证原子性,也可以间接的保证可见性。
概述:所谓的原子性是指在一次操作或者多次操作中,要么所有的操作全部都得到了执行并且不会受到任何因素的干扰而中断,要么所有的操作都不执行,多个操作是一个不可以分割的整体。
//比如说:你喂你女朋友吃冰淇淋,如果没有女朋友,你就假想一下,实在不行,你就喂你旁边的哥们吃一口冰淇淋。这就是一个不可分割的整体,一个是你喂,一个是她吃。这就是一个整体,如果没有她吃,那么你喂就没有意义,如果没有你喂,她吃就没有意义。
//比如:从张三的账户给李四的账户转1000元,这个动作将包含两个基本的操作:从张三的账户扣除1000元,给李四的账户增加1000元。这两个操作必须符合原子性的要求,要么都成功要么
都失败。
分析如下程序的执行结果
线程类
1 | public class VolatileAtomicThread implements Runnable { |
测试类
1 | public class VolatileAtomicThreadDemo { |
程序分析:我们在主线程中通过for循环启动了100个线程,每一个线程都会对VolatileAtomicThread类中的count加100次。那么直接结果应该是10000。但是真正的执行结果和我们分析
的是否一样呢?运行程序(多运行几次),查看控制台输出结果
1 | .... |
通过控制台的输出,我们可以看到最终count的结果可能并不是10000。接下来我们就来分析一下问题产生的原因。
以上问题主要是发生在count++操作上:
count++操作包含3个步骤:
count++操作不是一个原子性操作,也就是说在某一个时刻对某一个操作的执行,有可能被其他的线程打断。
产生问题的执行流程分析:
假设此时count的值是100,线程A需要对改变量进行自增1的操作,首先它需要从主内存中读取变量count的值。由于CPU的切换关系,此时CPU的执行权被切换到了B线程。A线程就处
于就绪状态,B线程处于运行状态。
线程B也需要从主内存中读取count变量的值,由于线程A没有对count值做任何修改因此此时B读取到的数据还是100
线程B工作内存中对count执行了+1操作,但是未刷新之主内存中
此时CPU的执行权切换到了A线程上,由于此时线程B没有将工作内存中的数据刷新到主内存,因此A线程工作内存中的变量值还是100,没有失效。A线程对工作内存中的数据进行了+1操作。
线程B将101写入到主内存
线程A将101写入到主内存
虽然计算了2次,但是只对A进行了1次修改。
我们刚才说到了volatile在多线程环境下只保证了共享变量在多个线程间的可见性,但是不保证原子性。那么接下来我们就来做一个测试。测试的思想,就是使用volatile修饰count。
线程类
1 | public class VolatileAtomicThread implements Runnable { |
控制台输出结果(需要运行多次)
1 | ... |
通过控制台结果的输出,我们可以看到程序还是会出现问题。因此也就证明volatile关键字是不保证原子性的。
volatile关键字不保证原子性操作,那么同学们可能会存在一些疑问,volatile关键字在什么情况下进行使用呢?这里我们举两个基本的使用场景。
比如现在存在一个线程不断向控制台输出一段话”传智播客中国IT教育的标杆….”,当这个线程执行5秒以后,将该线程结束。
实现思路:定义一个boolean类型的变量,这个变量就相当于一个标志。当这个变量的值为true的时候,线程一直执行,10秒以后我们把这个变量的值更改为false,此时结束该线程的执行。
为了保证一个线程对这个变量的修改,另外一个线程立马可以看到,这个变量就需要通过volatile关键字进行修饰。
线程类
1 | public class VolatileUseThread implements Runnable { |
测试类
1 | public class VolatileUseThreadDemo01 { |
观察控制台输出,volatileUseThread线程执行5秒以后程序结束。
//AI养猪。。。。
//设备区测量温度
//当温度高了。。。需要给猪开空调。。。加冰棍。。。加喝的水。。。
volatile的另一种简单使用场景是:定期”发布”观察结果供程序内部使用。例如,假设有一种环境传感器能够感觉环境温度。一个后台线程可能会每隔几秒读取一次该传感器数据,并更新包
含这个volatile变量的值。然后,其他线程可以读取这个变量,从而随时能够看到最新的温度值。这种使用就是多个线程操作共享变量,但是是有一个线程对其进行写操作,其他的线程都是读。
我们可以设计一个程序,模拟上面的温度传感器案例。
实现步说明
定义一个温度传感器(TemperatureSensor)的类,在该类中定义两个成员变量(temperature(温度值),type(传感器的类型)),temperature变量需要被volatile修饰
定义一个读取温度传感器的线程的任务类(ReadTemperatureRunnable),该类需要定义一个TemperatureSensor类型的成员变量(该线程需要读取温度传感器的数据)
定义一个定时采集温度的线程任务类(GatherTemperatureRunnable),该类需要定义一个TemperatureSensor类型的成员变量(该线程需要将读到的温度设置给传感器)
创建测试类(TemperatureSensorDemo)
TemperatureSensor类
1 | public class TemperatureSensor { // 温度传感器类 |
ReadTemperatureRunnable类
1 | public class ReadTemperatureRunnable implements Runnable { |
GatherTemperatureRunnable类
1 | public class GatherTemperatureRunnable implements Runnable { |
测试类
1 | public class TemperatureSensorDemo { |
控制台输出结果
1 | ... |
通过控制台的输出,我们可以看到当温度采集线程刚采集到环境温度以后,那么此时两个温度读取线程就可以立即感知到环境温度的变化。
接下来我们就来讲解一下我们上述案例(引入原子性问题的案例)的解决方案。
我们可以给count++操作添加锁,那么count++操作就是临界区中的代码,临界区中的代码一次只能被一个线程去执行,所以count++就变成了原子操作。
线程任务类
1 | public class VolatileAtomicThread implements Runnable { |
控制台输出结果
1 | count =========>>>> 9998 |
概述:java从JDK1.5开始提供了java.util.concurrent.atomic包(简称Atomic包),这个包中的原子操作类提供了一种用法简单,性能高效,线程安全地更新一个变量的方式。因为变
量的类型有很多种,所以在Atomic包里一共提供了13个类,属于4种类型的原子更新方式,分别是原子更新基本类型、原子更新数组、原子更新引用和原子更新属性(字段)。本次我们只讲解
使用原子的方式更新基本类型,使用原子的方式更新基本类型Atomic包提供了以下3个类:
AtomicBoolean: 原子更新布尔类型
AtomicInteger: 原子更新整型
AtomicLong:原子更新长整型
以上3个类提供的方法几乎一模一样,所以本节仅以AtomicInteger为例进行讲解,AtomicInteger的常用方法如下:
1 | public AtomicInteger(): 初始化一个默认值为0的原子型Integer |
案例演示AtomicInteger的基本使用:
1 | public class AtomicIntegerDemo01 { |
使用AtomicInteger对案例进行改造。
1 | public class VolatileAtomicThread implements Runnable { |
控制台输出结果
1 | ... |
通过控制台的执行结果,我们可以看到最终得到的结果就是10000,因此也就证明AtomicInteger所提供的方法是原子性操作方法。
AtomicInteger的本质:自旋锁 + CAS算法
CAS的全成是: Compare And Swap(比较再交换); 是现代CPU广泛支持的一种对内存中的共享数据进行操作的一种特殊指令。CAS可以将read-modify-write转换为原子操作,这个原子操作
直接由处理器保证。CAS有3个操作数,内存值V,旧的预期值A,要修改的新值B。当且仅当旧预期值A和内存值V相同时,将内存值V修改为B并返回true,否则什么都不做,并返回false。
举例说明:
举例说明:这好比春节的时候抢火车票,下手快的会抢先买到票,而下手慢的可以再次尝试,直到买到票。
那么接下来我们就来查看一下AtomicInteger类中incrementAndGet方法的源码。
1 | public class AtomicInteger extends Number implements java.io.Serializable { |
UnSafe类
1 | public final class Unsafe { |
CAS和Synchronized都可以保证多线程环境下共享数据的安全性。那么他们两者有什么区别?
Synchronized是从悲观的角度出发:
总是假设最坏的情况,每次去拿数据的时候都认为别人会修改,所以每次在拿数据的时候都会上锁,这样别人想拿这个数据就会阻塞直到它拿到锁(共享资源每次只给一个线程使用,其它线
程阻塞,用完后再把资源转让给其它线程)。因此Synchronized我们也将其称之为悲观锁。jdk中的ReentrantLock也是一种悲观锁。
CAS是从乐观的角度出发:
总是假设最好的情况,每次去拿数据的时候都认为别人不会修改,所以不会上锁,但是在更新的时候会判断一下在此期间别人有没有去更新这个数据。CAS这种机制我们也可以将其称之为乐观锁。
在JDK的并发包里提供了几个非常有用的并发容器和并发工具类。供我们在多线程开发中进行使用。
在集合类中HashMap是比较常用的集合对象,但是HashMap是线程不安全的(多线程环境下可能会存在问题)。为了保证数据的安全性我们可以使用Hashtable,但是Hashtable的效率低下。
基于以上两个原因我们可以使用JDK1.5以后所提供的ConcurrentHashMap。
案例1:演示HashMap线程不安全
实现步骤
测试类
1 | public class HashMapDemo01 { |
控制台输出结果
1 | ---------------------------------------------------------- |
通过控制台的输出结果,我们可以看到在多线程操作HashMap的时候,可能会出现线程安全问题。
注1:需要多次运行才可以看到具体的效果; 可以使用循环将代码进行改造,以便让问题方便的暴露出来!
案例2:演示Hashtable线程安全
测试类
1 | public class HashtableDemo01 { |
不论该程序运行多少次,都不会产生数据问题。因此也就证明Hashtable是线程安全的。
Hashtable保证线程安全的原理:
查看Hashtable的源码
1 | public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, java.io.Serializable { |
对应的结构如下图所示
Hashtable保证线程安全性的是使用方法全局锁进行实现的。在线程竞争激烈的情况下HashTable的效率非常低下。因为当一个线程访问HashTable的同步方法,其他线程也访问HashTable
的同步方法时,会进入阻塞状态。如线程1使用put进行元素添加,线程2不但不能使用put方法添加元素,也不能使用get方法来获取元素,所以竞争越激烈效率越低。
案例3:演示ConcurrentHashMap线程安全
测试类
1 | public class ConcurrentHashMapDemo01 { |
不论该程序运行多少次,都不会产生数据问题。因此也就证明ConcurrentHashMap是线程安全的。
由于ConcurrentHashMap在jdk1.7和jdk1.8的时候实现原理不太相同,因此需要分别来讲解一下两个不同版本的实现原理。
ConcurrentHashMap中的重要成员变量
1 | public class ConcurrentHashMap<K, V> extends AbstractMap<K, V> implements ConcurrentMap<K, V>, Serializable { |
对应的结构如下图所示
简单来讲,就是ConcurrentHashMap比HashMap多了一次hash过程,第1次hash定位到Segment,第2次hash定位到HashEntry,然后链表搜索找到指定节点。在进行写操作时,只需锁住写
元素所在的Segment即可(这种锁被称为分段锁),其他Segment无需加锁,从而产生锁竞争的概率大大减小,提高了并发读写的效率。该种实现方式的缺点是hash过程比普通的HashMap要长
(因为需要进行两次hash操作)。
ConcurrentHashMap的put方法源码分析
1 | public class ConcurrentHashMap<K, V> extends AbstractMap<K, V> implements ConcurrentMap<K, V>, Serializable { |
注:源代码进行简单讲解即可(核心:进行了两次哈希定位以及加锁过程)
在JDK1.8中为了进一步优化ConcurrentHashMap的性能,去掉了Segment分段锁的设计。在数据结构方面,则是跟HashMap一样,使用一个哈希表table数组。(数组 + 链表 + 红黑树)
而线程安全方面是结合CAS机制 + 局部锁实现的,减低锁的粒度,提高性能。同时在HashMap的基础上,对哈希表table数组和链表节点的value,next指针等使用volatile来修饰,从而
实现线程可见性。
ConcurrentHashMap中的重要成员变量
1 | public class ConcurrentHashMap<K,V> extends AbstractMap<K,V> implements ConcurrentMap<K,V>, Serializable { |
对应的结构如下图
ConcurrentHashMap的put方法源码分析
1 | public class ConcurrentHashMap<K,V> extends AbstractMap<K,V> implements ConcurrentMap<K,V>, Serializable { |
简单总结:
如果当前需要put的key对应的链表在哈希表table中还不存在,即还没添加过该key的hash值对应的链表,则调用casTabAt方法,基于CAS机制来实现添加该链表头结点到哈希表
table中,避免该线程在添加该链表头结的时候,其他线程也在添加的并发问题;如果CAS失败,则进行自旋,通过继续第2步的操作;
如果需要添加的链表已经存在哈希表table中,则通过tabAt方法,基于volatile机制,获取当前最新的链表头结点f,由于f指向的是ConcurrentHashMap的哈希表table的某条
链表的头结点,故虽然f是临时变量,由于是引用共享的该链表头结点,所以可以使用synchronized关键字来同步多个线程对该链表的访问。在synchronized(f)同步块里面则是与
HashMap一样遍历该链表,如果该key对应的链表节点已经存在,则更新,否则在链表的末尾新增该key对应的链表节点。
CountDownLatch允许一个或多个线程等待其他线程完成操作以后,再执行当前线程;比如我们在主线程需要开启2个其他线程,当其他的线程执行完毕以后我们再去执行主线程,针对这
个需求我们就可以使用CountDownLatch来进行实现。CountDownLatch中count down是倒着数数的意思;CountDownLatch是通过一个计数器来实现的,每当一个线程完成了自己的
任务后,可以调用countDown()方法让计数器-1,当计数器到达0时,调用CountDownLatch的await()方法的线程阻塞状态解除,继续执行。
CountDownLatch的相关方法
1 | public CountDownLatch(int count)// 初始化一个指定计数器的CountDownLatch对象 |
案例演示:使用CountDownLatch完成上述需求(我们在主线程需要开启2个其他线程,当其他的线程执行完毕以后我们再去执行主线程)
实现思路:在main方法中创建一个CountDownLatch对象,把这个对象作为作为参数传递给其他的两个任务线程
线程任务类1
1 | public class CountDownLatchThread01 implements Runnable { |
线程任务类2
1 | public class CountDownLatchThread02 implements Runnable { |
测试类
1 | public class CountDownLatchDemo01 { |
控制台输出结果
1 | 3秒以后执行了CountDownLatchThread02...... |
CountDownLatchThread02线程先执行完毕,此时计数器-1;CountDownLatchThread01线程执行完毕,此时计数器-1;当计数器的值为0的时候,主线程阻塞状态接触,主线程向下执行。
CyclicBarrier的字面意思是可循环使用(Cyclic)的屏障(Barrier)。它要做的事情是,让一组线程到达一个屏障(也可以叫同步点)时被阻塞,直到最后一个线程到达屏障时,屏障
才会开门,所有被屏障拦截的线程才会继续运行。
例如:公司召集5名员工开会,等5名员工都到了,会议开始。我们创建5个员工线程,1个开会线程,几乎同时启动,使用CyclicBarrier保证5名员工线程全部执行后,再执行开会线程。
CyclicBarrier的相关方法
1 | public CyclicBarrier(int parties, Runnable barrierAction) // 用于在线程到达屏障时,优先执行barrierAction,方便处理更复杂的业务场景 |
案例演示:模拟员工开会
实现步骤:
员工线程类
1 | public class EmployeeThread extends Thread { |
开会线程类
1 | public class MettingThread extends Thread { |
测试类
1 | public class CyclicBarrierDemo01 { |
使用场景:CyclicBarrier可以用于多线程计算数据,最后合并计算结果的场景。
比如:现在存在两个文件,这个两个文件中存储的是某一个员工两年的工资信息(一年一个文件),现需要对这两个文件中的数据进行汇总;使用两个线程读取2个文件中的数据,当两个文
件中的数据都读取完毕以后,进行数据的汇总操作。
分析:要想在两个线程读取数据完毕以后进行数据的汇总,那么我们就需要定义一个任务类(该类需要实现Runnable接口);两个线程读取完数据以后再进行数据的汇总,那么我们可以将
两个线程读取到的数据先存储到一个集合中,而多线程环境下最常见的线程集合类就是ConcurrentHashMap,而这个集合需要被两个线程都可以进行使用,那么我们可以将这个集
合作为我们任务类的成员变量,然后我们在这个任务类中去定义一个CyclicBarrier对象,然后在定义一个方法(count),当调用这个count方法的时候需要去开启两个线程对象,
使用这两个线程对象读取数据,把读取到的数据存储到ConcurrentHashMap对象,当一个线程读取数据完毕以后,调用CyclicBarrier的awit方法(告诉CyclicBarrier我已经
到达了屏障),然后在任务类的run方法对ConcurrentHashMap的数据进行汇总操作;
实现步骤:
1 | private CyclicBarrier cyclicBarrier = new CyclicBarrier(2 , this) ; |
任务类代代码:
1 | public class CyclicBarrierThreadUse implements Runnable { |
测试类代码:
1 | public class CyclicBarrierThreadUseDemo01 { |
Semaphore字面意思是信号量的意思,它的作用是控制访问特定资源的线程数目。
举例:现在有一个十字路口,有多辆汽车需要进经过这个十字路口,但是我们规定同时只能有两辆汽车经过。其他汽车处于等待状态,只要某一个汽车经过了这个十字路口,其他的汽车才可以经
过,但是同时只能有两个汽车经过。如何限定经过这个十字路口车辆数目呢? 我们就可以使用Semaphore。
Semaphore的常用方法
1 | public Semaphore(int permits)permits 表示许可线程的数量 |
案例演示:模拟汽车通过十字路口
实现步骤:
CarThreadRunnable类
1 | public class CarThreadRunnable implements Runnable { |
测试类
1 | public class SemaphoreDemo01 { |
控制台输出结果
1 | Thread-0----->>正在经过十字路口 |
通过控制台输出,我们可以看到当某一个汽车”驶出”十字路口以后,就会有一个汽车立马驶入。
Exchanger(交换者)是一个用于线程间协作的工具类。Exchanger用于进行线程间的数据交换。
举例:比如男女双方结婚的时候,需要进行交换结婚戒指。
Exchanger常用方法
1 | public Exchanger()// 构造方法 |
这两个线程通过exchange方法交换数据,如果第一个线程先执行exchange()方法,它会一直等待第二个线程也执行exchange方法,当两个线程都到达同步点时,这两个线程就可以交换数据,
将本线程生产出来的数据传递给对方。
案例演示:模拟交互结婚戒指
实现步骤:
ManThread类
1 | public class ManThread extends Thread { |
WomanThread类
1 | public class WomanThread extends Thread { |
测试类
1 | public class ExchangerDemo01 { |
使用场景:可以做数据校对工作
比如: 现在存在一个文件,该文件中存储的是某一个员工一年的工资信息,现需要将这个员工的工资信息录入到系统中,采用AB岗两人进行录入,录入到两个文件中,系统需要加载这两
个文件,并对两个文件数据进行校对,看看是否录入一致,
实现步骤:
ExchangerUseDemo类
1 | public class ExchangerUseDemo { |
声明:本页面文字完全转载,仅供个人学习使用,如有侵权请联系!
数据定义语言
查询所有数据库:SHOW DATABASES;
查询当前数据库:SELECT DATABASE();
创建数据库:CREATE DATABASE [ IF NOT EXISTS ] 数据库名 [ DEFAULT CHARSET 字符集] [COLLATE 排序规则 ];
删除数据库:DROP DATABASE [ IF EXISTS ] 数据库名;
使用数据库:USE 数据库名;
查询当前数据库所有表:SHOW TABLES;
查询表结构:DESC 表名;
查询指定表的建表语句:SHOW CREATE TABLE 表名;
创建表:
1 | CREATE TABLE 表名( |
最后一个字段后面没有逗号
添加字段:ALTER TABLE 表名 ADD 字段名 类型(长度) [COMMENT 注释] [约束];
例:ALTER TABLE emp ADD nickname varchar(20) COMMENT '昵称';
修改数据类型:ALTER TABLE 表名 MODIFY 字段名 新数据类型(长度);
修改字段名和字段类型:ALTER TABLE 表名 CHANGE 旧字段名 新字段名 类型(长度) [COMMENT 注释] [约束];
例:将emp表的nickname字段修改为username,类型为varchar(30)ALTER TABLE emp CHANGE nickname username varchar(30) COMMENT '昵称';
删除字段:ALTER TABLE 表名 DROP 字段名;
修改表名:ALTER TABLE 表名 RENAME TO 新表名
删除表:DROP TABLE [IF EXISTS] 表名;
删除表,并重新创建该表:TRUNCATE TABLE 表名;
指定字段:INSERT INTO 表名 (字段名1, 字段名2, ...) VALUES (值1, 值2, ...);
全部字段:INSERT INTO 表名 VALUES (值1, 值2, ...);
批量添加数据:INSERT INTO 表名 (字段名1, 字段名2, ...) VALUES (值1, 值2, ...), (值1, 值2, ...), (值1, 值2, ...);
INSERT INTO 表名 VALUES (值1, 值2, ...), (值1, 值2, ...), (值1, 值2, ...);
修改数据:UPDATE 表名 SET 字段名1 = 值1, 字段名2 = 值2, ... [ WHERE 条件 ];
例:UPDATE emp SET name = 'Jack' WHERE id = 1;
删除数据:DELETE FROM 表名 [ WHERE 条件 ];
语法:
1 | SELECT |
查询多个字段:SELECT 字段1, 字段2, 字段3, ... FROM 表名;
SELECT * FROM 表名;
设置别名:SELECT 字段1 [ AS 别名1 ], 字段2 [ AS 别名2 ], 字段3 [ AS 别名3 ], ... FROM 表名;
SELECT 字段1 [ 别名1 ], 字段2 [ 别名2 ], 字段3 [ 别名3 ], ... FROM 表名;
去除重复记录:SELECT DISTINCT 字段列表 FROM 表名;
转义:SELECT * FROM 表名 WHERE name LIKE '/_张三' ESCAPE '/'
/ 之后的_不作为通配符
语法:SELECT 字段列表 FROM 表名 WHERE 条件列表;
条件:
比较运算符 | 功能 |
---|---|
> | 大于 |
>= | 大于等于 |
< | 小于 |
<= | 小于等于 |
= | 等于 |
<> 或 != | 不等于 |
BETWEEN … AND … | 在某个范围内(含最小、最大值) |
IN(…) | 在in之后的列表中的值,多选一 |
LIKE 占位符 | 模糊匹配(_匹配单个字符,%匹配任意个字符) |
IS NULL | 是NULL |
逻辑运算符 | 功能 |
---|---|
AND 或 && | 并且(多个条件同时成立) |
OR 或 || | 或者(多个条件任意一个成立) |
NOT 或 ! | 非,不是 |
例子:
1 | -- 年龄等于30 |
常见聚合函数:
函数 | 功能 |
---|---|
count | 统计数量 |
max | 最大值 |
min | 最小值 |
avg | 平均值 |
sum | 求和 |
语法:SELECT 聚合函数(字段列表) FROM 表名;
例:SELECT count(id) from employee where workaddress = "广东省";
语法:SELECT 字段列表 FROM 表名 [ WHERE 条件 ] GROUP BY 分组字段名 [ HAVING 分组后的过滤条件 ];
where 和 having 的区别:
例子:
1 | -- 根据性别分组,统计男性和女性数量(只显示分组数量,不显示哪个是男哪个是女) |
语法:SELECT 字段列表 FROM 表名 ORDER BY 字段1 排序方式1, 字段2 排序方式2;
排序方式:
例子:
1 | -- 根据年龄升序排序 |
如果是多字段排序,当第一个字段值相同时,才会根据第二个字段进行排序
语法:SELECT 字段列表 FROM 表名 LIMIT 起始索引, 查询记录数;
例子:
1 | -- 查询第一页数据,展示10条 |
FROM -> WHERE -> GROUP BY -> SELECT -> ORDER BY -> LIMIT
查询用户:
1 | USE mysql; |
创建用户:CREATE USER '用户名'@'主机名' IDENTIFIED BY '密码';
修改用户密码:ALTER USER '用户名'@'主机名' IDENTIFIED WITH mysql_native_password BY '新密码';
删除用户:DROP USER '用户名'@'主机名';
例子:
1 | -- 创建用户test,只能在当前主机localhost访问 |
常用权限:
权限 | 说明 |
---|---|
ALL, ALL PRIVILEGES | 所有权限 |
SELECT | 查询数据 |
INSERT | 插入数据 |
UPDATE | 修改数据 |
DELETE | 删除数据 |
ALTER | 修改表 |
DROP | 删除数据库/表/视图 |
CREATE | 创建数据库/表 |
更多权限请看权限一览表
查询权限:SHOW GRANTS FOR '用户名'@'主机名';
授予权限:GRANT 权限列表 ON 数据库名.表名 TO '用户名'@'主机名';
撤销权限:REVOKE 权限列表 ON 数据库名.表名 FROM '用户名'@'主机名';
常用函数:
函数 | 功能 |
---|---|
CONCAT(s1, s2, …, sn) | 字符串拼接,将s1, s2, …, sn拼接成一个字符串 |
LOWER(str) | 将字符串全部转为小写 |
UPPER(str) | 将字符串全部转为大写 |
LPAD(str, n, pad) | 左填充,用字符串pad对str的左边进行填充,达到n个字符串长度 |
RPAD(str, n, pad) | 右填充,用字符串pad对str的右边进行填充,达到n个字符串长度 |
TRIM(str) | 去掉字符串头部和尾部的空格 |
SUBSTRING(str, start, len) | 返回从字符串str从start位置起的len个长度的字符串 |
REPLACE(column, source, replace) | 替换字符串 |
使用示例:
1 | -- 拼接 |
常见函数:
函数 | 功能 |
---|---|
CEIL(x) | 向上取整 |
FLOOR(x) | 向下取整 |
MOD(x, y) | 返回x/y的模 |
RAND() | 返回0~1内的随机数 |
ROUND(x, y) | 求参数x的四舍五入值,保留y位小数 |
常用函数:
函数 | 功能 |
---|---|
CURDATE() | 返回当前日期 |
CURTIME() | 返回当前时间 |
NOW() | 返回当前日期和时间 |
YEAR(date) | 获取指定date的年份 |
MONTH(date) | 获取指定date的月份 |
DAY(date) | 获取指定date的日期 |
DATE_ADD(date, INTERVAL expr type) | 返回一个日期/时间值加上一个时间间隔expr后的时间值 |
DATEDIFF(date1, date2) | 返回起始时间date1和结束时间date2之间的天数 |
例子:
1 | -- DATE_ADD |
常用函数:
函数 | 功能 |
---|---|
IF(value, t, f) | 如果value为true,则返回t,否则返回f |
IFNULL(value1, value2) | 如果value1不为空,返回value1,否则返回value2 |
CASE WHEN [ val1 ] THEN [ res1 ] … ELSE [ default ] END | 如果val1为true,返回res1,… 否则返回default默认值 |
CASE [ expr ] WHEN [ val1 ] THEN [ res1 ] … ELSE [ default ] END | 如果expr的值等于val1,返回res1,… 否则返回default默认值 |
例子:
1 | select |
分类:
约束 | 描述 | 关键字 |
---|---|---|
非空约束 | 限制该字段的数据不能为null | NOT NULL |
唯一约束 | 保证该字段的所有数据都是唯一、不重复的 | UNIQUE |
主键约束 | 主键是一行数据的唯一标识,要求非空且唯一 | PRIMARY KEY |
默认约束 | 保存数据时,如果未指定该字段的值,则采用默认值 | DEFAULT |
检查约束(8.0.1版本后) | 保证字段值满足某一个条件 | CHECK |
外键约束 | 用来让两张图的数据之间建立连接,保证数据的一致性和完整性 | FOREIGN KEY |
约束是作用于表中字段上的,可以再创建表/修改表的时候添加约束。
约束条件 | 关键字 |
---|---|
主键 | PRIMARY KEY |
自动增长 | AUTO_INCREMENT |
不为空 | NOT NULL |
唯一 | UNIQUE |
逻辑条件 | CHECK |
默认值 | DEFAULT |
例子:
1 | create table user( |
添加外键:
1 | CREATE TABLE 表名( |
删除外键:ALTER TABLE 表名 DROP FOREIGN KEY 外键名;
行为 | 说明 |
---|---|
NO ACTION | 当在父表中删除/更新对应记录时,首先检查该记录是否有对应外键,如果有则不允许删除/更新(与RESTRICT一致) |
RESTRICT | 当在父表中删除/更新对应记录时,首先检查该记录是否有对应外键,如果有则不允许删除/更新(与NO ACTION一致) |
CASCADE | 当在父表中删除/更新对应记录时,首先检查该记录是否有对应外键,如果有则也删除/更新外键在子表中的记录 |
SET NULL | 当在父表中删除/更新对应记录时,首先检查该记录是否有对应外键,如果有则设置子表中该外键值为null(要求该外键允许为null) |
SET DEFAULT | 父表有变更时,子表将外键设为一个默认值(Innodb不支持) |
更改删除/更新行为:ALTER TABLE 表名 ADD CONSTRAINT 外键名称 FOREIGN KEY (外键字段) REFERENCES 主表名(主表字段名) ON UPDATE 行为 ON DELETE 行为;
案例:部门与员工
关系:一个部门对应多个员工,一个员工对应一个部门
实现:在多的一方建立外键,指向一的一方的主键
案例:学生与课程
关系:一个学生可以选多门课程,一门课程也可以供多个学生选修
实现:建立第三张中间表,中间表至少包含两个外键,分别关联两方主键
案例:用户与用户详情
关系:一对一关系,多用于单表拆分,将一张表的基础字段放在一张表中,其他详情字段放在另一张表中,以提升操作效率
实现:在任意一方加入外键,关联另外一方的主键,并且设置外键为唯一的(UNIQUE)
合并查询(笛卡尔积,会展示所有组合结果):select * from employee, dept;
笛卡尔积:两个集合A集合和B集合的所有组合情况(在多表查询时,需要消除无效的笛卡尔积)
消除无效笛卡尔积:select * from employee, dept where employee.dept = dept.id;
内连接查询的是两张表交集的部分
隐式内连接:SELECT 字段列表 FROM 表1, 表2 WHERE 条件 ...;
显式内连接:SELECT 字段列表 FROM 表1 [ INNER ] JOIN 表2 ON 连接条件 ...;
显式性能比隐式高
例子:
1 | -- 查询员工姓名,及关联的部门的名称 |
左外连接:
查询左表所有数据,以及两张表交集部分数据SELECT 字段列表 FROM 表1 LEFT [ OUTER ] JOIN 表2 ON 条件 ...;
相当于查询表1的所有数据,包含表1和表2交集部分数据
右外连接:
查询右表所有数据,以及两张表交集部分数据SELECT 字段列表 FROM 表1 RIGHT [ OUTER ] JOIN 表2 ON 条件 ...;
例子:
1 | -- 左 |
左连接可以查询到没有dept的employee,右连接可以查询到没有employee的dept
当前表与自身的连接查询,自连接必须使用表别名
语法:SELECT 字段列表 FROM 表A 别名A JOIN 表A 别名B ON 条件 ...;
自连接查询,可以是内连接查询,也可以是外连接查询
例子:
1 | -- 查询员工及其所属领导的名字 |
把多次查询的结果合并,形成一个新的查询集
语法:
1 | SELECT 字段列表 FROM 表A ... |
SQL语句中嵌套SELECT语句,称谓嵌套查询,又称子查询。SELECT * FROM t1 WHERE column1 = ( SELECT column1 FROM t2);
子查询外部的语句可以是 INSERT / UPDATE / DELETE / SELECT 的任何一个
根据子查询结果可以分为:
根据子查询位置可分为:
子查询返回的结果是单个值(数字、字符串、日期等)。
常用操作符:- < > > >= < <=
例子:
1 | -- 查询销售部所有员工 |
返回的结果是一列(可以是多行)。
常用操作符:
操作符 | 描述 |
---|---|
IN | 在指定的集合范围内,多选一 |
NOT IN | 不在指定的集合范围内 |
ANY | 子查询返回列表中,有任意一个满足即可 |
SOME | 与ANY等同,使用SOME的地方都可以使用ANY |
ALL | 子查询返回列表的所有值都必须满足 |
例子:
1 | -- 查询销售部和市场部的所有员工信息 |
返回的结果是一行(可以是多列)。
常用操作符:=, <, >, IN, NOT IN
例子:
1 | -- 查询与xxx的薪资及直属领导相同的员工信息 |
返回的结果是多行多列
常用操作符:IN
例子:
1 | -- 查询与xxx1,xxx2的职位和薪资相同的员工 |
事务是一组操作的集合,事务会把所有操作作为一个整体一起向系统提交或撤销操作请求,即这些操作要么同时成功,要么同时失败。
基本操作:
1 | -- 1. 查询张三账户余额 |
操作方式二:
开启事务:START TRANSACTION 或 BEGIN TRANSACTION;
提交事务:COMMIT;
回滚事务:ROLLBACK;
操作实例:
1 | start transaction; |
问题 | 描述 |
---|---|
脏读 | 一个事务读到另一个事务还没提交的数据 |
不可重复读 | 一个事务先后读取同一条记录,但两次读取的数据不同 |
幻读 | 一个事务按照条件查询数据时,没有对应的数据行,但是再插入数据时,又发现这行数据已经存在 |
这三个问题的详细演示:https://www.bilibili.com/video/BV1Kr4y1i7ru?p=55cd
并发事务隔离级别:
隔离级别 | 脏读 | 不可重复读 | 幻读 |
---|---|---|---|
Read uncommitted | √ | √ | √ |
Read committed | × | √ | √ |
Repeatable Read(默认) | × | × | √ |
Serializable | × | × | × |
查看事务隔离级别:SELECT @@TRANSACTION_ISOLATION;
设置事务隔离级别:SET [ SESSION | GLOBAL ] TRANSACTION ISOLATION LEVEL {READ UNCOMMITTED | READ COMMITTED | REPEATABLE READ | SERIALIZABLE };
SESSION 是会话级别,表示只针对当前会话有效,GLOBAL 表示对所有会话有效
MySQL体系结构:
存储引擎就是存储数据、建立索引、更新/查询数据等技术的实现方式。存储引擎是基于表而不是基于库的,所以存储引擎也可以被称为表引擎。
默认存储引擎是InnoDB。
相关操作:
1 | -- 查询建表语句 |
InnoDB 是一种兼顾高可靠性和高性能的通用存储引擎,在 MySQL 5.5 之后,InnoDB 是默认的 MySQL 引擎。
特点:
文件:
参数:innodb_file_per_table,决定多张表共享一个表空间还是每张表对应一个表空间
知识点:
查看 Mysql 变量:show variables like 'innodb_file_per_table';
从idb文件提取表结构数据:
(在cmd运行)ibd2sdi xxx.ibd
InnoDB 逻辑存储结构:
MyISAM 是 MySQL 早期的默认存储引擎。
特点:
文件:
Memory 引擎的表数据是存储在内存中的,受硬件问题、断电问题的影响,只能将这些表作为临时表或缓存使用。
特点:
文件:
特点 | InnoDB | MyISAM | Memory |
---|---|---|---|
存储限制 | 64TB | 有 | 有 |
事务安全 | 支持 | - | - |
锁机制 | 行锁 | 表锁 | 表锁 |
B+tree索引 | 支持 | 支持 | 支持 |
Hash索引 | - | - | 支持 |
全文索引 | 支持(5.6版本之后) | 支持 | - |
空间使用 | 高 | 低 | N/A |
内存使用 | 高 | 低 | 中等 |
批量插入速度 | 低 | 高 | 高 |
支持外键 | 支持 | - | - |
在选择存储引擎时,应该根据应用系统的特点选择合适的存储引擎。对于复杂的应用系统,还可以根据实际情况选择多种存储引擎进行组合。
电商中的足迹和评论适合使用 MyISAM 引擎,缓存适合使用 Memory 引擎。
查看当前数据库的 INSERT, UPDATE, DELETE, SELECT 访问频次:SHOW GLOBAL STATUS LIKE 'Com_______';
或者 SHOW SESSION STATUS LIKE 'Com_______';
例:show global status like 'Com_______'
慢查询日志记录了所有执行时间超过指定参数(long_query_time,单位:秒,默认10秒)的所有SQL语句的日志。
MySQL的慢查询日志默认没有开启,需要在MySQL的配置文件(/etc/my.cnf)中配置如下信息:
# 开启慢查询日志开关
slow_query_log=1
# 设置慢查询日志的时间为2秒,SQL语句执行时间超过2秒,就会视为慢查询,记录慢查询日志
long_query_time=2
更改后记得重启MySQL服务,日志文件位置:/var/lib/mysql/localhost-slow.log
查看慢查询日志开关状态:show variables like 'slow_query_log';
show profile 能在做SQL优化时帮我们了解时间都耗费在哪里。通过 have_profiling 参数,能看到当前 MySQL 是否支持 profile 操作:SELECT @@have_profiling;
profiling 默认关闭,可以通过set语句在session/global级别开启 profiling:SET profiling = 1;
查看所有语句的耗时:show profiles;
查看指定query_id的SQL语句各个阶段的耗时:show profile for query query_id;
查看指定query_id的SQL语句CPU的使用情况show profile cpu for query query_id;
EXPLAIN 或者 DESC 命令获取 MySQL 如何执行 SELECT 语句的信息,包括在 SELECT 语句执行过程中表如何连接和连接的顺序。
语法:
# 直接在select语句之前加上关键字 explain / desc
EXPLAIN SELECT 字段列表 FROM 表名 HWERE 条件;
EXPLAIN 各字段含义:
索引是帮助 MySQL 高效获取数据的数据结构(有序)。在数据之外,数据库系统还维护着满足特定查找算法的数据结构,这些数据结构以某种方式引用(指向)数据,这样就可以在这些数据结构上实现高级查询算法,这种数据结构就是索引。
优缺点:
优点:
缺点:
索引结构 | 描述 |
---|---|
B+Tree | 最常见的索引类型,大部分引擎都支持B+树索引 |
Hash | 底层数据结构是用哈希表实现,只有精确匹配索引列的查询才有效,不支持范围查询 |
R-Tree(空间索引) | 空间索引是 MyISAM 引擎的一个特殊索引类型,主要用于地理空间数据类型,通常使用较少 |
Full-Text(全文索引) | 是一种通过建立倒排索引,快速匹配文档的方式,类似于 Lucene, Solr, ES |
索引 | InnoDB | MyISAM | Memory |
---|---|---|---|
B+Tree索引 | 支持 | 支持 | 支持 |
Hash索引 | 不支持 | 不支持 | 支持 |
R-Tree索引 | 不支持 | 支持 | 不支持 |
Full-text | 5.6版本后支持 | 支持 | 不支持 |
二叉树的缺点可以用红黑树来解决:
红黑树也存在大数据量情况下,层级较深,检索速度慢的问题。
为了解决上述问题,可以使用 B-Tree 结构。
B-Tree (多路平衡查找树) 以一棵最大度数(max-degree,指一个节点的子节点个数)为5(5阶)的 b-tree 为例(每个节点最多存储4个key,5个指针)
B-Tree 的数据插入过程动画参照:https://www.bilibili.com/video/BV1Kr4y1i7ru?p=68
演示地址:https://www.cs.usfca.edu/~galles/visualization/BTree.html
结构图:
演示地址:https://www.cs.usfca.edu/~galles/visualization/BPlusTree.html
与 B-Tree 的区别:
MySQL 索引数据结构对经典的 B+Tree 进行了优化。在原 B+Tree 的基础上,增加一个指向相邻叶子节点的链表指针,就形成了带有顺序指针的 B+Tree,提高区间访问的性能。
哈希索引就是采用一定的hash算法,将键值换算成新的hash值,映射到对应的槽位上,然后存储在hash表中。
如果两个(或多个)键值,映射到一个相同的槽位上,他们就产生了hash冲突(也称为hash碰撞),可以通过链表来解决。
特点:
存储引擎支持:
分类 | 含义 | 特点 | 关键字 |
---|---|---|---|
主键索引 | 针对于表中主键创建的索引 | 默认自动创建,只能有一个 | PRIMARY |
唯一索引 | 避免同一个表中某数据列中的值重复 | 可以有多个 | UNIQUE |
常规索引 | 快速定位特定数据 | 可以有多个 | |
全文索引 | 全文索引查找的是文本中的关键词,而不是比较索引中的值 | 可以有多个 | FULLTEXT |
在 InnoDB 存储引擎中,根据索引的存储形式,又可以分为以下两种:
分类 | 含义 | 特点 |
---|---|---|
聚集索引(Clustered Index) | 将数据存储与索引放一块,索引结构的叶子节点保存了行数据 | 必须有,而且只有一个 |
二级索引(Secondary Index) | 将数据与索引分开存储,索引结构的叶子节点关联的是对应的主键 | 可以存在多个 |
演示图:
聚集索引选取规则:
1. 以下 SQL 语句,哪个执行效率高?为什么?
1 | select * from user where id = 10; |
答:第一条语句,因为第二条需要回表查询,相当于两个步骤。
2. InnoDB 主键索引的 B+Tree 高度为多少?
答:假设一行数据大小为1k,一页中可以存储16行这样的数据。InnoDB 的指针占用6个字节的空间,主键假设为bigint,占用字节数为8.
可得公式:n * 8 + (n + 1) * 6 = 16 * 1024
,其中 8 表示 bigint 占用的字节数,n 表示当前节点存储的key的数量,(n + 1) 表示指针数量(比key多一个)。算出n约为1170。
如果树的高度为2,那么他能存储的数据量大概为:1171 * 16 = 18736
;
如果树的高度为3,那么他能存储的数据量大概为:1171 * 1171 * 16 = 21939856
。
另外,如果有成千上万的数据,那么就要考虑分表,涉及运维篇知识。
创建索引:CREATE [ UNIQUE | FULLTEXT ] INDEX index_name ON table_name (index_col_name, ...);
如果不加 CREATE 后面不加索引类型参数,则创建的是常规索引
查看索引:SHOW INDEX FROM table_name;
删除索引:DROP INDEX index_name ON table_name;
案例:
1 | -- name字段为姓名字段,该字段的值可能会重复,为该字段创建索引 |
如果索引关联了多列(联合索引),要遵守最左前缀法则,最左前缀法则指的是查询从索引的最左列开始,并且不跳过索引中的列。
如果跳跃某一列,索引将部分失效(后面的字段索引失效)。
联合索引中,出现范围查询(<, >),范围查询右侧的列索引失效。可以用>=或者<=来规避索引失效问题。
explain select * from tb_user where substring(phone, 10, 2) = '15';
explain select * from tb_user where phone = 17799990015;
,此处phone的值没有加引号explain select * from tb_user where profession like '%工程';
,前后都有 % 也会失效。是优化数据库的一个重要手段,简单来说,就是在SQL语句中加入一些人为的提示来达到优化操作的目的。
例如,使用索引:explain select * from tb_user use index(idx_user_pro) where profession="软件工程";
不使用哪个索引:explain select * from tb_user ignore index(idx_user_pro) where profession="软件工程";
必须使用哪个索引:explain select * from tb_user force index(idx_user_pro) where profession="软件工程";
use 是建议,实际使用哪个索引 MySQL 还会自己权衡运行速度去更改,force就是无论如何都强制使用该索引。
尽量使用覆盖索引(查询使用了索引,并且需要返回的列,在该索引中已经全部能找到),减少 select *。
explain 中 extra 字段含义:using index condition
:查找使用了索引,但是需要回表查询数据using where; using index;
:查找使用了索引,但是需要的数据都在索引列中能找到,所以不需要回表查询
如果在聚集索引中直接能找到对应的行,则直接返回行数据,只需要一次查询,哪怕是select *;如果在辅助索引中找聚集索引,如select id, name from xxx where name='xxx';
,也只需要通过辅助索引(name)查找到对应的id,返回name和name索引对应的id即可,只需要一次查询;如果是通过辅助索引查找其他字段,则需要回表查询,如select id, name, gender from xxx where name='xxx';
所以尽量不要用select *
,容易出现回表查询,降低效率,除非有联合索引包含了所有字段
面试题:一张表,有四个字段(id, username, password, status),由于数据量大,需要对以下SQL语句进行优化,该如何进行才是最优方案:select id, username, password from tb_user where username='itcast';
解:给username和password字段建立联合索引,则不需要回表查询,直接覆盖索引
当字段类型为字符串(varchar, text等)时,有时候需要索引很长的字符串,这会让索引变得很大,查询时,浪费大量的磁盘IO,影响查询效率,此时可以只降字符串的一部分前缀,建立索引,这样可以大大节约索引空间,从而提高索引效率。
语法:create index idx_xxxx on table_name(columnn(n));
前缀长度:可以根据索引的选择性来决定,而选择性是指不重复的索引值(基数)和数据表的记录总数的比值,索引选择性越高则查询效率越高,唯一索引的选择性是1,这是最好的索引选择性,性能也是最好的。
求选择性公式:
1 | select count(distinct email) / count(*) from tb_user; |
show index 里面的sub_part可以看到接取的长度
单列索引:即一个索引只包含单个列
联合索引:即一个索引包含了多个列
在业务场景中,如果存在多个查询条件,考虑针对于查询字段建立索引时,建议建立联合索引,而非单列索引。
单列索引情况:explain select id, phone, name from tb_user where phone = '17799990010' and name = '韩信';
这句只会用到phone索引字段
普通插入:
大批量插入:
如果一次性需要插入大批量数据,使用insert语句插入性能较低,此时可以使用MySQL数据库提供的load指令插入。
1 | # 客户端连接服务端时,加上参数 --local-infile(这一行在bash/cmd界面输入) |
数据组织方式:在InnoDB存储引擎中,表数据都是根据主键顺序组织存放的,这种存储方式的表称为索引组织表(Index organized table, IOT)
页分裂:页可以为空,也可以填充一般,也可以填充100%,每个页包含了2-N行数据(如果一行数据过大,会行溢出),根据主键排列。
页合并:当删除一行记录时,实际上记录并没有被物理删除,只是记录被标记(flaged)为删除并且它的空间变得允许被其他记录声明使用。当页中删除的记录到达 MERGE_THRESHOLD(默认为页的50%),InnoDB会开始寻找最靠近的页(前后)看看是否可以将这两个页合并以优化空间使用。
MERGE_THRESHOLD:合并页的阈值,可以自己设置,在创建表或创建索引时指定
文字说明不够清晰明了,具体可以看视频里的PPT演示过程:https://www.bilibili.com/video/BV1Kr4y1i7ru?p=90
主键设计原则:
如果order by字段全部使用升序排序或者降序排序,则都会走索引,但是如果一个字段升序排序,另一个字段降序排序,则不会走索引,explain的extra信息显示的是Using index, Using filesort
,如果要优化掉Using filesort,则需要另外再创建一个索引,如:create index idx_user_age_phone_ad on tb_user(age asc, phone desc);
,此时使用select id, age, phone from tb_user order by age asc, phone desc;
会全部走索引
总结:
如索引为idx_user_pro_age_stat
,则句式可以是select ... where profession order by age
,这样也符合最左前缀法则
常见的问题如limit 2000000, 10
,此时需要 MySQL 排序前2000000条记录,但仅仅返回2000000 - 2000010的记录,其他记录丢弃,查询排序的代价非常大。
优化方案:一般分页查询时,通过创建覆盖索引能够比较好地提高性能,可以通过覆盖索引加子查询形式进行优化
例如:
1 | -- 此语句耗时很长 |
MyISAM 引擎把一个表的总行数存在了磁盘上,因此执行 count(*) 的时候会直接返回这个数,效率很高(前提是不适用where);
InnoDB 在执行 count(*) 时,需要把数据一行一行地从引擎里面读出来,然后累计计数。
优化方案:自己计数,如创建key-value表存储在内存或硬盘,或者是用redis
count的几种用法:
各种用法的性能:
按效率排序:count(字段) < count(主键) < count(1) < count(*),所以尽量使用 count(*)
InnoDB 的行锁是针对索引加的锁,不是针对记录加的锁,并且该索引不能失效,否则会从行锁升级为表锁。
如以下两条语句:update student set no = '123' where id = 1;
,这句由于id有主键索引,所以只会锁这一行;update student set no = '123' where name = 'test';
,这句由于name没有索引,所以会把整张表都锁住进行数据更新,解决方法是给name字段添加索引
类型名称 | 取值范围 | 大小 |
---|---|---|
TINYINT | -128〜127 | 1个字节 |
SMALLINT | -32768〜32767 | 2个宇节 |
MEDIUMINT | -8388608〜8388607 | 3个字节 |
INT (INTEGHR) | -2147483648〜2147483647 | 4个字节 |
BIGINT | -9223372036854775808〜9223372036854775807 | 8个字节 |
无符号在数据类型后加 unsigned 关键字。
类型名称 | 说明 | 存储需求 |
---|---|---|
FLOAT | 单精度浮点数 | 4 个字节 |
DOUBLE | 双精度浮点数 | 8 个字节 |
DECIMAL (M, D),DEC | 压缩的“严格”定点数 | M+2 个字节 |
类型名称 | 日期格式 | 日期范围 | 存储需求 |
---|---|---|---|
YEAR | YYYY | 1901 ~ 2155 | 1 个字节 |
TIME | HH:MM:SS | -838:59:59 ~ 838:59:59 | 3 个字节 |
DATE | YYYY-MM-DD | 1000-01-01 ~ 9999-12-3 | 3 个字节 |
DATETIME | YYYY-MM-DD HH:MM:SS | 1000-01-01 00:00:00 ~ 9999-12-31 23:59:59 | 8 个字节 |
TIMESTAMP | YYYY-MM-DD HH:MM:SS | 1980-01-01 00:00:01 UTC ~ 2040-01-19 03:14:07 UTC | 4 个字节 |
类型名称 | 说明 | 存储需求 |
---|---|---|
CHAR(M) | 固定长度非二进制字符串 | M 字节,1<=M<=255 |
VARCHAR(M) | 变长非二进制字符串 | L+1字节,在此,L< = M和 1<=M<=255 |
TINYTEXT | 非常小的非二进制字符串 | L+1字节,在此,L<2^8 |
TEXT | 小的非二进制字符串 | L+2字节,在此,L<2^16 |
MEDIUMTEXT | 中等大小的非二进制字符串 | L+3字节,在此,L<2^24 |
LONGTEXT | 大的非二进制字符串 | L+4字节,在此,L<2^32 |
ENUM | 枚举类型,只能有一个枚举字符串值 | 1或2个字节,取决于枚举值的数目 (最大值为65535) |
SET | 一个设置,字符串对象可以有零个或 多个SET成员 | 1、2、3、4或8个字节,取决于集合 成员的数量(最多64个成员) |
类型名称 | 说明 | 存储需求 |
---|---|---|
BIT(M) | 位字段类型 | 大约 (M+7)/8 字节 |
BINARY(M) | 固定长度二进制字符串 | M 字节 |
VARBINARY (M) | 可变长度二进制字符串 | M+1 字节 |
TINYBLOB (M) | 非常小的BLOB | L+1 字节,在此,L<2^8 |
BLOB (M) | 小 BLOB | L+2 字节,在此,L<2^16 |
MEDIUMBLOB (M) | 中等大小的BLOB | L+3 字节,在此,L<2^24 |
LONGBLOB (M) | 非常大的BLOB | L+4 字节,在此,L<2^32 |
具体权限的作用详见官方文档
GRANT 和 REVOKE 允许的静态权限
Privilege | Grant Table Column | Context |
---|---|---|
ALL [PRIVILEGES] | Synonym for “all privileges” | Server administration |
ALTER | Alter_priv | Tables |
ALTER ROUTINE | Alter_routine_priv | Stored routines |
CREATE | Create_priv | Databases, tables, or indexes |
CREATE ROLE | Create_role_priv | Server administration |
CREATE ROUTINE | Create_routine_priv | Stored routines |
CREATE TABLESPACE | Create_tablespace_priv | Server administration |
CREATE TEMPORARY TABLES | Create_tmp_table_priv | Tables |
CREATE USER | Create_user_priv | Server administration |
CREATE VIEW | Create_view_priv | Views |
DELETE | Delete_priv | Tables |
DROP | Drop_priv | Databases, tables, or views |
DROP ROLE | Drop_role_priv | Server administration |
EVENT | Event_priv | Databases |
EXECUTE | Execute_priv | Stored routines |
FILE | File_priv | File access on server host |
GRANT OPTION | Grant_priv | Databases, tables, or stored routines |
INDEX | Index_priv | Tables |
INSERT | Insert_priv | Tables or columns |
LOCK TABLES | Lock_tables_priv | Databases |
PROCESS | Process_priv | Server administration |
PROXY | See proxies_priv table | Server administration |
REFERENCES | References_priv | Databases or tables |
RELOAD | Reload_priv | Server administration |
REPLICATION CLIENT | Repl_client_priv | Server administration |
REPLICATION SLAVE | Repl_slave_priv | Server administration |
SELECT | Select_priv | Tables or columns |
SHOW DATABASES | Show_db_priv | Server administration |
SHOW VIEW | Show_view_priv | Views |
SHUTDOWN | Shutdown_priv | Server administration |
SUPER | Super_priv | Server administration |
TRIGGER | Trigger_priv | Tables |
UPDATE | Update_priv | Tables or columns |
USAGE | Synonym for “no privileges” | Server administration |
GRANT 和 REVOKE 允许的动态权限
Privilege | Context |
---|---|
APPLICATION_PASSWORD_ADMIN | Dual password administration |
AUDIT_ABORT_EXEMPT | Allow queries blocked by audit log filter |
AUDIT_ADMIN | Audit log administration |
AUTHENTICATION_POLICY_ADMIN | Authentication administration |
BACKUP_ADMIN | Backup administration |
BINLOG_ADMIN | Backup and Replication administration |
BINLOG_ENCRYPTION_ADMIN | Backup and Replication administration |
CLONE_ADMIN | Clone administration |
CONNECTION_ADMIN | Server administration |
ENCRYPTION_KEY_ADMIN | Server administration |
FIREWALL_ADMIN | Firewall administration |
FIREWALL_EXEMPT | Firewall administration |
FIREWALL_USER | Firewall administration |
FLUSH_OPTIMIZER_COSTS | Server administration |
FLUSH_STATUS | Server administration |
FLUSH_TABLES | Server administration |
FLUSH_USER_RESOURCES | Server administration |
GROUP_REPLICATION_ADMIN | Replication administration |
GROUP_REPLICATION_STREAM | Replication administration |
INNODB_REDO_LOG_ARCHIVE | Redo log archiving administration |
NDB_STORED_USER | NDB Cluster |
PASSWORDLESS_USER_ADMIN | Authentication administration |
PERSIST_RO_VARIABLES_ADMIN | Server administration |
REPLICATION_APPLIER | PRIVILEGE_CHECKS_USER for a replication channel |
REPLICATION_SLAVE_ADMIN | Replication administration |
RESOURCE_GROUP_ADMIN | Resource group administration |
RESOURCE_GROUP_USER | Resource group administration |
ROLE_ADMIN | Server administration |
SESSION_VARIABLES_ADMIN | Server administration |
SET_USER_ID | Server administration |
SHOW_ROUTINE | Server administration |
SYSTEM_USER | Server administration |
SYSTEM_VARIABLES_ADMIN | Server administration |
TABLE_ENCRYPTION_ADMIN | Server administration |
VERSION_TOKEN_ADMIN | Server administration |
XA_RECOVER_ADMIN | Server administration |
\G
会将结果的表格形式转换成行文本形式1 | SELECT table_schema "Database Name" |
后续内容因为跟当前学习、工作计划有冲突,所以后续课程的学习计划会无限期推后。
目前的工作重点放在重做一个学习笔记网站,当然这是边做边学的,开发过程中遇到的难点和知识点我也会记录下来供大家学习。
在此感谢B站同样爱学习的同学 @守心-人 提供的后续课程笔记,大家有条件一定要去给个star,你的每一个star和点赞都是我们前进的动力
https://github.com/Buildings-Lei/mysql_note/blob/main/README.md
These pages are designed to celebrate Wotemo’s birthday, which is on 10.05.
If you visit this website on October 5th, you can enter directly without entering a password.
Or ask Wotemo to get the password.
Hope getting all of your blessings.
By the way, there is a comment function at the bottom of the page.
😘😘😘
]]>随着人工智障,哦不,人工智能的发展,PPT也不用我们做了😁
下面,我将为大家介绍两款AI自动生成PPT的Office插件
(事实上,这两款插件是配合起来使用的)
在ChatPPT官网直接点击下载即可
(记得不要修改安装路径,否则可能会出现插件在office中显示不出来的问题)
新建一个空白文档,你就能在上方看见ChatPPT(包括Motion Go,如果你勾选了Motion Go的话)
在Motion Go官网直接点击下载即可
(记得不要修改安装路径,否则可能会出现插件在office中显示不出来的问题)
新建一个空白文档,你就能在上方看见Motion Go(包括ChatPPT)
Github上有专门的调教方法,如
请你充当一名论文编辑专家,在论文评审的角度去修改论文摘要部分,使其更加流畅,优美。下面是具体要求:
下文是论文的摘要部分,请你修改它:xxxxx
让文心一言给你写一个PPT大纲
我:
你给我写一个人工智能行业分析的ppt大纲
文心一言:
第一页
标题:人工智能行业概述
内容:
人工智能的定义和历史发展
人工智能的技术基础和应用领域
人工智能在当今社会中的重要性和应用价值
第二页
标题:人工智能技术基础
内容:
人工智能中的机器学习、深度学习和自然语言处理等技术
人工智能技术应用的现状和未来的发展趋势
人工智能技术在自动化和智能化方面的应用前景
第三页
标题:人工智能应用领域
内容:
人工智能在工业制造领域的应用
人工智能在智能客服和智能推荐系统中的应用
人工智能在医疗、金融、农业等各个领域的应用
第四页
标题:人工智能产业链分析
内容:
人工智能产业链的构成和各环节发展情况
人工智能产业中的主要企业和产品
人工智能产业发展的趋势和未来展望
第五页
标题:人工智能技术发展与市场趋势
内容:
人工智能技术的发展趋势及主要技术流派
人工智能市场的发展趋势和未来发展方向
人工智能技术在全球范围内的竞争格局和发展态势
第六页
标题:人工智能应用场景和案例分析
内容:
人工智能应用的主要场景及其应用效果
人工智能应用案例的分析和启示
人工智能技术在企业中的应用和推广前景
第七页
标题:人工智能发展面临的挑战和机遇
内容:
人工智能发展面临的挑战和难点
人工智能技术发展所带来的机遇和前景
企业和个人如何把握和利用人工智能技术的发展趋势和应用前景
第八页
标题:结语
内容:
总结人工智能技术的发展趋势和应用前景
对企业和个人如何把握和利用人工智能技术的发展提出建议和展望。
根据你的需求相应的让文心一言生成对应的PPT大纲,然后将这个大纲转述给ChatPPT即可
Motion Go有许多丰富的插件,在ChatPPT生成完PPT后,你可以使用Motion Go进行更精细的调整
]]>两个程序演示如下(仔细看,有区别):
1 |
|
1 | // 创建链表的函数 |
1 | // 输出链表内容的函数 |
1 | // 合并两个链表的函数 |
1 | // 使用插入排序对链表进行升序排序的函数(自己写的) |
1 | // 使用插入排序对链表进行升序排序的函数(ChatGPT写的) |
1 | int main() { |
1 |
|
1 |
|
1 | // 创建链表的函数 |
1 | // 输出链表内容的函数 |
1 | // 使用插入排序对链表进行升序排序的函数 |
1 | // 合并两个已排序链表的函数 |
1 | int main() { |
1 |
|
写这两段代码可不容易(头发没了😭😭😭
]]>一个在3后面插入4,然后删除所有4的程序,哈哈哈
添4删4,4不4有冰
在链表这里卡了老长时间,终于没有Bug了:)
如图
这个程序可以输入一串数字(以-1结尾代表结束),然后在3后面插入4,然后删除所有的4,使用了c++的函数,结构体,指针,链表
用到了单向链表的插入和删除等功能
代码如下:
1 | // 在链表中插入一个节点,节点值为num2+1 |
代码如下:
1 | void del(node* head, int num) |
注意tail=tail->next一定要放在else里面,要不然就会像我一样找了半天Bug
代码如下:
1 | @[TOC](初学链表,尝试插入、删除、循环) |
链表是个好东西~~
]]>一个Python & Pygame开发的贪吃蛇小游戏
由Wotemo自主编写
本文件夹中的SnakeUsers已安装好虚拟环境和Flask
(联机版看,大神无视)
FLASK_APP
环境变量 $env:FLASK_APP = “main.py”(三个完整版代码可以在Github中找到)
1 | """ |
# Written by Tai-Hsuan Ho# Created on 2016/11/25, and developed on Python 3.4## Call: InputBox(rect, **args) to create a input bar editor in region defined by rect.## Keyword arguments include:# font: font of the input text.# text: text initially in the input bar when it is created.# bk_image: background image of the text input bar.# bk_color: background color of the text input bar, ignored when bk_image is specified.# bd_color: border color, no border if this keyword is missing or None.# text_color: color of the input text. White color if this keyword is missing.## Return value:# Return (input text, flag), where flag can be True, False, or None when pressing ENTER, # ESC, or receiving QUIT event.## Comments: # The input bar is transparent if both bk_image and bk_color are not specified or None.# There is a game loop inside this function, and all events will be ignore except for # the key events and QUIT, which will be put back to the event queue and exit the game # loop. #import pygamefrom pygame.locals import *COLOR_WHITE = (255, 255, 255)TEXT_MARGIN = 16FPS = 20ALPHABETS = 'abcdefghijklmnopqrstuvwxyz'OTHER_KEYS = '`1234567890-=[]\;\',./'SHIFT_KEYS = '~!@#$%^&*()_+{}|:"<>?'PRINTABLE = ' ' + ALPHABETS + OTHER_KEYS + SHIFT_KEYSdef _caps_lock(ch): # Convert the input char when Caps Lock is turned on. if ch in ALPHABETS: return chr(ord(ch) - ord('a') + ord('A')) else: return chdef _shift_hold(ch, caps_lock): # Convert the input char when SHIFT key is hold. if ch in OTHER_KEYS: return SHIFT_KEYS[OTHER_KEYS.index(ch)] elif ch in ALPHABETS and not caps_lock: return chr(ord(ch) - ord('a') + ord('A')) else: return chdef _draw_box(surface, bk_image, bk_color, display_backup, bd_color): # Draw background image or fill color to the base surface, and draw the border. (width, height) = surface.get_size() if bk_image: surface.blit(bk_image, (0, 0)) elif bk_color: surface.fill(bk_color) else: surface.blit(display_backup, (0, 0)) if bd_color: pygame.draw.rect(surface, bd_color, surface.get_rect(), 1)def _draw_text(surface, input_chars, font, color, start_index, cursor_index, show_cursor): # Draw the input text, making sure the char at cursor index is shown on the screen. x = 0 pos = [x] for i in range(len(input_chars)): x += font.size(input_chars[i])[0] pos.append(x) # Find the start index, so that the cursor can be seen in the input editor. if start_index >= cursor_index: start_index = max(0, cursor_index - 5) while pos[cursor_index] - pos[start_index] > (surface.get_width() - 2 * TEXT_MARGIN): start_index += 1 # Draw text in the editor. h = font.size('a')[1] y = (surface.get_height() - h) // 2 for i in range(start_index, len(input_chars)): img = font.render(input_chars[i], True, color) x = TEXT_MARGIN + pos[i] - pos[start_index] surface.blit(img, (x, y)) if x + img.get_width() + TEXT_MARGIN > surface.get_width(): break # Draw cursor and return the start index. if show_cursor: x = TEXT_MARGIN + pos[cursor_index] - pos[start_index] pygame.draw.line(surface, color, (x, y), (x, y + h)) return start_indexdef InputBox(rect, **args): # Draw a box for text input. Return (text, True) when ENTER is pressed, (text, False) when ESC pressed, and (text, None) when QUIT # event is received. When both bk_image and bk_color are not specified, the input editor is transparent. try: font = args['font'] except: font = pygame.font.Font(None, 32) try: input_chars = list(args['text']) except: input_chars = [] try: bk_image = args['bk_image'] except: bk_image = None try:bd_color = args['bd_color'] except:bd_color = None try:bk_color = args['bk_color'] except:bk_color = None try:text_color = args['text_color'] except:text_color = COLOR_WHITE # Set repeat key event. pygame.key.set_repeat(500, 50) # Get display background in region of the input box. display = pygame.display.get_surface() display_backup = display.subsurface(rect).copy() # Create surface. surface = pygame.Surface(rect.size) # Get input event and update the input box. n = 0 start_index = 0 cursor_index = len(input_chars) bNeedUpdate = True myClock = pygame.time.Clock() while True: for event in pygame.event.get(): if event.type == QUIT: display.blit(display_backup, rect) pygame.display.update(rect) pygame.event.post(pygame.event.Event(QUIT, {})) return (''.join(input_chars), None) # For key up event, check if enter or escape keys are pressed. elif event.type == KEYUP: if event.key in (K_ESCAPE, K_RETURN): display.blit(display_backup, rect) pygame.display.update(rect) return (''.join(input_chars), event.key is K_RETURN) # For key down event, process backspace, delete, left, right, home, end, and normal key inputs. elif event.type == KEYDOWN: bNeedUpdate = True # Backspace key, deleting the previous char and moving the cursor left. if event.key == K_BACKSPACE: if cursor_index >= 1: del input_chars[cursor_index - 1] cursor_index -= 1 # Delete key, deleting the current char. elif event.key == K_DELETE: if cursor_index < len(input_chars): del input_chars[cursor_index] # Left arrow key, moving cursor index to the previous char. elif event.key == K_LEFT: if cursor_index >= 1: cursor_index -= 1 # Right arrow key, moving cursor index to the next char. elif event.key == K_RIGHT: if cursor_index < len(input_chars): cursor_index += 1 # HOME key, moving cursor index to start of the input chars. elif event.key == K_HOME: cursor_index = 0 # END key, moving cursor index to end of the input chars. elif event.key == K_END: cursor_index = len(input_chars) # Otherwise, add printable key to the input char list. else: try: ch = chr(event.key) if ch in PRINTABLE: shift_hold = (event.mod & KMOD_SHIFT) caps_lock = (event.mod & KMOD_CAPS) if shift_hold: ch = _shift_hold(ch, caps_lock) elif caps_lock: ch = _caps_lock(ch) input_chars.insert(cursor_index, ch) cursor_index += 1 except: pass # Update the display for every 0.5 second or when key down event is received. if bNeedUpdate or (n == 0) or (n == FPS // 2): _draw_box(surface, bk_image, bk_color, display_backup, bd_color) show_cursor = bNeedUpdate or (n == 0) start_index = _draw_text(surface, input_chars, font, text_color, start_index, cursor_index, show_cursor) display.blit(surface, rect) pygame.display.update(rect) bNeedUpdate = False n = (n + 1) % FPS myClock.tick(FPS)# Test codes.def main(): rect = pygame.Rect(200, 250, 200, 40) name_input = InputBox(rect, text = '', bd_color = (66, 133, 244), bk_color = (229, 231, 206), text_color = (0, 0, 0)) print(f'你好:{name_input}') return name_input
]]>历经几个周末的时间,我终于将这款用户注册与登录系统做出来啦~撒花✿✿ヽ(°▽°)ノ✿
1 | """用户选择登录或注册,这是主代码,在这里运行程序""" |
1 | """用户登录""" |
1 | """用户注册""" |
1 | """验证码的发送与验证""" |
1.用户注册展示
2.用户登录展示
3.邮箱验证码展示
本代码由沃特陌(Wotemo)自主编写,如有瑕疵可以和我反映哦~
如果有不懂的地方也可以和我交流哟(^U^)ノ~YO
1 | print('Hello World!') |