后端面试

1、变量赋值之后会立即会写到主内存中（这也决定了volatile在并发环境下不一定是完全安全的，因为有些操作不一定是原子的） 2、有一个神奇的地方就是：就是当一个线程在读取一个使用volatile修饰的变量的时候，会将该线程中所有使用的变量从主内存中重新读取。

cpu的指令重排序是：cpu会改变指令分发给各处理单元的先后顺序，前提是保证指令与指令之间的依赖关系和处理结果一致 volatile起的作用，在指令编译时，如果volatile变量被赋值后，会在指令后新增一个带lock前缀的空操作A，这个带lock前缀的空操作A会将变量立即会写入主内存，以此避免了操作A前后的指令重排，也称为“内存屏障”。

volatile性能相比synchronized加锁的效率会更高，volatile变量的读取速度与普通变量差不多，写入操作需要同步到主内存

正如先前说的，volatile变量在被赋值后会回写到主内存，这个操作并不能保证并发一定安全。原因是：计算机执行一条程序一条指令并不是原子性的，比如一个i++自增操作，在汇编层面需要取数据，+1，会写数据多步，更别说后面的机器码了，如果一个线程对变量赋值后，会写到主内存的之前，此时另一个线程已经读取了前一次的数据，那么势必会出现问题。 所以：volatile变量使用的前提是1、变量的操作不依赖前一次操作结果 2、变量不需要与其他变量共同约束

并行：同时进行多个任务，发挥多cpu，多核cpu的能力，开发难度较大，多用于一些大型计算，图像处理 并发：轮流执行多个任务，发挥多cpu，多核cpu的能力，多用于互联网多用户请求 “并行”是“并发”概念的一个子集

硬件原因：cpu多核，每个cpu都拥有高速缓存，高速缓存中的变量不共享，主内存中的变量才共享 相应的，JVM内存模型也有类似的概念，分为工作内存和主内存，每个线程独立享有一个工作内存，工作内存中变量不共享。所以如果要让多核cpu协同工作，就有了并发的概念

1、某些变量用final修饰，保证其在各线程之间的可见性

1、一般情况下，除了原子操作，很少有绝对线程安全，即使很多synchronized线程安全类也不一定是绝对线程安全的，还需要人为进行同步

1、java中的线程安全类，如Vector，都是相对安全的

1、有些线程操作本身就是互斥的，容易产生死锁

互斥锁，如synchronized

CAS

1、可重入代码 2、本地线程存储（如ThreadLocal，web服务中每个请求就是一个线程，线程中采用本地存储）

单线程中，后面的代码对前面执行的代码是可见的。（如果后面的代码对前面的写有读操作，则需要禁止重排序，否则程序运行结果会出错）

管程中，前一个线程的解锁对后一个线程的加锁是可见的。（如果不能保证可见，锁的竞争就会有问题, 也无法保证互斥同步）

volatile变量的写操作对后续的读操作是可见的。（禁用缓存，同时加入内存屏障禁止了指令重排序）

主线程启动子线程，在子线程start前面的操作对子线程来说都是可见的。

主线程启动子线程，子线程调用join方法之后，子线程中的操作对join之后的代码都是可见的。

线程中断规则：线程发起中断interrupt对于后续的中断检测代码Thread.interrupted()都是可见的。

对象终结规则：一个对象的初始化对于后续它调用finalize方法都是可见的。

互斥

不可抢占

占有且等待,不会主动释放

循环等待

破坏占有后不可抢占：申请锁失败，尝试释放已经占有的锁

破坏占有且等待：一次性申请所有的锁

破坏循环等待：将多把锁按一定顺序进行加锁

负载均衡

异步调用

加缓存

数据分区

数据镜像

服务拆分

限流降级

高可用架构

高可用运维

服务冗余

cpu、内存、磁盘IO、网络

各种中间件，redis、kafka、tomcat、nginx

HTTP访问请求、响应时间、是否正确、方法调用链路、性能瓶颈

上层系统出现问题，能关联出此时基础层的情况，可以快速定位问题，如google的zipkin可以做到全链路的监控

信息太多等于没有信息

负载均衡

异步调用

加缓存

数据分区

数据镜像

服务拆分

限流降级

高可用架构

高可用运维

服务冗余

cpu、内存、磁盘IO、网络

各种中间件，redis、kafka、tomcat、nginx

HTTP访问请求、响应时间、是否正确、方法调用链路、性能瓶颈

上层系统出现问题，能关联出此时基础层的情况，可以快速定位问题，如google的zipkin可以做到全链路的监控

信息太多等于没有信息

微服务是最优解，下限是不能产生依赖环

每个模块之间版本的依赖关系

我们会有一张服务架构的地图，可以知道整个架构有多少种服务、服务版本、每个服务有多少实例，相应状态

发现、降级、熔断、路由

负载均衡、流量分配

协议转换、校验、缓存、边缘计算等

高性能语言编写

集群、paxos

Hashtable

LinkedHashMap

TreeMap

HashMap

Set

Queue

List

是：set

否：List

我们可以看源码里面，hashtable的Entry中setValue方法： public V setValue(V value) { if (value == null) throw new NullPointerException(); V oldValue = this.value; this.value = value; return oldValue; }

官方注释里面说该类已经过时，新的实现采用Map接口 NOTE: This class is obsolete. New implementations should implement the Map interface, rather than extending this class. 但我们可以来看一下，dictionary抽象类里面定义了类似size(),isEmpty(),put(),get(),keys(),elements(),remove()方法，

虽然Map属于Java集合，但map不属于集合，map包含的是键值对，不适合“一组对象”这一说

Jdk6

jdk8

Jdk6

看到hashMap和HashTable的扩容重hash过程： hashTable是在put时发现count触发到threshold了，直接进行重哈希rehash，大小升级到2*old+1，然后再插入，这会是put操作时间延长 hashMap会提前预测，先插入成功，然后判断当发现再加一个就触发threshold时，就提前开始resize，升级为2*old大小

硬件原因：cpu多核，每个cpu都拥有高速缓存，高速缓存中的变量不共享，主内存中的变量才共享 相应的，JVM内存模型也有类似的概念，分为工作内存和主内存，每个线程独立享有一个工作内存，工作内存中变量不共享。所以如果要让多核cpu协同工作，就有了并发的概念

1、首先是定义了每个线程独享一个工作内存，和一个共享主内存 2、变量在工作内存和主内存之间的读写机制，主要有8个，lock、unlock、read、load、use、assign、store、write

内存可见性

禁止指令重排序

volatile性能

volatile不是随便用的

1、 在第一次使用的地方进行声明 2、 局部变量都是要自行初始化，初始化条件不满足，就不要声明； 初始化的好处，减小局部变量表的大小，提高性能； 同时避免局部变量过早声明导致不正确的使用。

这样在编译期间就可以把这些内容放入常量池中，避免运行期间计算生成常量的值。另外，将常量的名字以大写命名也可以方便区分出常量与变量

例如：
for (int i = 1; i <= count; i++)
{
Object obj = new Object();
}
这种做法会导致内存中有count份Object对象引用存在，count很大的话，就耗费内存了，建议为改为：
Object obj = null;
for (int i = 0; i <= count; i++)
{
obj = new Object();
}
这样的话，内存中只有一份Object对象引用，每次new Object()的时候，Object对象引用指向不同的Object罢了，但是内存中只有一份，这样就大大节省了内存空间了。

要知道，当某个对象被定义为static的变量所引用，那么gc通常是不会回收这个对象所占有的堆内存的，如： public class A { private static B b = new B(); } 此时静态变量b的生命周期与A类相同，如果A类不被卸载，那么引用B指向的B对象会常驻内存，直到程序终止

遍历Map的方式有很多，通常场景下我们需要的是遍历Map中的Key和Value，那么推荐使用的、效率最高的方式是：
public static void main(String[] args)

{

HashMap<String, String> hm = new HashMap<String, String>();

hm.put("111", "222");

Set<Map.Entry<String, String>> entrySet = hm.entrySet();

Iterator<Map.Entry<String, String>> iter = entrySet.iterator();

while (iter.hasNext())

{

Map.Entry<String, String> entry = iter.next();

System.out.println(entry.getKey() + "" + entry.getValue());

}

}
如果你只是想遍历一下这个Map的key值，那用”Set<String> keySet = hm.keySet();”会比较合适一些

带缓冲的输入输出流，即BufferedReader、BufferedWriter、BufferedInputStream、BufferedOutputStream，这可以极大地提升IO效率

比如ArrayList、LinkedLlist、StringBuilder、StringBuffer、HashMap、HashSet等等，以StringBuilder为例： StringBuilder()　　　　　　// 默认分配16个字符的空间 StringBuilder(int size)　　// 默认分配size个字符的空间 StringBuilder(String str)　// 默认分配16个字符+str.length()个字符空间 可以通过类（这里指的不仅仅是上面的StringBuilder）的构造函数来设定它的初始化容量，这样可以明显地提升性能。比如StringBuilder吧，length表示当前的StringBuilder能保持的字符数量。因为当StringBuilder达到最大容量的时候，它会将自身容量增加到当前的2倍再加2，无论何时只要StringBuilder达到它的最大容量，它就不得不创建一个新的字符数组然后将旧的字符数组内容拷贝到新字符数组中—-这是十分耗费性能的一个操作。试想，如果能预估到字符数组中大概要存放5000个字符而不指定长度，最接近5000的2次幂是4096，每次扩容加的2不管，那么： 在4096 的基础上，再申请8194个大小的字符数组，加起来相当于一次申请了12290个大小的字符数组，如果一开始能指定5000个大小的字符数组，就节省了一倍以上的空间 把原来的4096个字符拷贝到新的的字符数组中去 这样，既浪费内存空间又降低代码运行效率。所以，给底层以数组实现的集合、工具类设置一个合理的初始化容量是错不了的，这会带来立竿见影的效果。但是，注意，像HashMap这种是以数组+链表实现的集合，别把初始大小和你估计的大小设置得一样，因为一个table上只连接一个对象的可能性几乎为0。初始大小建议设置为2的N次幂，如果能估计到有2000个元素，设置成new HashMap(128)、new HashMap(256)都可以。

这是因为静态类、单例类、工厂类这种类本来我们就不需要外部将它们new出来，将构造函数置为private之后，保证了这些类不会产生实例对象。

Array和ArrayList的区别

因为这毫无意义，这样只是定义了引用为static final，数组的内容还是可以随意改变的，将数组声明为public更是一个安全漏洞，这意味着这个数组可以被外部类所改变

避免无意中创建的对象，如自动装箱

这点在多线程模块中的synchronized锁方法块一文中已经讲得很清楚了，除非能确定一整个方法都是需要进行同步的，否则尽量使用同步代码块，避免对那些不需要进行同步的代码也进行了同步，影响了代码执行效率。 https://www.cnblogs.com/woyaobianfei/p/8046616.html

异常处理效率低，RuntimeException的运行时异常类，其中绝大多数完全可以由程序员来规避，比如： ArithmeticException可以通过判断除数是否为空来规避 NullPointerException可以通过判断对象是否为空来规避 IndexOutOfBoundsException可以通过判断数组/字符串长度来规避 ClassCastException可以通过instanceof关键字来规避 ConcurrentModificationException可以使用迭代器来规避

//可能很多 0~很多
static int sum(int... args) {
int sum = 0;
for (int arg : args)
sum += arg;
return sum;
}

//要求参数的个数，是1~多个
//
static int sum1(int... args) {
if(args.length==0) {
//做点异常处理
}
if(args[0]==100) {

}
for(int i=1;i<args.length;i++) {
int sum = 0;
sum += args[i];
return sum;
}
}

static int sum2(int flag, int... args) {
if(flag==100) {

}
int sum = 0;
for (int arg : args)
sum += arg;
return sum;
return Collections.EMPTY_LIST;
}

方法的结果返回null，会导致调用方的要单独处理为null的情况。返回零长度，调用方可以统一处理，如使用foreach即可。 JDK中也为我们提供了Collections.EMPTY_LIST这样的零长度集合

boolean 1字节 byte 1字节 8位 char 2字节 0 - 2^16-1 无符号数 short 2字节 16位 2^15-1 int 4字节 32位 2^31-1 float 4字节 单浮点 2^31-1 double 8字节 双浮点 2^63-1 long 8字节 长整形 2^63-1

在JDK里常用的一种设计方法是：定义一个接口，声明一个抽象的骨架类实现接口，骨架类类实现通用的方法，而实际的业务类可以同时实现接口又继承骨架类，也可以只实现接口。 如HashSet实现了implements Set接口 但是又extends 类AbstractSet，而AbstractSet本身也实现了Set接口。其他如Map，List都是这样的设计的。

分支主题

当前基本所有的项目都使用了线程池技术，这非常好，可以动态配置线程数、可以重用线程。

然而，如果你在项目中使用到了ThreadLocal，一定要记得使用前或者使用后remove一下。这是因为上面提到了线程池技术做的是一个线程重用，这意味着代码运行过程中，一条线程使用完毕，并不会被销毁而是等待下一次的使用。我们看一下Thread类中，持有ThreadLocal.ThreadLocalMap的引用：

/* ThreadLocal values pertaining to this thread. This map is maintained

* by the ThreadLocal class. */

ThreadLocal.ThreadLocalMap threadLocals = null;

线程不销毁意味着上条线程set的ThreadLocal.ThreadLocalMap中的数据依然存在，那么在下一条线程重用这个Thread的时候，很可能get到的是上条线程set的数据而不是自己想要的内容。

这个问题非常隐晦，一旦出现这个原因导致的错误，没有相关经验或者没有扎实的基础非常难发现这个问题，因此在写代码的时候就要注意这一点，这将给你后续减少很多的工作量。

解释一下竞争同一个seed导致性能下降的原因，比如，看一下Random类的nextInt()方法实现：
1 public int nextInt() {

2 return next(32);

3 }

调用了next(int bits)方法，这是一个受保护的方法：

1 protected int next(int bits) {

2 long oldseed, nextseed;

3 AtomicLong seed = this.seed;

4 do {

5 oldseed = seed.get();

6 nextseed = (oldseed * multiplier + addend) & mask;

7 } while (!seed.compareAndSet(oldseed, nextseed));

8 return (int)(nextseed >>> (48 - bits));

9 }

而这边的seed是一个全局变量：

1 /**

2 * The internal state associated with this pseudorandom number generator.

3 * (The specs for the methods in this class describe the ongoing

4 * computation of this value.)

5 */

6 private final AtomicLong seed;

多个线程同时获取随机数的时候，会竞争同一个seed，导致了效率的降低。

String

List

Hash

Set

Zset

与keys命令相比，scan通过游标分步进行，不会阻塞线程

高位进位加法的遍历顺序，避免了字典扩容的影响

操作渐进式rehash的hash时，需要同时遍历新旧两个hash

setbit、getbit、bitcount（计数）、bitpos（查找定位）、 bitfield（可以操作多个bit位）,bitfield还提供了溢出策略sat和fail 如bitfield w overflow sat incrby u4 2 1

1、zset通过时间窗口实现简单限流，以时间戳作为zset元素的score

漏斗包含：容量、流速、剩余容量、上一次流出时间，每次取流量的时候会计算一下当前漏斗的剩余容量 漏斗可以交给hash缓存redis-cell，指令 cl.throttle key capacity operations seconds quota

怎么实现？list可以通过push、pop实现消息队列

如果队列为空，消费者会不断轮询怎么办？消费者不断地轮询会造成较大的性能损耗，使得redis的qps大大增高，第一种可以采用如果队列为空，则sleep一下，但这样在现实情况下及时性会受到影响，第二种采用blpop、brpop命令，阻塞读，如果队列为空则阻塞在哪里，当队列有值时，可以立即读出；在这种情况下，如果迟迟未读到数据，服务器会释放连接，抛出异常，客户端需要作出处理，比如重试。

延时队列怎么实现？通过zset，把下一次任务执行的时间戳作为score加入到延时队列，用多个线程根据时间戳取出任务进行执行。此时要保证的是只会有一个线程能抢到消息。

在多个线程从zset延时队列中获取任务zrangeByScore的时候，是会存在多个线程同时获取到，但zrem只会有一个线程能做到，zrem成功的线程可以处理消息 我们可以看到，上面的情况zrangeByScore是会有较大浪费的，可以采用lua脚本将zrangeByScore和zrem作为一个原子操作

pfadd、pfcount、pfmerge，可用于不需要很精确的计数，如网站的用户访问量，会去重

原理：各组随机数末尾0的个数的最大值K，与总随机数个数N存在 近似 2^k = N的关系

HyperLogLog只能解决去重计数问题，无法解决ismenbers问题，引入布隆过滤器 bf.add、bf.exsits 布隆过滤器当元素超出初始大小，准确率会下降，而且增加会比较可怕，可通过bf.reserve调整参数，设置错误率和估算数据量

原理：通过hash排布判断元素是否出现过，bloomFilter判断没出现过，则肯定没出过。判断出现过，可能没出现过

附近的人 geoadd、geodist、geopos、geohash georadiusbymenber key value number km count number asc列出附近的人

地图上的事物是会移动的，而我们把位置数据放在一个zset集合中，在redis集群，可能从一个节点到另一个节点，性能影响较大，建议每个key的数据量<1M 不建议集群，建议单redis实例部署，可以对geo数据按照国家、省市区拆分

存储用户信息

分支主题

会过期的key会放入一个字典并定期扫描。扫描采用贪心算法，每次随机20个key，删过过期key，直到取出来的过期key小于1/4

key过期时间上再加上一个随机数，防止同时过期

从节点过期key依赖主节点的aof日志，所以主节点挂了会影响从节点的key过期

分支主题

redis的对象信息都会有一个对象头 struct RedisObject { int4 type; // 4bits int4 encoding; // 4bits int24 lru; // 24bits int32 refcount; // 4bytes void *ptr; // 8bytes，64-bit system } robj; 64位系统占用16字节

字符串长度<1M,加倍扩容，>1M,每次扩容1M

分支主题

redis无法立即将空闲内存立即归还操作系统，但可复用 flushdb命令会强制清理内存

采用第三方内存分配库jemalloc

CAP（一致性Consistent、可用性Availability、分区容错性Partition tolerance）原理： 一句话概括，一致性和可用性无法同时满足

网络分区：就是不同机器之间断网了，网络隔离了

分布式的redis不满足“一致性”要求，但满足可用性要求，即使从节点挂了，主节点能正常提供服务，但会保证最终一致性，

增量同步

快照同步

注意点

从节点刚加入集群，首先进行快照同步，然后再增量同步

考虑到有盘复制是很重的io操作，甚至会使得AOF的fsync操作推迟。 无盘复制直接通过遍历内存，将内容通过套接字发给从节点，从节点保存到磁盘文件再一次性加载

为了保证修改性指令能同步到从节点，通过wait指令是的修改性指令执行后立即同步给从节点，并设置timeout，如果timeout为0，且从节点挂了，会使得主节点也会不可用

哨兵有两个可调参数，限制消息丢失 min-slaves-to-write 1 至少有一个从节点可以正常复制 min-slaves-max-lag 10 等待从节点10s，超过时间未回应认为从节点挂了，主节点停止工作

分支主题