如果因为网络原因或其他原因没有回调, 怎么保证支付状态一致?
下面我们从一个实例来看如何运用JWT机制实现认证:
GC,
jvm 中,程序计数器、虚拟机栈、本地方法栈都是随线程而生随线程而灭,栈帧随着方法的进入和退出做入栈和出栈操作,实现了自动的内存清理,因此,我们的内存垃圾回收主要集中于 java 堆和方法区中,在程序运行期间,这部分内存的分配和使用都是动态的.
算法:
1. 标记 -清除算法
2. 复制算法
3. 标记-压缩算法
4. 分代收集算法
JVM GC怎么判断对象可以被回收了?
· 对象没有引用
· 作用域发生未捕获异常
· 程序在作用域正常执行完毕
· 程序执行了System.exit()
· 程序发生意外终止(被杀线程等)
默认的新生代(Young generation)、老年代(Old generation)所占空间比例为 1 : 2 。
线程: 最小处理单元, 共享内存
进程: 可以包含多条线程, 不共享内存
对于mysql数据库来说,索引的使用是很巧妙的。它设置的好可以提高速度,设置的不好不光无法提高速度,还会造成浪费内存空间。在优化方面,我们首先建立索引,要判断是否需要建立。其次使用的时候,要尽可能避免索引与or,where。。。。。。(此处有至少10条)一起使用。
快排,
单例模式: 静态内部类实现线程安全
懒汉式保证线程安全的方式:
1. 静态内部类
public class Singleton {
private static class LazyHolder {
private static final Singleton INSTANCE = new Singleton();
}
private Singleton (){}
public static final Singleton getInstance() {
return LazyHolder.INSTANCE;
}
}
public class Singleton {
2 private static Singleton instance;
3 private Singleton (){
4 }
5 public static Singleton getInstance(){ //对获取实例的方法进行同步
6 if (instance == null){
7 synchronized(Singleton.class){
8 if (instance == null)
9 instance = new Singleton();
10 }
11 }
12 return instance;
13 }
14
15 }
网络上的两个程序通过一个双向的通信连接实现数据的交换,这个连接的一端称为一个socket。
mysql数据库中,常见的引擎有三种,例如,innoDB,myISAM,memory。其中INNODB的特点是可以用于事务,mvcc的行级锁。特点是ACID,使用的索引通常是B+树,B+树作为索引的特点是有序,连接
1,分为三次握手,四次挥手。(详细点,过程,每一次连接的参数,参数表示的意义)。2,在四次挥手中,其实有两次可以合二为一,就形成了三次挥手。3,第四次挥手的意义有两种,一个是避免无效数据,一个是防止发送异常。4,在第四次挥手中用到了定时器,tcp/ip中一共有四种定时器,分别是重传定时器
第一次握手:192.168.1.116发送位码syn=1,随机产生seq number=3626544836的数据包到192.168.1.123,192.168.1.123由SYN=1知道192.168.1.116要求建立联机;
第二次握手:192.168.1.123收到请求后要确认联机信息,向192.168.1.116发送ack number=3626544837,syn=1,ack=1,随机产生seq=1739326486的包;
第三次握手:192.168.1.116收到后检查ack number是否正确,即第一次发送的seq number+1,以及位码ack是否为1,若正确,192.168.1.116会再发送ack number=1739326487,ack=1,192.168.1.123收到后确认seq=seq+1,ack=1则连接建立成功。
四次挥手:
1. 客户端A发送一个FIN,用来关闭客户A到服务器B的数据传送(报文段4)。
2. 服务器B收到这个FIN,它发回一个ACK,确认序号为收到的序号加1(报文段5)。和SYN一样,一个FIN将占用一个序号。
3. 服务器B关闭与客户端A的连接,发送一个FIN给客户端A(报文段6)。
4. 客户端A发回ACK报文确认,并将确认序号设置为收到序号加1(报文段7)。
OSI七层模型与TCP/IP五层模型
TCP/IP五层模型: 应用层, 传输层, 网络层, 数据链路层, 物理层
OSI定义了网络互连的七层框架(物理层、数据链路层、网络层、传输层、会话层、表示层、应用层),即ISO开放互连系统参考模型。
传输层.
TCP与UDP区别总结:
1、TCP面向连接(如打电话要先拨号建立连接);UDP是无连接的,即发送数据之前不需要建立连接
2、TCP提供可靠的服务。也就是说,通过TCP连接传送的数据,无差错,不丢失,不重复,且按序到达;UDP尽最大努力交付,即不保证可靠交付
3、TCP面向字节流,实际上是TCP把数据看成一连串无结构的字节流;UDP是面向报文的
UDP没有拥塞控制,因此网络出现拥塞不会使源主机的发送速率降低(对实时应用很有用,如IP电话,实时视频会议等)
4、每一条TCP连接只能是点到点的;UDP支持一对一,一对多,多对一和多对多的交互通信
5、TCP首部开销20字节;UDP的首部开销小,只有8个字节
6、TCP的逻辑通信信道是全双工的可靠信道,UDP则是不可靠信道
应用层
inner join, left join
用一个常用的“A账户向B账号汇钱”的例子来说明如何通过数据库事务保证数据的准确性和完整性。熟悉关系型数据库事务的都知道从帐号A到帐号B需要6个操作:
1、从A账号中把余额读出来(500)。
2、对A账号做减法操作(500-100)。
3、把结果写回A账号中(400)。
4、从B账号中把余额读出来(500)。
5、对B账号做加法操作(500+100)。
6、把结果写回B账号中(600)。
原子性:
保证1-6所有过程要么都执行,要么都不执行。一旦在执行某一步骤的过程中发生问题,就需要执行回滚操作。 假如执行到第五步的时候,B账户突然不可用(比如被注销),那么之前的所有操作都应该回滚到执行事务之前的状态。
一致性
在转账之前,A和B的账户中共有500+500=1000元钱。在转账之后,A和B的账户中共有400+600=1000元。也就是说,数据的状态在执行该事务操作之后从一个状态改变到了另外一个状态。同时一致性还能保证账户余额不会变成负数等。
隔离性
在A向B转账的整个过程中,只要事务还没有提交(commit),查询A账户和B账户的时候,两个账户里面的钱的数量都不会有变化。
如果在A给B转账的同时,有另外一个事务执行了C给B转账的操作,那么当两个事务都结束的时候,B账户里面的钱应该是A转给B的钱加上C转给B的钱再加上自己原有的钱。
持久性
一旦转账成功(事务提交),两个账户的里面的钱就会真的发生变化(会把数据写入数据库做持久化保存)!
链表就是带着指针的结构体,含数据域和指向下一个节点的地址。
头部没有前驱节点,尾部指向NULL
增删快于数组,遍历慢于数组
已经被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等等
虚拟机栈中引用的对象。
方法区中类静态属性实体引用的对象。
方法区中常量引用的对象。
本地方法栈中JNI引用的对象。
BST存在的主要问题是,数在插入的时候会导致树倾斜,不同的插入顺序会导致树的高度不一样,而树的高度直接的影响了树的查找效率。理想的高度是logN,最坏的情况是所有的节点都在一条斜线上,这样的树的高度为N。
基于BST存在的问题,一种新的树——平衡二叉查找树(Balanced BST)产生了。平衡树在插入和删除的时候,会通过旋转操作将高度保持在logN。其中两款具有代表性的平衡树分别为AVL树和红黑树。AVL树由于实现比较复杂,而且插入和删除性能差,在实际环境下的应用不如红黑树。
ArrayList实现List接口,底层是由数组实现,随机查找速度快0(1),插入和删除因为要移动数组元素所以效率慢。
HashMap实现Map接口。底层是数组加链表实现,线程不安全,允许存储Null键值对。装载因子0.75.
好处: 方法增强
面向切面编程:如声明式事务、日志等功能
AOP原理: 动态代理 1.cglib 2.jdk
区别: jdk实现动态代理的前提必须要有接口, 而cglib不需要接口
如果目标对象没有实现接口, 则默认用cglib
好处: 分层解耦
解释依赖注入。
之前程序员可通过new创建新实例对象,但是Spring可向容器索取使用注解:@Autowired…
如果HashMap到达临界容量需要扩容,两个线程同时进行resize操作,同时开辟两块空间,线程挂起时机不当时,rehash会产生环路。
当然,还会发生,一个线程迭代时,另一个线程做插入删除操作,造成迭代的fast-fail。
根本原因是没有锁机制,一个线程的修改会影响另一个线程的操作。
改用concurrentHashMap
HashTable容器在竞争激烈的并发环境下表现出效率低下的原因,是因为所有访问HashTable的线程都必须竞争同一把锁,那假如容器里有多把锁,每一把锁用于锁容器其中一部分数据,那么当多线程访问容器里不同数据段的数据时,线程间就不会存在锁竞争,从而可以有效的提高并发访问效率,这就是ConcurrentHashMap所使用的锁分段技术,首先将数据分成一段一段的存储,然后给每一段数据配一把锁,当一个线程占用锁访问其中一个段数据的时候,其他段的数据也能被其他线程访问。有些方法需要跨段,比如size()和containsValue(),它们可能需要锁定整个表而而不仅仅是某个段,这需要按顺序锁定所有段,操作完毕后,又按顺序释放所有段的锁。这里“按顺序”是很重要的,否则极有可能出现死锁,在ConcurrentHashMap内部,段数组是final的,并且其成员变量实际上也是final的,但是,仅仅是将数组声明为final的并不保证数组成员也是final的,这需要实现上的保证。这可以确保不会出现死锁,因为获得锁的顺序是固定的。
ConcurrentHashMap是由Segment数组结构和HashEntry数组结构组成。Segment是一种可重入锁ReentrantLock,在ConcurrentHashMap里扮演锁的角色,HashEntry则用于存储键值对数据。一个ConcurrentHashMap里包含一个Segment数组,Segment的结构和HashMap类似,是一种数组和链表结构, 一个Segment里包含一个HashEntry数组,每个HashEntry是一个链表结构的元素, 每个Segment守护者一个HashEntry数组里的元素,当对HashEntry数组的数据进行修改时,必须首先获得它对应的Segment锁。
CAS: concurrent包的一种乐观锁
CAS的语义是“我认为V的值应该为A,如果是,那么将V的值更新为B,否则不修改并告诉V的值实际为多少”,CAS是项乐观锁技术,当多个线程尝试使用CAS同时更新同一个变量时,只有其中一个线程能更新变量的值,而其它线程都失败,失败的线程并不会被挂起,而是被告知这次竞争中失败,并可以再次尝试。CAS有3个操作数,内存值V,旧的预期值A,要修改的新值B。当且仅当预期值A和内存值V相同时,将内存值V修改为B,否则什么都不做
4个字节 32位
DB在执行一条Sql语句的时候,默认的方式是根据搜索条件进行全表扫描,遇到匹配条件的就加入搜索结果集合。如果我们对某一字段增加索引,查询时就会先去索引列表中一次定位到特定值的行数,大大减少遍历匹配的行数,所以能明显增加查询的速度。
a索引 b索引, 只用到了a索引
1.如果条件中有or,即使其中有条件带索引也不会使用(这也是为什么尽量少用or的原因)要想使用or,又想让索引生效,只能将or条件中的每个列都加上索引
2.对于多列索引,不是使用的第一部分,则不会使用索引
where a=3 and c=5… 这种情况下b就是断点,a发挥了效果,c没有效果
3.like查询以%开头
4.如果列类型是字符串,那一定要在条件中将数据使用引号引用起来,否则不使用索引
5.如果mysql估计使用全表扫描要比使用索引快,则不使用索引
因为这样是全模糊查找, 无法使用索引, 所以会扫描全表
索引的最左原则, 因为索引没生效
分类:
newFixedThreadPool: 创建一个指定工作线程数量的线程池。
newCachedThreadPool: 创建一个可缓存的线程池。
newSingleThreadExecutor: 创建一个单线程化的Executor,即只创建唯一的工作者线程来执行任务,如果这个线程异常结束,会有另一个取代它,保证顺序执行
newScheduleThreadPool: 创建一个定长的线程池,而且支持定时的以及周期性的任务执行
参数:
corePoolSize: 核心线程数
maxPoolSize: 最大线程数
keepAliveTime: 非核心线程闲置时的超时时长
allowCoreThreadTimeout: 设置该时长同样会作用于核心线程
queueCapacity: 队列容量
hashset的底层是hashmap实现的
底层实际将将该元素作为key放入HashMap。
HashSet中的Value是一个固定值PRESENT。 所以修改不修改无所谓。
原理:
从上面可以看出,同步代码块是使用monitorenter和monitorexit指令实现的,同步方法(在这看不出来需要看JVM底层实现)依靠的是方法修饰符上的ACC_SYNCHRONIZED实现。
同步代码块:monitorenter指令插入到同步代码块的开始位置,monitorexit指令插入到同步代码块的结束位置,JVM需要保证每一个monitorenter都有一个monitorexit与之相对应。任何对象都有一个monitor与之相关联,当且一个monitor被持有之后,他将处于锁定状态。线程执行到monitorenter指令时,将会尝试获取对象所对应的monitor所有权,即尝试获取对象的锁;
同步方法:synchronized方法则会被翻译成普通的方法调用和返回指令如:invokevirtual、areturn指令,在VM字节码层面并没有任何特别的指令来实现被synchronized修饰的方法,而是在Class文件的方法表中将该方法的access_flags字段中的synchronized标志位置1,表示该方法是同步方法并使用调用该方法的对象或该方法所属的Class在JVM的内部对象表示Klass做为锁对象。
synchronized是Java中的关键字,是一种同步锁。它修饰的对象有以下几种:
1. 修饰一个代码块,被修饰的代码块称为同步语句块,其作用的范围是大括号{}括起来的代码,作用的对象是调用这个代码块的对象;
2. 修饰一个方法,被修饰的方法称为同步方法,其作用的范围是整个方法,作用的对象是调用这个方法的对象;
3. 修改一个静态的方法,其作用的范围是整个静态方法,作用的对象是这个类的所有对象;
4. 修改一个类,其作用的范围是synchronized后面括号括起来的部分,作用主的对象是这个类的所有对象。
采用了分治的策略
线程安全:
就是多线程访问时,采用了加锁机制,当一个线程访问该类的某个数据时,进行保护,其他线程不能进行访问直到该线程读取完,其他线程才可使用。不会出现数据不一致或者数据污染。
线程不安全:
就是不提供数据访问保护,有可能出现多个线程先后更改数据造成所得到的数据是脏数据
根据2^10=1024,所以10个老鼠可以确定1000个瓶子具体哪个瓶子有毒。具体实现跟3个老鼠确定8个瓶子原理一样。
000=0
001=1
010=2
011=3
100=4
101=5
110=6
111=7
一位表示一个老鼠,0-7表示8个瓶子。也就是分别将1、3、5、7号瓶子的药混起来给老鼠1吃,2、3、6、7号瓶子的药混起来给老鼠2吃,4、5、6、7号瓶子的药混起来给老鼠3吃,哪个老鼠死了,相应的位标为1。如老鼠1死了、老鼠2没死、老鼠3死了,那么就是101=5号瓶子有毒。同样道理10个老鼠可以确定1000个瓶子
解答: 因为 它最多搬50根胡萝卜,而每走1米就要吃掉一根萝卜。
那么它第一次搬50根胡萝卜到49米处,然后返回50米处将剩下的50根胡萝卜搬到49米处,这中间去->回->去,一共会吃掉3根胡萝卜;由于一次它最多搬50根胡萝卜,所以只有当剩下的胡萝卜数量小于等于50时,它才不用回去,直接搬到家中。那么我们可以假设 搬了x米后,它不用回返:100-3x <=50 (x为正整数) 解得 x=17所以就可以得到 结果了 100 - 3*17 -(50-17)=16(根)小兔子最多能把16根胡萝卜搬到家里。
在Java中有两种形式可以实现多态。继承和接口。
公平锁/非公平锁
可重入锁: 可重入锁又名递归锁,是指在同一个线程在外层方法获取锁的时候,在进入内层方法会自动获取锁。
独享锁/共享锁
互斥锁/读写锁
乐观锁/悲观锁: 悲观锁适合写操作非常多的场景,乐观锁适合读操作非常多的场景,不加锁会带来大量的性能提升。
分段锁
偏向锁/轻量级锁/重量级锁
自旋锁
Read uncommitted
Read committed
Repeatable read
Serializable 序列化
原子性:
是指事务包含的所有操作要么全部成功,要么全部失败回滚
一致性:
是指事务必须使数据库从一个一致性状态变换到另一个一致性状态,也就是说一个事务执行之前和执行之后都必须处于一致性状态。
隔离性:
是当多个用户并发访问数据库时,比如操作同一张表时,数据库为每一个用户开启的事务,不能被其他事务的操作所干扰,多个并发事务之间要相互隔离。
持久性:
是指一个事务一旦被提交了,那么对数据库中的数据的改变就是永久性的,即便是在数据库系统遇到故障的情况下也不会丢失提交事务的操作。
脏读:
是指在一个事务处理过程里读取了另一个未提交的事务中的数据
不可重复读:
是指在对于数据库中的某个数据,一个事务范围内多次查询却返回了不同的数据值,这是由于在查询间隔,被另一个事务修改并提交了。
幻读:
是事务非独立执行时发生的一种现象。例如事务T1对一个表中所有的行的某个数据项做了从“1”修改为“2”的操作,这时事务T2又对这个表中插入了一行数据项,而这个数据项的数值还是为“1”并且提交给数据库。而操作事务T1的用户如果再查看刚刚修改的数据,会发现还有一行没有修改,其实这行是从事务T2中添加的,就好像产生幻觉一样,这就是发生了幻读。
来配置并查看网络接口的配置情况: ifconfig
查看进程: ps-ef|grep
所有监听端口及对应的进程: netstat -anp
top: 相当于任务管理器
free: 查看内存
tail cat head: 查看日志
Spring框架的七大模块
Spring Context:
构建于Core封装包基础上的 Context封装包,提供了一种框架式的对象访问方法,有些象JNDI注册器。Context封装包的特性得自于Beans封装包,并添加了对国际化(I18N)的支持(例如资源绑定),事件传播,资源装载的方式和Context的透明创建,比如说通过Servlet容器。
Spring DAO:
DAO (Data Access Object)提供了JDBC的抽象层,它可消除冗长的JDBC编码和解析数据库厂商特有的错误代码。 并且,JDBC封装包还提供了一种比编程性更好的声明性事务管理方法,不仅仅是实现了特定接口,而且对所有的POJOs(plain old Java objects)都适用。
Spring ORM:
ORM 封装包提供了常用的“对象/关系”映射APIs的集成层。 其中包括JPA、JDO、Hibernate 和 iBatis 。利用ORM封装包,可以混合使用所有Spring提供的特性进行“对象/关系”映射,如前边提到的简单声明性事务管理。
Spring AOP:
Spring的 AOP 封装包提供了符合AOP Alliance规范的面向方面的编程实现,让你可以定义,例如方法拦截器(method-interceptors)和切点(pointcuts),从逻辑上讲,从而减弱代码的功能耦合,清晰的被分离开。而且,利用source-level的元数据功能,还可以将各种行为信息合并到你的代码中。
Spring Web:
Spring中的 Web 包提供了基础的针对Web开发的集成特性,例如多方文件上传,利用Servlet listeners进行IOC容器初始化和针对Web的ApplicationContext。当与WebWork或Struts一起使用Spring时,这个包使Spring可与其他框架结合。
Spring Web MVC:
Spring中的MVC封装包提供了Web应用的Model-View-Controller(MVC)实现。Spring的MVC框架并不是仅仅提供一种传统的实现,它提供了一种清晰的分离模型,在领域模型代码和Web Form之间。并且,还可以借助Spring框架的其他特性。
两个obj,如果equals()相等,hashCode()一定相等。
两个obj,如果hashCode()相等,equals()不一定相等(Hash散列值有冲突的情况,虽然概率很低)。
但是,对于大型网站存在多个主机站点,往往不会直接返回请求页面,而是重定向。返回的状态码就不是200 OK,而是301,302以3开头的重定向码,浏览器在获取了重定向响应后,在响应报文中Location项找到重定向地址,浏览器重新第一步访问即可。
补充一点的就是,重定向是为了负载均衡或者导入流量,提高SEO排名。利用一个前端服务器接受请求,然后负载到不同的主机上,可以大大提高站点的业务并发处理能力;重定向也可将多个域名的访问,集中到一个站点;由于baidu.com,www.baidu.com会被搜索引擎认为是两个网站,照成每个的链接数都会减少从而降低排名,永久重定向会将两个地址关联起来,搜索引擎会认为是同一个网站,从而提高排名。
常用的摘要算法有MD5,SHA1。摘要算法是一个不可逆过程,就是无论多大数据,经过算法运算后都是生成固定长度的数据,一般结果使用16进制进行显示。
MD5和SHA1的区别:MD5结果是128位摘要,SHa1是160位摘要。那么MD5的速度更快,而SHA1的强度更高。
常用的对称加密算法有:AES和DES.
非对称加密(RSA)
两者最大的差别就是是否支持事务
MyISAM:如果执行大量的SELECT,MyISAM是更好的选择。(因为没有支持行级锁),在增删的时候需要锁定整个表格,效率会低一些。相关的是innodb支持行级锁,删除插入的时候只需要锁定改行就行,效率较高
InnoDB:如果你的数据执行大量的INSERT或UPDATE,出于性能方面的考虑,应该使用InnoDB表。DELETE 从性能上InnoDB更优,但DELETE FROM table时,InnoDB不会重新建立表,而是一行一行的删除,在innodb上如果要清空保存有大量数据的表,最好使用truncate table这个命令。
h&(length-1)取模得出的index分布均匀并且碰撞几率低
所以说,当数组长度为2的n次幂的时候,不同的key算得得index相同的几率较小,那么数据在数组上分布就比较均匀,也就是说碰撞的几率小,相对的,查询的时候就不用遍历某个位置上的链表,这样查询效率也就较高了。
@Resource默认是按照名称来装配注入的,只有当找不到与名称匹配的bean才会按照类型来装配注入;
@Autowired默认是按照类型装配注入的,如果想按照名称来转配注入,则需要结合@Qualifier一起使用;
@Resource注解是又J2EE提供,而@Autowired是由Spring提供,故减少系统对spring的依赖建议使用
目的是为了异步处理, 能够实现异步解耦
例子: app的消息推送, 将信息放到mq中, 线程去拿; 注册邮件通知
使用场景的话,举个例子:
假设用户在你的软件中注册,服务端收到用户的注册请求后,它会做这些操作:
校验用户名等信息,如果没问题会在数据库中添加一个用户记录
如果是用邮箱注册会给你发送一封注册成功的邮件,手机注册则会发送一条短信
分析用户的个人信息,以便将来向他推荐一些志同道合的人,或向那些人推荐他
发送给用户一个包含操作指南的系统通知
等等……
但是对于用户来说,注册功能实际只需要第一步,只要服务端将他的账户信息存到数据库中他便可以登录上去做他想做的事情了。至于其他的事情,非要在这一次请求中全部完成么?值得用户浪费时间等你处理这些对他来说无关紧要的事情么?所以实际当第一步做完后,服务端就可以把其他的操作放入对应的消息队列中然后马上返回用户结果,由消息队列异步的进行这些操作。
我们知道,mysql是持久化存储,存放在磁盘里面,检索的话,会涉及到一定的IO,为了解决这个瓶颈,于是出现了缓存,比如现在用的最多的 memcached(简称mc)。首先,用户访问mc,如果未命中,就去访问mysql,之后像内存和硬盘一样,把数据复制到mc一部分。
redis和mc都是缓存,并且都是驻留在内存中运行的,这大大提升了高数据量web访问的访问速度。然而mc只是提供了简单的数据结构,比如 string存储;redis却提供了大量的数据结构,比如string、list、set、hashset、sorted set这些,这使得用户方便了好多,毕竟封装了一层实用的功能,同时实现了同样的效果,当然用redis而慢慢舍弃mc。
内存和硬盘的关系,硬盘放置主体数据用于持久化存储,而内存则是当前运行的那部分数据,CPU访问内存而不是磁盘,这大大提升了运行的速度,当然这是基于程序的局部化访问原理。
推理到redis+mysql,它是内存+磁盘关系的一个映射,mysql放在磁盘,redis放在内存,这样的话,web应用每次只访问redis,如果没有找到的数据,才去访问Mysql。
缓存服务, 处理高并发场景; 减少对数据库的访问
加入红黑树
比方说恶意的程序,如果它知道我们用的是哈希算法,它可能会发送大量的请求,导致产生严重的哈希碰撞。然后不停的访问这些 key就能显著的影响服务器的性能,这样就形成了一次拒绝服务攻击(DoS)。JDK 8中从O(n)到O(logn)的飞跃,可以有效地防止类似的攻击,同时也让HashMap性能的可预测性稍微增强了一些。
长连接: 长连接的话,那么这么多次HTTP请求(这些请求包括请求网页内容,CSS文件,JS文件,图片等等),其实使用的都是一个TCP连接,很显然是可以节省很多消耗的。
长短轮询: 对于客户端来说,不管是长轮询还是短轮询,客户端的动作都是一样的,就是不停的去请求,不同的是服务端,短轮询情况下服务端每次请求不管有没有变化都会立即返回结果,而长轮询情况下,如果有变化才会立即返回结果,而没有变化的话,则不会再立即给客户端返回结果,直到超时为止。
第一个区别是决定的方式,一个TCP连接是否为长连接,是通过设置HTTP的Connection Header来决定的,而且是需要两边都设置才有效。而一种轮询方式是否为长轮询,是根据服务端的处理方式来决定的,与客户端没有关系。
第二个区别就是实现的方式,连接的长短是通过协议来规定和实现的。而轮询的长短,是服务器通过编程的方式手动挂起请求来实现的。
java是一门纯粹的面向对象的语言。面向对象这种程序设计模式它将现实世界中的一切事物都看作是对象,例如,一个人是一个对象,汽车、飞机、小鸟等等,都是对象;它强调从对象出发,以对象为中心用人类的思维方式来认识和思考问题。每个对象都具有各自的状态特征(也可以称为属性)及行为特征(方法),java就是通过对象之间行为的交互来解决问题的。
类是面向对象中一个重要的概念。类是具有相同属性和行为特征的对象的抽象,类是对象的概念模型,对象是类的一个实例,通过类来创建对象,同一类的所有对象具有相同的属性和行为特征。类具有三个基本特征:封装、继承、多态。
封装就是将对象的属性和行为特征包装到一个程序单元(即类)中,把实现细节隐藏起来,通过公用的方法来展现类对外提供的功能,提高了类的内聚性,降低了对象之间的耦合性。
继承是对原有类的拓展,举例说明:我现在有一个Person类,但是我想要一个学生对象,他拥有Person类的所有属性和方法,此外他还有学号属性,及上课、写作业等一些方法,我可以创建一个Student类,但是我不想重复写Person类中已经有了的属性和方法,那么,此时我就可以用Student类继承Person类,Student类就拥有了Person类里的属性和方法了,我只需要在Student类里添加另外的新的属性和方法就可以了。Person类就成为父类,Student类就称为子类。父类和子类之间是一般和特殊的关系,子类是一种特殊的父类。此外,子类还可以通过重写来改变父类中的方法,重写可以改变方法的返回类型和访问权限,不能改变方法名称。
多态是建立在继承的基础上的,是指子类类型的对象可以赋值给父类类型的引用变量,但运行时仍表现子类的行为特征。也就是说,同一种类型的对象执行同一个方法时可以表现出不同的行为特征。
final
当这个关键字修饰一个类时,意味着他不能派生出新的子类,也就是说不能被继承,因此一个类不能被同时声明为abstract和final。当final修饰变量或者方法时,可以保证他们在使用中不会被改变。被声明为final的变量必须在初始化时给定初值,以后在使用时只能被引用而不能被修改。同样,当final修饰一个方法时,这个方法不能被重载。
finally
异常处理时提供finally来执行任何清楚操作。如果抛出一个异常,那么相匹配的catch子句就会被执行,然后控制就会转入finally块。
finalize
方法名。finalize方法在垃圾回收器执行内存对象清理时会调用finalize()方法进行前期的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的,因此所有的类都继承了它。
将session放在redis缓存中, 这样请求过来ngix中, 会先去redis中找session请求
通俗地讲就是能保证排序前2个相等的数其在序列的前后位置顺序和排序后它们两个的前后位置顺序相同。在简单形式化一下,如果Ai = Aj, Ai原来在位置前,排序后Ai还是要在Aj位置前。
其次,说一下稳定性的好处。排序算法如果是稳定的,那么从一个键上排序,然后再从另一个键上排序,第一个键排序的结果可以为第二个键排序所用。
ngix
如果你发现你的Web站点负载量非常大时,应当考虑使用负载均衡技术来将负载平均分摊到多个内部服务器上。
负载均衡可以将工作任务分摊到多个处理单元,从而提高并发处理能力。
将大量的并发请求分担到多个处理节点。由于单个处理节点的故障不影响整个服务,负载均衡集群同时也实现了高可用性。
数据库挂的原因? 场景分析: 高并发原因的话重启也没用.
后来发现有一个 O(n)算法。因为两个数组都是排好序的。所以只要一次遍历就行了。首先设两个下标,分别初始化为两个数组的起始地址,依次向前推进 。推进的规则是比较两个数组中的数字,小的那个数组的下标向前推进一步,直到任何一个数组的下标到达数组末尾时,如果这时还没碰到相同的数字,说明数组中没有相同的数字。
首先也是要对数组进行排序(时间复杂度为O(n*log(n))),然后再已排序的数组中,令i=0,j=n-1,判断arr[i]+arr[j]是否等于target,等于则结束,如果小于target,则i=i+1;如果大于target,则j=j-1,这样查找符合条件的两个元素的过程只需要遍历数组一次,因此查找的时间复杂度降低到O(n),总的时间复杂度还是O(n*log(n))。
简单的说,就是一次大的操作由不同的小操作组成,这些小的操作分布在不同的服务器上,且属于不同的应用,分布式事务需要保证这些小操作要么全部成功,要么全部失败。本质上来说,分布式事务就是为了保证不同数据库的数据一致性。
解决方案:
1. 基于XA协议的两阶段提交
2. 消息事务+最终一致性
3. TCC编程模式
源码实现的…
Synchronized关键词属于内置特性: 不需要手动释放锁
ReentrantLock是实现类: 需要手动释放锁, 可能导致死锁
如果多个线程都只是进行读操作,所以当一个线程在进行读操作时,其他线程只能等待无法进行读操作。
因此就需要一种机制来使得多个线程都只是进行读操作时,线程之间不会发生冲突,通过Lock就可以办到。
Synchronized和ReentrantLock都是可重入锁
如果不是, 可能会产生死锁
200 OK
301 永久重定向
302 临时重定向
400 Bad Request
403 Forbidden
404 Not Found
500 Internal Server Error
501 未实现
502 网关出错
MVC的优点
1. 低耦合性: 视图层和业务层分离,这样就允许更改视图层代码而不用重新编译模型和控制器代码
2. 高重用性和可适用性
3. 可维护性
缺点
不适合小型,中等规模的应用程序
struts1的缺陷:
(1).只支持JSP作为表现层技术,不能与Velocity,FreeMarker等技术整合
(2).与Servlet API严重耦合,难于测试
一个exute有四个参数ActionMapping、ActionForm、HttpServletRequest和HttpServletResponse,初始化困难.
(3).侵入式设计,严重依赖于Struts1API,如如ActionMapping、ActionForm和ActionForward类.一旦系统需要重构时,这些类完全没有利用价值,导致较低的代码复用.
Struts2是一种基于MVC的Web应用框架
控制器——FilterDispatcher
动作——Action
视图——Result
使用Collections.sort()传入ArrayList,会采用默认的方式进行排序(字典序)
使用Collections.sort()传入ArrayList和自己实现Commparator接口的类的对象,实现自定义排序
使用List.sort()传入自己实现Commparator接口的类的对象,实现自定义排序
Comparator返回值在jdk1.7、jdk1.8里必须是一对相反数,如1和-1,不能是1和0.因为1.7的排序算法采用timsort,对返回值有严格要求
hashmap
首先,在每个线程Thread内部有一个ThreadLocal.ThreadLocalMap类型的成员变量threadLocals,这个threadLocals就是用来存储实际的变量副本的,键值为当前ThreadLocal变量,value为变量副本(即T类型的变量)。
最常见的ThreadLocal使用场景为 用来解决 数据库连接、Session管理等。
SQL语句在程序运行前已经进行了预编译,在程序运行时第一次操作数据库之前,SQL语句已经被数据库分析,编译和优化,对应的执行计划也会缓存下来并允许数据库已参数化的形式进行查询,当运行时动态地把参数传给PreprareStatement时,即使参数里有敏感字符如 or ‘1=1’也数据库会作为一个参数一个字段的属性值来处理而不会作为一个SQL指令。
PreparedStatement可以尽可能的提高访问数据库的性能,我们都知道数据库在处理SQL语句时都有一个预编译的过程,而预编译对象就是把一些格式固定的SQL编译后,存放在内存池中即数据库缓冲池,当我们再次执行相同的SQL语句时就不需要预编译的过程了,只需DBMS运行SQL语句。
所以当你需要执行Statement对象多次的时候,PreparedStatement对象将会大大降低运行时间,特别是的大型的数据库中,它可以有效的也加快了访问数据库的速度。
Spring的事务管理机制实现的原理,就是通过这样一个动态代理对所有需要事务管理的Bean进行加载,并根据配置在invoke方法中对当前调用的 方法名进行判定,并在method.invoke方法前后为其加上合适的事务管理代码,这样就实现了Spring式的事务管理。Spring中的AOP实 现更为复杂和灵活,不过基本原理是一致的。
Repeatable Read (RR)
快照读忽略,本文不考虑。
针对当前读,RR隔离级别保证对读取到的记录加锁 (记录锁),同时保证对读取的范围加锁,新的满足查询条件的记录不能够插入 (间隙锁),不存在幻读现象。
间隙锁主要用来防止幻读,用在repeatable-read隔离级别下,指的是当对数据进行条件,范围检索时,对其范围内也许并存在的值进行加锁!当查询的索引含有唯一属性(唯一索引,主键索引)时,Innodb存储引擎会对next-key lock进行优化,将其降为record lock,即仅锁住索引本身,而不是范围!若是普通辅助索引,则会使用传统的next-key lock进行范围锁定!
CGLib采用了非常底层的字节码技术,其原理是通过字节码技术为一个类创建子类,并在子类中采用方法拦截的技术拦截所有父类方法的调用,顺势织入横切逻辑。
支持事务
支持行级锁和表级锁,能支持更多的并发量
mysql5.6版本开始支持 全文索引
查询不加锁,完全不影响查询
关键字总数相同的情况下B树的高度越小,磁盘I/O所花的时间越少.
AVL树: AVL树是带有平衡条件的二叉查找树,一般是用平衡因子差值判断是否平衡并通过旋转来实现平衡,左右子树树高不超过1.
适合用于插入删除次数比较少,但查找多的情况。
B+树:是应文件系统所需而产生的一种B树的变形树(文件的目录一级一级索引,只有最底层的叶子节点(文件)保存数据.),非叶子节点只保存索引,不保存实际的数据
加锁 同步
每个项目从整体架构设计、扩展性、后续优化到任何实现细节都有可能会问。对做过的事情需要多总结和优化思考。项目这块是需要花大量心思准备的。