今日面试又遇到了一些题目，先记录下来
1、netty怎么处理粘包问题
netty底层走的是TCP协议，传输的是字节流，消息与消息之间是没有边界的。发生粘包的原因主要有：1)、当连续发送数据时，由于TCP协议的nagle算法，会将较小的内容拼接成较大的包一次性发送到服务器，因而导致粘包。2）、当发送的内同较大时，由于服务器的recv(buffer_size)方法中buffer_siize较小，不能一次性读完所有数据，从而导致一个消息分拆成多次读取，产生非拆包的情况。
解决粘包的方法：这个思路很简单，其实是在接收数据的时候，将字节流拆分成完整的包：1）如果当前读到的数据不是一个完整的业务数据包，则继续从TCP缓冲区中读取数据，直到读到的数据中包含完整的数据包；2）如果当前读取到的数据加上内存中已有的数据，包含一个完整的业务数据包，则将完整的业务包拼成一个包，并返回应用层处理；对于多余的数据，扔保留再内存中，待后续加载的数据合并处理。
netty中提供了一些拆包器，能满足大部分的使用场景：
1)、FixedLengthFrameDecoder：定长拆包器（固定长度的数据）
2)、LineBasedFrameDecoder：行拆包器（按照行拆分，换行符作为分隔符）
3)、DelimiterBasedFrameDecoder：基于分隔符拆包器（允许指定一个分隔符，在收到消息的时候按照指定分隔符进行拆包）
4)、LengthFieldBaseFrameDecoder：基于长度域的拆包器（协议中有一个固定的区域来表示数据长度）
2、Java多线程加锁方式
可以通过synchronized关键字加锁
也可以通过Java.util.concurrent包中的lock接口和ReentrantLock实现类
3、什么是原子类操作
原子操作是指不会被线程调度机制打断的操作；这种操作一旦开始，就一直运行到结束，中间不会有任何的context switch(切换到另一个线程)
原子操作是不可分割的，在执行完毕之前不会被任何其他的任务或事物打断。
4、Java的设计模型，请说说观察者设计模型
Java的设计模式像我们常用的有单例模式、工厂方法模式、抽象工厂模式、装饰模式、观察者模式
观察者设计模式是一对多的依赖关系，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并且自动更新。
5、Spring的AOP、IOC原理
AOP是面向切面编程，通过动态代理的方式为程序添加统一功能，集中解决一些公共问题。
AOP优点：各个步骤之间的良好隔离性耦合性大大降低；源代码无关性，再拓展功能的同时不对源码进行修改操作
IOC是控制反转。当某个角色需要另一个角色协助的时候，在传统的程序设计过程中，通常由调用者来创建被调用者的实例对象。但再Spring中创建被调用者的工作不再由调用者来完成，因此称为控制反转。创建被调用者的工作由Spring来完成，然后注入调用者直接使用
1、IOC思想基于IOC容器完成，IOC容器底层就是对象工厂
2、Spring提供IOC容器实现两种方式：（两个接口）
1）BeanFactory：IOC容器基本实现，是Spring内部的使用接口，不提供给开发人员使用
特点：加载获取配置文件的时候不会创建对象，在获取对象（使用）的时候才会创建对象
2）ApplicationContext：BeanFactory接口的子接口，提供更多更强大的功能，一般由开发人员进行使用
特点：加载获取配置文件的时候就会把配置文件中的对象进行创建
6、Java怎么处理并发，Java多线程加锁的方式
并发就是可以使用多个进程或线城，同时处理并发不同的操作
主要是用lock和synchnized
lock是一个接口，里面的方法使用：lock()、tryLock()、tryLock(long time,TimeUnit unit)、lockInterruptibly()是用来获取锁的。unlock()方法是用来释放锁的。
lock四个获取锁方法的区别：
1）lock()方法平时使用的最多的一个方法，就是用来获取锁的，如果锁已经被其他线城获取，则进行等待。如果采用lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，使用lock必须在try{]catch{}块中进行，并且将释放锁的操作放在finally块中进行，保证锁一定被释放掉，防止死锁的发生。（死锁是指两个或者两个以上的进程在执行过程中，由于竞争资源或者犹豫彼此通信而造成了一种阻塞的现象，若无外力作用，它们将无法推进下去。）
2）tryLock()方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true。如果获取失败（即锁已经被其他线城获取），则返回false，也就是说这个方法无论如何都会立即返回。拿不到锁也会返回并不会在那里一直等待
3）tryLock(long time,TimeUnit unit)方法和tryLock()方法时类似，只不过区别在于这个方法在拿不到锁时会等待一定时间，在时间限制之内如果还是拿不到锁，就返回false。如果一开始就拿到锁或者在等待期间内拿到了锁，则返回true。
4）lockinterrupibly()方法比较特殊，当通过这个方法区获取锁时，如果线程正在等待获取锁，则这个线城能够相应中断，即中断线程的等待状态。也就是说，当两个线程同时通过lock.lockinterruputibly()想获取某个锁时，假如此时线程A获取到了锁，而B线程只有等待，那么对线程调用threadB.interrupt()方法能够中断线程B的等待过程。
注意：当一个线程获取了锁之后，是不会被Interrupt()方法中断的。因此当通过lockinterruptibly()方法获取某个锁时，如果不能获取到，只有进行等待的情况下，是可以相应中断的。而使用synchronized修饰的话，当一个线程处于等待某个锁的状态，是无法被中断的，只有一直等待下去。
ReentrantLock
直接使用lock接口的话，我们需要实现很多方法，不太方便，ReentrantLock是唯一实现了Lock接口的类，并且ReentrantLock提供了很多方法。
ReentrantLock意思是可重入锁（主要是为了解决自己锁死自己的情况）
ReentrantLock也是一个接口，在它里面只定义了两个方法：
一个用来获取读锁，一个用来获取写锁。也就是说将文件的读写操作分开，分成2个锁来分配给线程，从而使得多个线程可以同时进行读操作。ReentrantReadWriteLock实现了ReadWriteLock接口。
ReentrantReadWriteLock里面提供了很多丰富的方法，不过最主要的两个方法：readlock()和writelock用来获取读锁和写锁。
注意：如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁。
如果有一个线程已经占用了读锁，则此时其他线程如果申请写锁或者读锁，则申请的线程会一直等待释放写锁。
synchronized是Java中的一个关键字，也就是说是java语言的内置特性。
如果一个代码块被synchronized修饰，当一个线程获取了对应的锁，并执行代码块时，其他线程只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁只会有两种情况：
1）获取锁的线程执行完了该代码块，然后线程释放对锁的占有
2）线程执行发生异常，此时JVM会让线程自动释放锁。
lock与synchronized的区别
1）lock不是java语言内置的，synchronized是Java语言的关键字，因此是内置特性。lock是一个类，通过这个类可以事现同步访问；
2）lock和synchronized有一个非常大的不同，采用synchronized不需要用户手动的去释放锁，当sunchronized方法或者代码块执行完毕之后，系统会自动的让线程释放对锁的占有，而lock则必须要用户去手动释放锁，如果没有主动释放锁则会导致出现死锁的现象。
lock和synchronized的选择
1）lock是一个接口，而synchronized是java的关键字，是内置的语言事现。
2）synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现场产生；而lock在发生异常时，如果没有主动通过unlock()去释放锁，则很可能造成死锁现象，因此使用lock()时需要在finally块中释放锁。
3）lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能响应中断。
4）通过lock可以知道有没有成功获取锁，synchronized办不到
5）lock可以提高多个线程进行读操作的效率
在性能上来说，如果竞争不激烈，两者的行能是差不多的，而竞争资源非常激烈时（既有大量线程同时竞争），此时lock性能要远远优于synchronized。所以说，在具体使用时根据当时情况选择。
