1、springmvc运行原理

 

相关接口解释

DispatcherServlet接口： Spring提供的前端控制器，所有的请求都有经过它来统一分发。在DispatcherServlet将请求分发给Spring Controller之前，需要借助于Spring提供的HandlerMapping定位到具体的Controller。

HandlerMapping接口： 能够完成客户请求到Controller映射。

Controller接口： 需要为并发用户处理上述请求，因此实现Controller接口时，必须保证线程安全并且可重用。 Controller将处理用户请求，这和Struts Action扮演的角色是一致的。一旦Controller处理完用户请求，则返回ModelAndView对象给DispatcherServlet前端控制器，ModelAndView中包含了模型（Model）和视图（View）。 从宏观角度考虑，DispatcherServlet是整个Web应用的控制器；从微观考虑，Controller是单个Http请求处理过程中的控制器，而ModelAndView是Http请求过程中返回的模型（Model）和视图（View）。

ViewResolver接口： Spring提供的视图解析器（ViewResolver）在Web应用中查找View对象，从而将相应结果渲染给客户。

 SpringMVC运行原理 

1. 客户端请求提交到DispatcherServlet 

2. 由DispatcherServlet控制器查询一个或多个HandlerMapping，找到处理请求的Controller 

3. DispatcherServlet将请求提交到Controller 

4. Controller调用业务逻辑处理后，返回ModelAndView 

5. DispatcherServlet查询一个或多个ViewResoler视图解析器，找到ModelAndView指定的视图 

6. 视图负责将结果显示到客户端 DispatcherServlet是整个Spring MVC的核心。它负责接收HTTP请求组织协调Spring MVC的各个组成部分。

其主要工作有以下三项：

 1. 截获符合特定格式的URL请求。 

2. 初始化DispatcherServlet上下文对应的WebApplicationContext，并将其与业务层、持久化层的WebApplicationContext建立关联。 

3. 初始化Spring MVC的各个组成组件，并装配到DispatcherServlet中。

 

2、写了个sql

3、单例模式

什么是单例模式？

单例模式视为了避免重复生成同一个实例对象，而产生的一种模式。因为对象在内存中占据空间较大，相比而言，我们更希望对于相同的对象，不必要每次都新建同样的对象。多个变量指向同一个对象。这样可以节省内存开销。

    单例模式可以分为懒汉式和饿汉式：

　　　　懒汉式单例模式：在类加载时不初始化。

　　　　饿汉式单例模式：在类加载时就完成了初始化，所以类加载比较慢，但获取对象的速度快

第一种（懒汉，线程不安全）:

public class SingletonDemo1 {

    private static SingletonDemo1 instance;

    private SingletonDemo1(){}

    public static SingletonDemo1 getInstance(){

        if (instance == null) {

            instance = new SingletonDemo1();

        }

        return instance;

    }

}

这种写法lazy loading很明显，但是致命的是在多线程不能正常工作。　

    第二种（懒汉，线程安全）：

public class SingletonDemo2 {

    private static SingletonDemo2 instance;

    private SingletonDemo2(){}

    public static synchronized SingletonDemo2 getInstance(){

        if (instance == null) {

            instance = new SingletonDemo2();

        }

        return instance;

    }

}

这种写法在getInstance()方法中加入了synchronized锁。能够在多线程中很好的工作，而且看起来它也具备很好的lazy loading，但是效率很低（因为锁），并且大多数情况下不需要同步。

 第三种（饿汉）：

public class SingletonDemo3 {

    private static SingletonDemo3 instance = new SingletonDemo3();

    private SingletonDemo3(){}

    public static SingletonDemo3 getInstance(){

        return instance;

    }

}

这种方式基于classloder机制避免了多线程的同步问题，不过，instance在类装载时就实例化，这时候初始化instance显然没有达到lazy loading的效果。

第四种（静态内部类）：

public class SingletonDemo5 {

    private static class SingletonHolder{

        private static final SingletonDemo5 instance = new SingletonDemo5();

    }

    private SingletonDemo5(){}

    public static final SingletonDemo5 getInsatance(){

        return SingletonHolder.instance;

    }

}

这种方式同样利用了classloder的机制来保证初始化instance时只有一个线程，它跟第三种和第四种方式不同的是（很细微的差别）：第三种和第四种方式是只要Singleton类被装载了，那么instance就会被实例化（没有达到lazy loading效果），而这种方式是Singleton类被装载了，instance不一定被初始化。因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载SingletonHolder类，从而实例化instance。想象一下，如果实例化instance很消耗资源，我想让他延迟加载，另外一方面，我不希望在Singleton类加载时就实例化，因为我不能确保Singleton类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化instance显然是不合适的。这个时候，这种方式相比第三和第四种方法就显得更合理。

4、单例模式的应用

使用场景：

1任务管理器就是很典型的单例模式（这个很熟悉吧），想想看，是不是呢，你能打开两个windows task manager吗？

2（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。

3. 网站的计数器，一般也是采用单例模式实现，否则难以同步。

4. 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。数据库软件系统中使用数据库连接池，主要是节省打开或者关闭数据库连接所引起的效率损耗，这种效率上的损耗还是非常昂贵的，因为何用单例模式来维护，就可以大大降低这种损耗。

5. 多线程的线程池的设计一般也是采用单例模式，这是由于线程池要方便对池中的线程进行控制。

。。。。。

 

5、collection和collections的区别

1、java.util.Collection 是一个集合接口（集合类的一个顶级接口）。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式，其直接继承接口有List与Set。

 Collection   

├List   

│├LinkedList   

│├ArrayList   

│└Vector   

│　└Stack   

└Set

2、Collections则是集合类的一个工具类/帮助类，其中提供了一系列静态方法，用于对集合中元素进行排序、搜索以及线程安全等各种操作。

1) 排序(Sort)

使用sort方法可以根据元素的自然顺序 对指定列表按升序进行排序。列表中的所有元素都必须实现 Comparable 接口。此列表内的所有元素都必须是使用指定比较器可相互比较的

List<Integer> list = new ArrayList<Integer>();

        int array[] = {112, 111, 23, 456, 231 };

        for (int i = 0; i < array.length; i++) {

            list.add(array[i]);

        }

        Collections.sort(list);

        for (int i = 0; i < array.length; i++) {

            System.out.println(list.get(i));

        }

结果：23  111  112  231  456

2) 混排（Shuffling）

混排算法所做的正好与 sort 相反: 它打乱在一个 List 中可能有的任何排列的踪迹。也就是说，基于随机源的输入重排该 List, 这样的排列具有相同的可能性（假设随机源是公正的）。这个算法在实现一个碰运气的游戏中是非常有用的。例如，它可被用来混排代表一副牌的 Card 对象的一个 List 。另外，在生成测试案例时，它也是十分有用的。

Collections.Shuffling(list)

3) 反转(Reverse)

使用Reverse方法可以根据元素的自然顺序 对指定列表按降序进行排序。

Collections.reverse(list)

4) 替换所以的元素(Fill)

使用指定元素替换指定列表中的所有元素。

Collections.fill(li,"aaa");

5) 拷贝(Copy)

用两个参数，一个目标 List 和一个源 List, 将源的元素拷贝到目标，并覆盖它的内容。目标 List 至少与源一样长。如果它更长，则在目标 List 中的剩余元素不受影响。

Collections.copy(list,li): 后面一个参数是目标列表 ,前一个是源列表

6) 返回Collections中最小元素(min)

根据指定比较器产生的顺序，返回给定 collection 的最小元素。collection 中的所有元素都必须是通过指定比较器可相互比较的

Collections.min(list)

7) 返回Collections中最小元素(max)

根据指定比较器产生的顺序，返回给定 collection 的最大元素。collection 中的所有元素都必须是通过指定比较器可相互比较的

Collections.max(list)

8) lastIndexOfSubList

返回指定源列表中最后一次出现指定目标列表的起始位置

int count = Collections.lastIndexOfSubList(list,li);

9) IndexOfSubList

返回指定源列表中第一次出现指定目标列表的起始位置

int count = Collections.indexOfSubList(list,li);

10) Rotate

根据指定的距离循环移动指定列表中的元素

Collections.rotate(list,-1);

如果是负数，则正向移动，正数则方向移动

6、synchorized的用法和threadlocal的区别

   synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：

1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；

2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；

3. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；

4. 修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

修饰一个方法

 

Synchronized修饰一个方法很简单，就是在方法的前面加synchronized，public synchronized void method(){//todo}; synchronized修饰方法和修饰一个代码块类似，只是作用范围不一样，修饰代码块是大括号括起来的范围，而修饰方法范围是整个函数。如将【Demo1】中的run方法改成如下的方式，实现的效果一样。

 

*【Demo4】：synchronized修饰一个方法

 

public synchronized void run() {

   for (int i = 0; i < 5; i ++) {

      try {

         System.out.println(Thread.currentThread().getName() + ":" + (count++));

         Thread.sleep(100);

      } catch (InterruptedException e) {

         e.printStackTrace();

      }

   }

}

Synchronized作用于整个方法的写法。

写法一：

 

public synchronized void method()

{

   // todo

}

写法二：

 

public void method()

{

   synchronized(this) {

      // todo

   }

}

写法一修饰的是一个方法，写法二修饰的是一个代码块，但写法一与写法二是等价的，都是锁定了整个方法时的内容

在用synchronized修饰方法时要注意以下几点： 
1. synchronized关键字不能继承。 

在定义接口方法时不能使用synchronized关键字。

构造方法不能使用synchronized关键字，但可以使用synchronized代码块来进行同步。 

总结：

A. 无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。

B. 每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。

C. 实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。

 

volatile、ThreadLocal、synchronized等3个关键字区别

1.volatile

volatile主要是用来在多线程中同步变量。

在一般情况下，为了提升性能，每个线程在运行时都会将主内存中的变量保存一份在自己的内存中作为变量副本，但是这样就很容易出现多个线程中保存的副本变量不一致，或与主内存的中的变量值不一致的情况。

而当一个变量被volatile修饰后，该变量就不能被缓存到线程的内存中，它会告诉编译器不要进行任何移出读取和写入操作的优化，换句话说就是不允许有不同于“主”内存区域的变量拷贝，所以当该变量有变化时，所有调用该变量的线程都会获得相同的值，这就确保了该变量在应用中的可视性(当一个任务做出了修改在应用中必须是可视的)，同时性能也相应的降低了(还是比synchronized高)。

但需要注意volatile只能确保操作的是同一块内存，并不能保证操作的原子性。所以volatile一般用于声明简单类型变量，使得这些变量具有原子性，即一些简单的赋值与返回操作将被确保不中断。但是当该变量的值由自身的上一个决定时，volatile的作用就将失效，这是由volatile关键字的性质所决定的。

所以在volatile时一定要谨慎，千万不要以为用volatile修饰后该变量的所有操作都是原子操作，不再需要synchronized关键字了。

2.ThreadLocal

首先ThreadLocal和本地线程没有一毛钱关系，更不是一个特殊的Thread，它只是一个线程的局部变量(其实就是一个Map),ThreadLocal会为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。这样做其实就是以空间换时间的方式(与synchronized相反)，以耗费内存为代价，单大大减少了线程同步(如synchronized)所带来性能消耗以及减少了线程并发控制的复杂度。

个人觉得比较典型的例子就是在Android关于Looper的源码中对ThreadLocal的使用，同时也包含了ThreadLocal的基本用法，具体代码如下：

但需要注意的是，虽然ThreadLocal和Synchonized都用于解决多线程并发访问，ThreadLocal与synchronized还是有本质的区别。synchronized是利用锁的机制，使变量或代码块在某一时该只能被一个线程访问。而ThreadLocal为每一个线程都提供了变量的副本，使得每个线程在某一时间访问到的并不是同一个对象，这样就隔离了多个线程对数据的数据共享。而Synchronized却正好相反，它用于在多个线程间通信时能够获得数据共享。即Synchronized用于线程间的数据共享，而ThreadLocal则用于线程间的数据隔离。所以ThreadLocal并不能代替synchronized，Synchronized的功能范围更广(同步机制)。

3.synchronized

synchronized关键字是Java利用锁的机制自动实现的，一般有同步方法和同步代码块两种使用方式。Java中所有的对象都自动含有单一的锁(也称为监视器)，当在对象上调用其任意的synchronized方法时，此对象被加锁(一个任务可以多次获得对象的锁，计数会递增)，同时在线程从该方法返回之前，该对象内其他所有要调用类中被标记为synchronized的方法的线程都会被阻塞。当然针对每个类也有一个锁(作为类的Class对象的一部分)，所以你懂的^.^。
最后需要注意的是synchronized是同步机制中最安全的一种方式，其他的任何方式都是有风险的，当然付出的代价也是最大的。

创建线程的两种方法

 

创建线程的两种方法：

 

1、继承Thread类，并重写Thread类的run方法

 

2、实现接口Runnable的run方法。

 

　　注意:另外还有一种创建线程的方法笔者没有指出，使用线程池方式—Callable接口。Callable接口实现类,call方法可抛出异常、返回线程任务执行完毕后的结果。

 

　　面试问题：Thread类直接调用run()和调用start()方法的区别是什么呢？

 

　　　　答：Thread的start()方法才能创建一个新的线程。如果直接调用run()方法，相当于直接调用一个类中的方法，不会创建一个新的线程。

 

1.5 创建线程方式一继承Thread类

创建线程的步骤：

1 定义一个类继承Thread。

2 重写run方法。

3 创建子类对象，就是创建线程对象。

4 调用start方法，开启线程并让线程执行，同时还会告诉jvm去调用run方法。

l 测试类

 

复制代码

 1 public class Demo01 {

 2     public static void main(String[] args) {

 3         //创建自定义线程对象

 4         MyThread mt = new MyThread("新的线程！");

 5         //开启新线程

 6         mt.start();

 7         //在主方法中执行for循环

 8         for (int i = 0; i < 10; i++) {

 9             System.out.println("main线程！"+i);

10         }

11     }

12 }

复制代码

l 自定义线程类

 

复制代码

public class MyThread extends Thread {

    //定义指定线程名称的构造方法

    public MyThread(String name) {

        //调用父类的String参数的构造方法，指定线程的名称

        super(name);

    }

    /**

     * 重写run方法，完成该线程执行的逻辑

     */

    @Override

    public void run() {

        for (int i = 0; i < 10; i++) {

            System.out.println(getName()+"：正在执行！"+i);

        }

    }

}

复制代码

思考：线程对象调用 run方法和调用start方法区别？
线程对象调用run方法不开启线程。仅是对象调用方法。线程对象调用start开启线程，并让jvm调用run方法在开启的线程中执行。
1.5.1 继承Thread类原理
我们为什么要继承Thread类，并调用其的start方法才能开启线程呢？
继承Thread类：因为Thread类用来描述线程，具备线程应该有功能。那为什么不直接创建Thread类的对象呢？如下代码：
Thread t1 = new Thread();
t1.start();//这样做没有错，但是该start调用的是Thread类中的run方法，而这个run方法没有做什么事情，更重要的是这个run方法中并没有定义我们需要让线程执行的代码。

创建线程的目的是什么？
是为了建立程序单独的执行路径，让多部分代码实现同时执行。也就是说线程创建并执行需要给定线程要执行的任务。
对于之前所讲的主线程，它的任务定义在main函数中。自定义线程需要执行的任务都定义在run方法中。
Thread类run方法中的任务并不是我们所需要的，只有重写这个run方法。既然Thread类已经定义了线程任务的编写位置（run方法），那么只要在编写位置（run方法）中定义任务代码即可。所以进行了重写run方法动作。
1.5.2 多线程的内存图解
多线程执行时，到底在内存中是如何运行的呢？
以上个程序为例，进行图解说明：
多线程执行时，在栈内存中，其实每一个执行线程都有一片自己所属的栈内存空间。进行方法的压栈和弹栈。

当执行线程的任务结束了，线程自动在栈内存中释放了。但是当所有的执行线程都结束了，那么进程就结束了。
1.5.3 获取线程名称
开启的线程都会有自己的独立运行栈内存，那么这些运行的线程的名字是什么呢？该如何获取呢？既然是线程的名字，按照面向对象的特点，是哪个对象的属性和谁的功能，那么我们就去找那个对象就可以了。查阅Thread类的API文档发现有个方法是获取当前正在运行的线程对象。还有个方法是获取当前线程对象的名称。既然找到了，我们就可以试试。

l Thread.currentThread()获取当前线程对象
l Thread.currentThread().getName();获取当前线程对象的名称

 

class MyThread extends Thread {  //继承Thread

    MyThread(String name){

        super(name);

    }

    //复写其中的run方法

    public void run(){

        for (int i=1;i<=20 ;i++ ){

            System.out.println(Thread.currentThread().getName()+",i="+i);

        }

    }

}

class ThreadDemo {

    public static void main(String[] args)     {

        //创建两个线程任务

        MyThread d = new MyThread();

        MyThread d2 = new MyThread();

        d.run();//没有开启新线程, 在主线程调用run方法

        d2.start();//开启一个新线程，新线程调用run方法

    }

}通过结果观察，原来主线程的名称：main；自定义的线程：Thread-0，线程多个时，数字顺延。如Thread-1......
进行多线程编程时，不要忘记了Java程序运行是从主线程开始，main方法就是主线程的线程执行内容。
1.6 创建线程方式—实现Runnable接口
创建线程的另一种方法是声明实现 Runnable 接口的类。该类然后实现 run 方法。然后创建Runnable的子类对象，传入到某个线程的构造方法中，开启线程。
为何要实现Runnable接口，Runable是啥玩意呢？继续API搜索。
查看Runnable接口说明文档：Runnable接口用来指定每个线程要执行的任务。包含了一个 run 的无参数抽象方法，需要由接口实现类重写该方法。

l 接口中的方法

l Thread类构造方法

创建线程的步骤。
1、定义类实现Runnable接口。
2、覆盖接口中的run方法。。
3、创建Thread类的对象
4、将Runnable接口的子类对象作为参数传递给Thread类的构造函数。
5、调用Thread类的start方法开启线程。
l 代码演示：

public class Demo02 {

    public static void main(String[] args) {

        //创建线程执行目标类对象

        Runnable runn = new MyRunnable();

        //将Runnable接口的子类对象作为参数传递给Thread类的构造函数

        Thread thread = new Thread(runn);

        Thread thread2 = new Thread(runn);

        //开启线程

        thread.start();

        thread2.start();

        for (int i = 0; i < 10; i++) {

            System.out.println("main线程：正在执行！"+i);

        }

    }

}

public class MyRunnable implements Runnable{

 

    //定义线程要执行的run方法逻辑

    @Override

    public void run() {

        

        for (int i = 0; i < 10; i++) {

            System.out.println("我的线程：正在执行！"+i);

        }

    }

} 

1.6.1 实现Runnable的原理
为什么需要定一个类去实现Runnable接口呢？继承Thread类和实现Runnable接口有啥区别呢？
实现Runnable接口，避免了继承Thread类的单继承局限性。覆盖Runnable接口中的run方法，将线程任务代码定义到run方法中。
创建Thread类的对象，只有创建Thread类的对象才可以创建线程。线程任务已被封装到Runnable接口的run方法中，而这个run方法所属于Runnable接口的子类对象，所以将这个子类对象作为参数传递给Thread的构造函数，这样，线程对象创建时就可以明确要运行的线程的任务。
1.6.2 实现Runnable的好处
第二种方式实现Runnable接口避免了单继承的局限性，所以较为常用。实现Runnable接口的方式，更加的符合面向对象，线程分为两部分，一部分线程对象，一部分线程任务。继承Thread类，线程对象和线程任务耦合在一起。一旦创建Thread类的子类对象，既是线程对象，有又有线程任务。实现runnable接口，将线程任务单独分离出来封装成对象，类型就是Runnable接口类型。Runnable接口对线程对象和线程任务进行解耦。