JAVA

Java常用的数据结构有哪些?哪些是线程安全的?是怎么保证线程安全的？

Java开发中常用的数据结构
简述Java中满足线程安全的数据结构

多个线程同时读写，读线程的数量远远大于写线程，你认为应该如何解决并发的问题？你会选择加什么样的锁？

ReadWriteLock读写锁

JAVA的AQS是否了解，它是干嘛的？

AbstractQueuedSynchronizer（AQS）为实现依赖于先进先出 (FIFO) 等待队列的阻塞锁定和相关同步器（信号量、事件，等等）提供一个框架。
要明白AQS在功能上有独占锁和共享锁两种功能。

除了synchronized关键字之外，你是怎么来保障线程安全的？

- 1、互斥同步(阻塞同步)，悲观并发策略
  synchronized关键字 、ReentrantLock
- 2、非阻塞同步，基于冲突检测的乐观并发策略
    非阻塞的实现CAS（compareandswap）：CAS指令需要有3个操作数，分别是内存地址（在java中理解为变量的内存地址，用V表示）、旧的预期值（用A表示）和新值（用B表示）。CAS指令执行时，CAS指令指令时，当且仅当V处的值符合旧预期值A时，处理器用B更新V处的值，否则它就不执行更新，但是无论是否更新了V处的值，都会返回V的旧值，上述的处理过程是一个原子操作。
    CAS缺点：
        - ABA问题：因为CAS需要在操作值的时候检查下值有没有发生变化，如果没有发生变化则更新，但是一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时会发现它的值没有发生变化，但是实际上却变化了。

        - ABA问题的解决思路就是使用版本号。在变量前面追加版本号，每次变量更新的时候把版本号加一，那么A-B-A就变成了1A-2B-3C。JDK的atomic包里提供了一个类AtomicStampedReference来解决ABA问题。这个类的compareAndSet方法作用是首先检查当前引用是否等于预期引用，并且当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。

- 3、无需同步方案
    要保证线程安全，并不是一定就要进行同步，两者没有因果关系。同步只是保证共享数据争用时的正确性的手段，如果一个方法本来就不涉及共享数据，那它自然就无需任何同步操作去保证正确性，因此会有一些代码天生就是线程安全的。

    - 1）可重入代码
       可重入代码（ReentrantCode）也称为纯代码（Pure Code），可以在代码执行的任何时刻中断它，转而去执行另外一段代码，而在控制权返回后，原来的程序不会出现任何错误。所有的可重入代码都是线程安全的，但是并非所有的线程安全的代码都是可重入的。

       可重入代码的特点是不依赖存储在堆上的数据和公用的系统资源、用到的状态量都是由参数中传入、不调用 非可重入的方法等。

       （类比：synchronized拥有锁重入的功能，也就是在使用synchronized时，当一个线程得到一个对象锁后，再次请求此对象锁时时可以再次得到该对象的锁）

    - 2）线程本地存储

       如果一段代码中所需的数据必须与其他代码共享，那就看看这些共享数据的代码是否能保证在同一个线程中执行？如果能保证，我们就可以把共享数据的可见范围限制在同一个线程之内。这样无需同步也能保证线程之间不出现数据的争用问题。

       符合这种特点的应用并不少见，大部分使用消费队列的架构模式（如“生产者-消费者”模式）都会将产品的消费过程尽量在一个线程中消费完。其中最重要的一个应用实例就是经典的Web交互模型中的“一个请求对应一个服务器线程（Thread-per-Request）”的处理方式，这种处理方式的广泛应用使得很多Web服务器应用都可以使用线程本地存储来解决线程安全问题。

Tomcat本身的参数你一般会怎么调整？

HashMap和Hashtable的区别。

实现一个保证迭代顺序的HashMap。

说说HashMap的原理, 以及HashMap如何扩充bucket的大小。

说一说排序算法，稳定性，复杂度。

TCP如何保证可靠传输？三次握手过程？

如何控制某个方法允许并发访问线程的个数

Semaphore（信号量）

死锁是什么意思，形成条件是什么？出现死锁是可以通过什么方式去排查。

监测死锁可以使用jdk自带的工具。
执行jps命令，得到运行的线程的id，
jps -l
再执行jstack命令，查看结果。
jstack -l pid

jvisualVM, jconsole

Java中活锁和死锁有什么区别？

活锁：互相释放资源给对方，结果谁都没有用到这资源。
死锁：互相抢着资源，谁都没有抢到。

产生死锁的四个必要条件：

• （1）互斥条件：一个资源每次只能被一个进程使用。
• （2）占有且等待：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
• （3）不可强行占有:进程已获得的资源，在末使用完之前，不能强行剥夺。
• （4）循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

如何避免死锁？

　　加锁顺序（线程按照一定的顺序加锁）；
　　加锁时限（线程尝试获取锁的时候加上一定的时限，超过时限则放弃对该锁的请求，并释放自己占有的锁）；
　　死锁检测。

对于volatile关键字，当且仅当满足以下所有条件时可使用：

1. 对变量的写入操作不依赖变量的当前值，或者你能确保只有单个线程更新变量的值。
2. 该变量没有包含在具有其他变量的不变式中。
3. static是类的属性，存储在类的那块内存，每个线程操作的时候会读取这个内存块，甚至会加载到寄存器或高速缓存中，这样自然不会保证其他线程对该值的可见性；而volatile表示每次读操作直接到内存，如果多个线程都遵循这样的约定，就会读取到最新的状态.
   PS：synchronized代码块会对变量进行写入操作

什么时候需要加volatile关键字？它能保证线程安全吗？

volatile是不能保证线程安全的，它只是保证了数据的可见性，不会再缓存，

每个线程都是从主存中读到的数据，而不是从缓存中读取的数据，

当synchronized去掉的时候，每个线程的结果是乱的，加上的时候结果才是正确的。

并发编程的3个概念：原子性、可见性、有序性

• 原子性：一个操作或多个操作要么全部执行完成且执行过程不被中断，要么就不执行。
• 可见性：当多个线程同时访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。
• 有序性：程序执行的顺序按照代码的先后顺序执行。

线程池内的线程如果全部忙，提交一个新的任务，会发生什么？队列全部塞满了之后，还是忙，再提交会发生什么？

一个任务通过execute(Runnable)方法被添加到线程池，任务就是一个Runnable类型的对象，任务的执行方法就是Runnable类型对象的run()方法。当一个任务通过execute(Runnable)方法想添加到线程池时：

• 如果此时线程池中数量小于corePoolSize,即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。
• 如果此时线程池中的数量等于corePoolSize,但是缓冲队列workQueue未满，那么任务放入缓冲队列
• 如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量小于maximumPoolSize，建新的线程来处理被添加的任务。
• 如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue 满，并且线程池中的数量等于maximumPoolSize，那么通过handler所指定的策略来处理此任务。也就是：处理任务的优先级为：核心线程 corePoolSize、任务队列workQueue、最大线程maximumPoolSize，如果三者都满了，使用handler处理被拒绝的任务
• 当线程池中的线程数量大于corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池可以动态的调整池中的线程数。
  • corePoolSize： 线程池维护线程的最少数量
  • maxnumPoolSize： 线程池维护线程的最大数量
  • keepAliveTime： 线程池维护线程所允许的空闲时间
  • unit： 线程池维护线程所允许的空闲时间的单位
  • workQueue： 线程池所使用的缓冲队列
  • handler： 线程池对拒绝任务的处理策略

synchronized关键字锁住的是什么东西？在字节码中是怎么表示的？在内存中的对象上表现为什么？

1. synchronized锁住的是括号里的对象，不是代码。对于非static的synchronized方法，锁的就是对象本身也就是this。
2. 在java语言中存在两种内建的synchronized语法：
   • 1、synchronized语句；对于synchronized语句当Java源代码被javac编译成bytecode的时候，会在同步块的入口位置和退出位置分别插入monitorenter和monitorexit字节码指令。
   • 2、synchronized方法。synchronized方法则会被翻译成普通的方法调用和返回指令如:invokevirtual、areturn指令，在VM字节码层面并没有任何特别的指令来实现被synchronized修饰的方法，而是在Class文件的方法表中将该方法的access_flags字段中的synchronized标志位置1，表示该方法是同步方法并使用调用该方法的对象或该方法所属的Class在JVM的内部对象表示Klass做为锁对象

synchronized 的原理是什么？synchronized 和 ReentrantLock 有什么不同？

这两种方式最大区别就是对于Synchronized来说，它是java语言的关键字，是原生语法层面的互斥，需要jvm实现。而ReentrantLock它是JDK 1.5之后提供的API层面的互斥锁，需要lock()和unlock()方法配合try/finally语句块来完成。

Synchronized进过编译，会在同步块的前后分别形成monitorenter和monitorexit这个两个字节码指令。在执行monitorenter指令时，首先要尝试获取对象锁。如果这个对象没被锁定，或者当前线程已经拥有了那个对象锁，把锁的计算器加1，相应的，在执行monitorexit指令时会将锁计算器就减1，当计算器为0时，锁就被释放了。如果获取对象锁失败，那当前线程就要阻塞，直到对象锁被另一个线程释放为止。

wait/notify/notifyAll方法需不需要被包含在synchronized块中？这是为什么？

Obj.wait()，与Obj.notify()必须要与synchronized(Obj)一起使用，也就是wait,与notify是针对已经获取了Obj锁进行操作。

　　从语法角度来说就是Obj.wait(),Obj.notify必须synchronized(Obj){…}语句块内。
　　从功能上来说wait就是说线程在获取对象锁后，主动释放对象锁，同时本线程休眠。直到有其它线程调用对象的notify()唤醒该线程，才能继续获取对象锁，并继续执行
　　如果实例方法含有如下的语句时：wait();则其意义同：this.wait();

Executors类是什么？ Executor和Executors的区别？

1. Executor
   它是”执行者来”接口，它是来执行任务的。准确的说，Executor提供了execute()接口来执行已提交的 Runnable 任务的对象。Executor存在的目的是提供一源种将”任务提交”与”任务如何运行”分离开来的知机制。它只包含一个函数接口。

2. Executors
   Executors是个静态工厂类。它通过静态工厂方法返回到ExecutorService、ScheduledExecutorService、ThreadFactory 和 Callable 等类的对象。

ExecutorService你一般是怎么用的？是每个service放一个还是一个项目里面放一个？有什么好处？

Java线程池ExecutorService
如果有一套相同逻辑的多个任务的情况下,应用一个线程池是个好选择。
如果项目中有多套不同的这种任务,那每套任务应该一个线程池。

线程池是什么？为什么要使用它？如何创建一个Java线程池？

线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。
线程池线程都是后台线程。每个线程都使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。
如果某个线程在托管代码中空闲（如正在等待某个事件），则线程池将插入另一个辅助线程来使所有处理器保持繁忙。
如果所有线程池线程都始终保持繁忙，但队列中包含挂起的工作，则线程池将在一段时间后创建另一个辅助线程但线程的数目永远不会超过最大值。
超过最大值的线程可以排队，但他们要等到其他线程完成后才启动。

使用线程池的好处:

1. 重用存在的线程，减少对象创建、消亡的开销，性能佳。
2. 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。
3. 提供定时执行、定期执行、单线程、并发数控制等功能。

线程池内部工作原理可以说一下么？

其实java线程池的实现原理很简单，说白了就是一个线程集合workerSet和一个阻塞队列workQueue。当用户向线程池提交一个任务(也就是线程)时，线程池会先将任务放入workQueue中。workerSet中的线程会不断的从workQueue中获取线程然后执行。当workQueue中没有任务的时候，worker就会阻塞，直到队列中有任务了就取出来继续执行。

线程池创建有几种，为什么创建定长的线程池个数最好是5，10，15这样的数字。

1. newCachedThreadPool
   创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。这种类型的线程池特点是：
   工作线程的创建数量几乎没有限制(其实也有限制的,数目为Interger. MAX_VALUE), 这样可灵活的往线程池中添加线程。
   如果长时间没有往线程池中提交任务，即如果工作线程空闲了指定的时间(默认为1分钟)，则该工作线程将自动终止。终止后，如果你又提交了新的任务，则线程池重新创建一个工作线程。
   在使用CachedThreadPool时，一定要注意控制任务的数量，否则，由于大量线程同时运行，很有会造成系统瘫痪。

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

   ExecutorService cachedThreadPool = Executors.newCachedThreadPool(); for (int i = 0; i < 10; i++) { final int index = i; try { Thread.sleep(index * 1000); } catch (InterruptedException e) { e.printStackTrace(); } cachedThreadPool.execute(new Runnable() { @Override public void run() { System.out.println(index); } }); }

2. newFixedThreadPool
   创建一个指定工作线程数量的线程池。每当提交一个任务就创建一个工作线程，如果工作线程数量达到线程池初始的最大数，则将提交的任务存入到池队列中。

   FixedThreadPool是一个典型且优秀的线程池，它具有线程池提高程序效率和节省创建线程时所耗的开销的优点。但是，在线程池空闲时，即线程池中没有可运行任务时，它不会释放工作线程，还会占用一定的系统资源。

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

   ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3); for (int i = 0; i < 10; i++) { final int index = i; fixedThreadPool.execute(new Runnable() { @Override public void run() { try { System.out.println(index); Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } } }); }

3. newSingleThreadExecutor
   创建一个单线程化的Executor，即只创建唯一的工作者线程来执行任务，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。如果这个线程异常结束，会有另一个取代它，保证顺序执行。单工作线程最大的特点是可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

   ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor(); for (int i = 0; i < 10; i++) { final int index = i; singleThreadExecutor.execute(new Runnable() { @Override public void run() { try { System.out.println(index); Thread.sleep(2000); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }); }

4. newScheduleThreadPool
   创建一个定长的线程池，而且支持定时的以及周期性的任务执行，支持定时及周期性任务执行。

   1 2 3 4 5 6 7

   ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5); scheduledThreadPool.schedule(new Runnable() { @Override public void run() { System.out.println("delay 3 seconds"); } }, 3, TimeUnit.SECONDS);

5. newWorkStealingPool：jdk1.8新增,创建持有足够线程的线程池来支持给定的并行级别，并通过使用多个队列，减少竞争，它需要穿一个并行级别的参数，如果不传，则被设定为默认的CPU数量。

   1 2 3 4 5

   public static ExecutorService newWorkStealingPool() { return new ForkJoinPool (Runtime.getRuntime().availableProcessors(), ForkJoinPool.defaultForkJoinWorkerThreadFactory, null, true); }

   1 2 3 4 5 6 7 8 9 10 11

   public ForkJoinPool(int parallelism, ForkJoinWorkerThreadFactory factory, UncaughtExceptionHandler handler, boolean asyncMode) { this(checkParallelism(parallelism), checkFactory(factory), handler, asyncMode ? FIFO_QUEUE : LIFO_QUEUE, "ForkJoinPool-" + nextPoolId() + "-worker-"); checkPermission(); }

可以看出前四种线程池最终都是返回了ThreadPoolExecutor对象，最后一个返回的ForkJoinPool是jdk1.7才新增的。

线程池个数:

1. 先看下机器的CPU核数，然后在设定具体参数：

即CPU核数 = Runtime.getRuntime().availableProcessors()

2. 分析下线程池处理的程序是CPU密集型，还是IO密集型

• CPU密集型：核心线程数 = CPU核数 + 1

• IO密集型：核心线程数 = CPU核数 * 2

注：IO密集型（某大厂实践经验）

• 核心线程数 = CPU核数 / （1-阻塞系数）
  例如阻塞系数 0.8，CPU核数为4,则核心线程数为20

在交易过程中如何放在用户在支付时的重复支付（交叉支付），请写出你了解的方案或使用的过的方案。

程序开发时通过开发工具DeBug调试时，控制台显示的内容都包含什么？哪些内容可以帮助你发现问题和解决问题。

RPC通信过程中，假设A系统提供了一个方法入参是一个JavaBean，出参也是一个JavaBean。另外两个系统B系统、C系统调用接口，调用方B想让提供方A增加一个返回参数，假设服务提供方A增加了返回参数，请问C系统调用方需要做什么处理？

了解哪些设计模式，用伪代码实现一个你熟悉的设计模式。

知道哪些负载均衡算法。

说一下Btree的查找原理。

简述三次握手，如果c端发起握手请求，s端无法立刻建立连接应该回应什么？

Java对象四种引用。

Java字节流、字符流使用场景、为什么有了字符流还要字节流？

Java序列化Id的作用

• 序列化ID的作用：
  其实，这个序列化ID起着关键的作用，它决定着是否能够成功反序列化！简单来说，java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地实体类中的serialVersionUID进行比较，如果相同则认为是一致的，便可以进行反序列化，否则就会报序列化版本不一致的异常。

• 序列化ID如何产生：
  当我们一个实体类中没有显示的定义一个名为“serialVersionUID”、类型为long的变量时，Java序列化机制会根据编译时的class自动生成一个serialVersionUID作为序列化版本比较，这种情况下，只有同一次编译生成的class才会生成相同的serialVersionUID。譬如，当我们编写一个类时，随着时间的推移，我们因为需求改动，需要在本地类中添加其他的字段，这个时候再反序列化时便会出现serialVersionUID不一致，导致反序列化失败。那么如何解决呢？便是在本地类中添加一个“serialVersionUID”变量，值保持不变，便可以进行序列化和反序列化。

Java为什么要有基本类型的包装类,为什么要有基本类型。

什么是泛型? 参数化类型

什么是反射

Java类型擦除（泛型擦除）

Java有哪几种IO模型

Jdk代理、cglib代理的区别

讲一下怎么使用分布式锁

java.util.concurrent包下CountDownLatch、CyclicBarrier和 Semaphore使用场景

1. CountDownLatch
   CountDownLatch类利用它可以实现类似计数器的功能。比如有一个任务A，它要等待其他4个任务执行完毕之后才能执行，此时就可以利用CountDownLatch来实现这种功能了。

2. CyclicBarrier
   字面意思回环栅栏，通过它可以实现让一组线程等待至某个状态之后再全部同时执行。叫做回环是因为当所有等待线程都被释放以后，CyclicBarrier可以被重用。

3. Semaphore
   Semaphore翻译成字面意思为 信号量，Semaphore可以控同时访问的线程个数，通过 acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可。

区别:
CountDownLatch和CyclicBarrier都能够实现线程之间的等待，只不过它们侧重点不同：

• 1、CountDownLatch一般用于某个线程A等待若干个其他线程执行完任务之后，它才执行；
• 2、CyclicBarrier一般用于一组线程互相等待至某个状态，然后这一组线程再同时执行；
• 3、另外，CountDownLatch是不能够重用的，而CyclicBarrier是可以重用的。
  Semaphore其实和锁有点类似，它一般用于控制对某组资源的访问权限。

什么是线程局部变量ThreadLocal

线程局部变量是局限于线程内部的变量，属于线程自身所有，不在多个线程间共享。Java提供ThreadLocal类来支持线程局部变量，是一种实现线程安全的方式。但是在管理环境下（如 web 服务器）使用线程局部变量的时候要特别小心，在这种情况下，工作线程的生命周期比任何应用变量的生命周期都要长。任何线程局部变量一旦在工作完成后没有释放，Java 应用就存在内存泄露的风险。

ThreadLoal的作用是什么?

简单说ThreadLocal就是一种以空间换时间的做法在每个Thread里面维护了一个ThreadLocal.ThreadLocalMap把数据进行隔离，数据不共享，自然就没有线程安全方面的问题了。

JVM

你知道哪些或者你们线上使用什么GC策略? 它有什么优势，适用于什么场景？

JAVA类加载器包括几种？它们之间的父子关系是怎么样的？双亲委派机制是什么意思？有什么好处？

JVM如何加载一个类的过程，双亲委派模型中有哪些方法？

如何自定义一个类加载器？你使用过哪些或者你在什么场景下需要一个自定义的类加载器吗？

堆内存设置的参数是什么？

Perm Space中保存什么数据? 会引起OutOfMemory吗？

做gc时，一个对象在内存各个Space中被移动的顺序是什么？

你有没有遇到过OutOfMemory问题？你是怎么来处理这个问题的？处理过程中有哪些收获？

1.8之后Perm Space有哪些变动? MetaSpace大小默认是无限的么? 还是你们会通过什么方式来指定大小?

Jstack是干什么的? Jstat呢? 如果线上程序周期性地出现卡顿，你怀疑可能是gc导致的，你会怎么来排查这个问题？线程日志一般你会看其中的什么部分？

StackOverFlow异常有没有遇到过？一般你猜测会在什么情况下被触发？如何指定一个线程的堆栈大小？一般你们写多少？

Jvm的内存屏障

Spring

你有没有用过Spring的AOP? 是用来干嘛的? 大概会怎么使用？

如果一个接口有2个不同的实现, 那么怎么来Autowire一个指定的实现？

Spring的声明式事务 @Transaction注解一般写在什么位置? 抛出了异常会⾃动回滚吗？有没有办法控制不触发回滚?

如果想在某个Bean生成并装配完毕后执行自己的逻辑，可以什么方式实现？

SpringBoot没有放到web容器里为什么能跑HTTP服务？

SpringBoot中如果你想使用自定义的配置文件而不仅仅是application.properties，应该怎么弄？

SpringMVC中RequestMapping可以指定GET, POST方法么？怎么指定？

SpringMVC如果希望把输出的Object(例如XXResult或者XXResponse)这种包装为JSON输出, 应该怎么处理?

怎样拦截SpringMVC的异常，然后做自定义的处理，比如打日志或者包装成JSON

MySQL

如果有很多数据插入MYSQL 你会选择什么方式?

如果查询很慢，你会想到的第一个方式是什么？索引是干嘛的?

如果建了一个单列索引，查询的时候查出2列，会用到这个单列索引吗？

如果建了一个包含多个列的索引，查询的时候只用了第一列，能不能用上这个索引？查三列呢？

接上题，如果where条件后面带有一个 i + 5 < 100 会使用到这个索引吗？

怎么看是否用到了某个索引？

数据库索引有哪几种，他们之间的区别。

like %aaa%会使用索引吗? like aaa%呢?

drop、truncate、delete的区别？

平时你们是怎么监控数据库的? 慢SQL是怎么排查的？

你们数据库是否支持emoji表情，如果不支持，如何操作?

你们的数据库单表数据量是多少？一般多大的时候开始出现查询性能急剧下降？

查询死掉了，想要找出执行的查询进程用什么命令？找出来之后一般你会干嘛？

读写分离是怎么做的？你认为中间件会怎么来操作？这样操作跟事务有什么关系？

分库分表有没有做过？线上的迁移过程是怎么样的？如何确定数据是正确的？

Mysql索引的分类(Btree, hash)，各自使用什么情况 。

说说Myisam, Innodb区别。

Linux命令

日志特别大只想看最后100行怎么弄? 如果想一直看日志的持续输出，用什么命令?

如果日志一边输出，一边想实时看到有没有某个关键字应该怎么弄？

grep如果忽略大小写应该怎么弄? 正则表达式呢？

vim往下一行是什么键？往下30行呢? 跳到文件末尾一行是什么? 跳回来是什么? 向后搜索是什么?

如果有个文本文件，按空格作为列的分隔符，如果想统计第三列里面的每个单词的出现次数应该怎么弄？

如果把上面的出现次数排个序应该怎么弄? 想按照数字本身的顺序而不是字符串的顺序排列怎么弄？

Linux环境变量是以什么作为分隔符的？环境变量通过什么命令设置？

给某个文件权设置限比如设置为644 是用什么命令？这个6是什么意思？

Linux下面如果想看某个进程的资源占用情况是怎么看的？系统load大概指的什么意思？你们线上系统load一般多少？如果一个4核机器，你认为多少load是比较正常的？top命令里面按一下1会发生什么?

top命令里面，有时候所有进程的CPU使用率加起来超过100%是怎么回事？

还有哪些查看系统性能或者供你发现问题的命令？你一般是看哪个参数？

想看某个进程打开了哪些网络连接是什么命令？里面连接的状态你比较关心哪几种？

Linux常问题

有没有做过Linux系统参数方面的优化，大概优化过什么？

系统参数里面有个叫做backlog的可以用来干什么？

查看网络连接发现好多TIME_WAIT 可能是什么原因？对你的应用会有什么影响？你会选择什么样的方式来减少这些TIME_WAIT

可否介绍一下TCP三次握手的过程，如果现在有个网络程序，你用第三方的library来发送数据，你怀疑这个library发送的数据有问题，那么怎么来验证？tcpdump导出的文件你一般是怎么分析的？

KeepAlive是用来干什么的？这样的好处是什么？

Redis

1. 缓存穿透可以介绍一下么？你认为应该如何解决这个问题
2. 你是怎么触发缓存更新的？(比如设置超时时间(被动方式), 比如更新的时候主动update)？如果是被动的方式如何控制多个入口同时触发某个缓存更新？
3. 你们用Redis来做什么？为什么不用其他的KV存储例如Memcached,Cassandra等?
4. 你们用什么Redis客户端? Redis高性能的原因大概可以讲一些?
5. 你熟悉哪些Redis的数据结构? zset是干什么的? 和set有什么区别?
6. Redis的hash, 存储和获取的具体命令叫什么名字?
7. LPOP和BLPOP的区别?
8. Redis的有一些包含SCAN关键字的命令是干嘛的? SCAN返回的数据量是固定的吗?
9. Redis中的Lua有没有使用过? 可以用来做什么? 为什么可以这么用?
10. Redis的Pipeline是用来干什么的?

去哪儿网面试题

1. mysql数据库调优。
2. sql优化。
3. like能用索引吗？
5. GC原理。
6. jvm内存结构。
7. 说一下你学过jvm 在书写代码上对你有什么帮助和提高。
8. 千万数据量的查询你会怎么做？
9. HashMap在jdk1.7和1.8的区别，为什么引入这个概念？hash碰撞怎么解决，为什么1.8要比1.7更好，好在哪？
10. 关于你的项目，如果并发很大，你会怎么改造。
11. 方法区里什么样的对象有可能被回收。
12. 线上cpu飙升100%你怎么处理。
13. 频繁FullGC怎么处理。
14. linux命令。(快速文件处理命令)
15. 伊甸区和幸存区可动态变化吗？
16. redis和memcached区别。
17. 说几个jdk命令，jmap是什么意思。
18. 如果并发很大，你对数据的正确性怎么保证。

饿了么面试题

1. http和https的区别，https原理，http2.0与1.0的区别。
2. Java的垃圾回收机制，Java文件加载机制，tomcat类加载机制，锁机制，jvm原理及线上调优，jvm内存模型。
3. 多线程，有哪些可以保持进程同步的方法，创建线程的几种方法，对i++多线程访问你会怎么做。
4. Java的设计模式，单例有什么模式，懒汉为什么加volotile，volotile的内存屏障，如何避免死锁。
5. 考虑单例模式的编写，要线程安全且内存消耗小（剑指offer原题）。
6. String、StringBuilder、StringBuffer区别；String类能被继承吗？为什么？
7. 在白纸上手写二分法排序算法（lintcode上原题）；二分查找的思想。
8. 查找单链表中倒数第k个节点的算法，手写（lintcode上原题）；最常见的排序算法你见过哪些，快排的基本思想及时间复杂度。
9. 常见的数据结构有哪些。
10. hashmap、hashcode一样，不equals怎么处理 ；hashcode实现原理，currentHashMap原理，实现细节，怎么实现同步的；类为什么要有hascode方法，是不是主要在集合类中都要实现hashcode方法；equals方法怎么实现；两个不同的对象可能有相同的hashcode值吗；常用集合有哪些。
11. tcp三次握手，四次挥手协议。
12. 架构设计一个开发性问题，设计一个Nginx管理的中间件，怎么设计。
13. 所有的类都继承与object，你用过object类的直接子类有哪些，object类常用的方法有哪些。
14. Java会出现内存泄漏吗，如果回，在哪种情况下？
15. 抽象类和接口的区别。
16. 平时怎么扩展自己的专业知识水平。

百度面试题

1. 什么是 Java 的反射机制。

2. Cookie 和 Session的区别。

3. get 和 post请求的区别。

4. IOC的优点是什么。

5. IO 和 NIO的区别，NIO优点。

6. JRE、JDK、JVM 及 JIT 之间有什么不同。

7. Hashcode 的作用。

8. 简述一致性 Hash 算法。

9. 为什么在重写 equals 方法的时候需要重写 hashCode 方法？equals与 hashCode 的异同点在哪里。

10. 为什么 Map 接口不继承 Collection 接口。

11. 说出几点 Java 中使用 Collections 的最佳实践？

12. GC是什么？为什么要有GC。

13. 什么时候会导致垃圾回收。

14. GC 有几种方式？怎么配置。

15. 什么时候一个对象会被GC？ 如何判断一个对象是否存活。

16. 垃圾回收器的基本原理是什么？

17. Serial 与 Parallel GC之间的不同之处。

18. JVM 中一次完整的 GC 流程是怎样的？ 对象如何晋升到老年代。

19. 吞吐量优先和响应优先的垃圾收集器选择。

20. 说说你知道的几种主要的jvm 参数。

21. Java中存在内存泄漏问题吗？请举例说明。

22. 什么是线程，多线程的优点是什么？以及简单说一下多线程的几种实现方式。

23. ThreadLocal 用途是什么，原理是什么，用的时候要注意什么?

24. 有T1，T2，T3三个线程，怎么确保它们按顺序执行？怎样保证T2在T1执行完后执行，T3在T2执行完后执行同步块内的线程抛出异常会发生什么？

25. 什么是乐观锁（Optimistic Locking）？如何实现乐观锁？如何避免ABA问题。

26. 什么是设计模式（Design Patterns）？你用过哪种设计模式？用在什么场合？

27. 你能写出三种单例模式实现么？

28. 你知道Google是如何在一秒内把搜索结果返回给用户？

29. 高并发下，如何做到安全的修改同一行数据？

30. 如何避免浏览器缓存。

31. 大型网站在架构上应当考虑哪些问题？

32. 最近有在看什么书么，印象最深刻的是什么？

33. 你们线上应用的 JVM 参数有哪些？

34. 能简单说下你对算法的理解么？

经验分享

如果你的技术扎实没问题，接下来的面试也决定你是否能得到认可拿到offer，列出以下几点经验，面试前提前准备好答案。

• 最好准备好1-2两个问题来应对“你有什么想问的吗？”之类的问题。
• 离职原因，不要抱怨现在和以前的雇主。
• 保持谈话的时间安排节奏顺利进行, 但不要就某个问题说过多，通过一个问题引入到下一个问题。
• 面谈的过程中面试官的问题可能会比较细，比较犀利，那是正常环节，不必紧张。
• 如果遇到不太了解问题，最好不要说模棱两可的答案。
• 沟通过程中最好保持高度的愿意性。
• 准备要充分，知识面要尽量的广，同时深度也要够。
• 面试安排上，如果不着急，尽量给自己留多时间，两天一家，及时做总结和补充。
• 简历投递方面，拉勾上投了很多经常不匹配，有一些打击自信心，如果有同样感受的，不妨换BOSS或者其他平台。避免打击自信心。