记京东网络部的一次面试

1.@RestController与@Controller的区别

@RestController的官方解释：

A convenience annotation that is itself annotated with {@link Controller @Controller} and {@link ResponseBody @ResponseBody}。
    也就是说它相当于是两部分：一部分@Controller，一部分@ResponseBody。它被视为@RequestMapping和@ResponseBody的语义。如果配置了适当的{@code HandlerMapping}-{@code HandlerAdapter}对(这是MVC Java配置和MVC名称空间中的缺省值)，则处理{@code @RestController}。但它不支持{@code @RestController}-{@code AnnotationMethodHandlerAdapter}对，它们也是不推荐的。

@Controller的官方解释：

This annotation serves as a specialization of {@link Component @Component},allowing for implementation classes to be autodetected through classpath scanning.It is typically used in combination with annotated handler methods based on the {@link org.springframework.web.bind.annotation.RequestMapping} annotation.

该注释被当作一个专业的组件，允许通过类路径自动扫描实现类。它通常和RequestMapping绑定使用。

2.wait和sleep的区别：

sleep()是使线程暂停执行一段时间的方法。wait()也是一种使线程暂停执行的方法。例如，当线程执行wait()方法时候，会释放当前的锁，然后让出CPU，进入等待状态。并且可以调用notify（）方法或者notifyAll（）方法通知正在等待的其他线程。notify（）方法仅唤醒一个线程（等待队列中的第一个线程）并允许他去获得锁。notifyAll（）方法唤醒所有等待这个对象的线程并允许他们去竞争获得锁。具体区别如下：

1)  原理不同。sleep()方法是Thread类的静态方法，是线程用来控制自身流程的，他会使此线程暂停执行一段时间，而把执行机会让给其他线程，等到计时时间一到，此线程会自动苏醒。例如，当线程执行报时功能时，每一秒钟打印出一个时间，那么此时就需要在打印方法前面加一个sleep()方法，以便让自己每隔一秒执行一次，该过程如同闹钟一样。而wait()方法是object类的方法，用于线程间通信，这个方法会使当前拥有该对象锁的进程等待，直到其他线程调用notify（）方法或者notifyAll（）时才醒来，不过开发人员也可以给他指定一个时间，自动醒来。

2)  对锁的 处理机制不同。由于sleep()方法的主要作用是让线程暂停执行一段时间，时间一到则自动恢复，不涉及线程间的通信，因此，调用sleep()方法并不会释放锁。而wait()方法则不同，当调用wait()方法后，线程会释放掉他所占用的锁，从而使线程所在对象中的其他synchronized数据可以被其他线程使用。

3)  使用区域不同。wait()方法必须放在同步控制方法和同步代码块中使用，sleep()方法则可以放在任何地方使用。sleep()方法必须捕获异常，而wait()、notify（）、notifyAll（）不需要捕获异常。在sleep的过程中，有可能被其他对象调用他的interrupt（），产生InterruptedException。由于sleep不会释放锁标志，容易导致死锁问题的发生，因此一般情况下，推荐使用wait（）方法。

3.Look的类型

ReentrantLock：

• 公平锁/非公平锁
• 可重入锁
• 独享锁/共享锁
• 互斥锁/读写锁
• 乐观锁/悲观锁
• 分段锁
• 偏向锁/轻量级锁/重量级锁
• 自旋锁

4.CAS机制：

package Thread;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * 了解CAS机制，扫清盲点,
 *什么是CAS？
 * CAS=Compare And Swap
 * 三个基本操作数：内存地址v，旧的预期值A，要更改的新值B
 * 更新一个变量的时候，只有当预期值A和内存地址v当中的实际值相同时，才会将内存地址v对应的值修改为B。、
 *线程在提交更新值之前，会将当前的旧址与内存地址v的实际值进行比较，如果不相同，则提示提交失败，线程就会
 * 在此时进行重新获取，这个过程叫做自旋。
 * 对比synchronize，CAS是一个乐观锁机制，乐观的认为程序中的并发问题并没有太过严重。
 * 除了在Atomic类里面用到CAS，还在很多LOCK实现的底层用到CAS
 * 缺点：
 * 1.CPU开销比较大：在并发量较高的情况下，如果一个线程反复更新一个变量，而又反复更新不成功，会给CPU造成很大的压力
 * 2.不能保证代码块的原子性操作：CAS只能保证一个变量的原子性操作，而不能保证代码块的原子性操作，如果需要多个变量的
 * 共同原子性操作的更新，就不得不使用synchronize。
 * 3.ABA问题：一个变量的值从A变成了B又从B变成了A
 *          解决办法：加一个版本号在A上，如果最后提交的时候A的版本号和当前的一致，则提交成功，否则提交失败
 * CAS自旋：
 *   1.获取当前值；
 *   2.当前值加1，计算出目标值；
 *   3.进行CAS操作，如果成功跳出循环，否则重复上述操作
 *   public final int incrementAndGet() {
 *
 *          for (;;) {
 *
 *             int current = get();
 *
 *             int next = current + 1;
 *
 *             if (compareAndSet(current, next))
 *
 *                 return next;
 *
 *             }
 *
 *           }
 *
 *          private volatile int value; public final int get() {
 *
 *          return value;
 *
 *         }
 *         //关于compareAndSet的底层实现
 *         public final boolean compareAndSet(int expect,int update){
 *             return unsafe.compareAndSwapInt(this,valueOffset,expect,update);
 *         }
 *         private static final Unsafe unsafe = Unsafe.getUnsafe();
 *         private static final long valueOffset;
 *         static{
 *             try{
 *                 valueOffset = unsafe.objectFieldOffset(AtomicInteger.class.getDeclaredField("value"));
 *             }catch(Exception ex){
 *                 throw new Error(ex);
 *             }
 *         }
 *  unsafe为我们提供了硬件级别的原子操作
 *  至于valueOffset对象，是通过unsafe.objectFieldOffset方法得到，所代表的是AtomicInteger对象value
 *  成员变量在内存中的偏移量。我们可以简单地把valueOffset理解为value变量的内存地址。
 *  而unsafe的compareAndSwapInt方法参数包括了这三个基本元素：valueOffset参数代表了V，expect参数代表了A，update参数代表了B。
 *  正是unsafe的compareAndSwapInt方法保证了Compare和Swap操作之间的原子性操作。
 *
 * */
public class CASDemo {

    public static int count = 0;
    public static int count1 = 0;
    private static AtomicInteger count2 = new AtomicInteger(0);

    public static void sample(){
        /**
         * 先看一个例子,
         * 因为线程是不安全的，所以导致结果count可能会小于200
         * */
        //开启两个线程
        for(int i=0;i<2;i++){
            new Thread (
                    new Runnable() {
                        public void run() {
                            try {
                                Thread.sleep(200);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                            //每个线程当中让count值自增100次
                            for (int j = 0; j < 100; j++) {
                                count++;
                            }
                        }
                    }).start();
        }
        try{
            Thread.sleep(2000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("count="+count);
    }

    public static void sample2(){
        //给上一个例子上加上synchronize关键字
        //开启两个线程,加了同步锁之后，count1++变成了原子操作，代码实现了线程安全，结果变成200
        //但是明显感觉性能变慢了
        long start = System.currentTimeMillis();

        for(int i=0;i<2;i++){
            new Thread (
                    new Runnable() {
                        public void run() {
                            try {
                                Thread.sleep(200);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                            //每个线程当中让count值自增100次
                            for (int j = 0; j < 100; j++) {
                                synchronized (CASDemo.class){
                                    count1++;
                                }
                            }
                        }
                    }).start();
        }
        try{
            Thread.sleep(2000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();

        System.out.println("count1="+(end-start)+":"+count1);
    }

    public static void sample3(){
        //使用原子操作类,记录下时间
        //Atomic类的底层实现了CAS机制

        long start = System.currentTimeMillis();
        for(int i=0;i<2;i++){
            new Thread (
                    new Runnable() {
                        public void run() {
                            try {
                                Thread.sleep(200);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                            //每个线程当中让count值自增100次
                            for (int j = 0; j < 100; j++) {
                                count2.incrementAndGet();
                            }
                        }
                    }).start();
        }
        try{
            Thread.sleep(2000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        Long end = System.currentTimeMillis();
        System.out.println("count2="+(end-start)+":"+count2.get());
    }

    public static void main(String arg[]){
        sample();
        sample2();
        sample3();
    }

}