13. servlet运行机理
  Servlet是java引入的在B/S架构中用来处理动态网页的一种技术，其实质是一个继承了HttpServlet的java类，由web容器负责解释运行，其机理如下：
（第一次被请求）
客户提出请求 -> web容器解析请求，找出请求的url，根据web.xml配置找到对应的servlet -> 加载servlet -> 实例化 -> 调用init初始化 -> 调用service方法 -> 由service方法自动匹配doXXX方法-> web容器关闭/servlet长时间没有被请求则调用其destroy方法销毁servlet实例

不确定的地方:  servlet多长时间没有被调用才会销毁，可以设置吗？ 不同的web服务器应该是不同的吧

14. servlet 和 jsp 的区别
都是用来处理动态网页的技术，jsp被编译后转化为servlet, 一个jsp页面本质上也是一个servlet；jsp在第一次被请求后，先转化为servlet，再编译，所以第一次要比servlet慢
Servlet是在java代码中嵌入HTML， 擅长逻辑控制
Jsp是在HTML中嵌入java代码, 擅长页面处理

15. forward(请求转发)与redirect(重定向)的区别
( Forward是服务器端请求，是servlet提供的一种技术，服务器根据请求的url找到请求的页面，对浏览器而言，这一过程是不透明的，好像什么也没发生一样，浏览器的地址栏不会显示被请求的url页面地址（显示的仍是上次请求的服务器端的url地址），从HTTP协议的角度，只发生一次的请求响应过程
Redirect是客户端的请求，客户端根据服务器传回的地址，重新向服务器发出请求，浏览器的地址栏显示的是新请求的url地址， 从http协议的角度，发生了两次请求响应的过程 )
-------------------
1. 重定向是HTTP协议定义的功能，要经过两次HTTP通信过程，第一次用于获取资源的实际地址，第二次用之前得到的地址发出请求， 这个过程对浏览器是可见的；
    请求转发是servlet技术本身的特点，转发的过程是在服务器内部进行，对浏览器是不透明的，它认为它所发送的地址实际上得到的就是这些内容； 从HTTP角度看，只有一次通讯过程

2. 重定向只能转向新的资源，功能较单一；  请求转发不但可以转向新的资源，也可将其它资源和本身的生成的内容结合起来，功能很丰富

3. 重定向适用范围广，因为它是HTTP协议定义的，不但可以重定向统一web程序的其它资源，也可以重定向到其它web程序甚至其它网站；  而请求转发是servlet本身的一种机制，通常只在同一web程序内部转发，从而使它的可用范围受到限制。

16. 线程

1.线程的同步
  同步的概念： 当多个线程同时使用一个对象时，由于线程本身运行的不确定性，可能会造成操作的不完整性，故而引入同步
  java中同步的方式有两种， Synchronized 和 lock
  当一个线程进入一个对象的同步方法后，它会把该对象锁住，其它的线程不能再使用该对象（当然包括对象的任何方法，属性），直到持有线程锁的对象释放掉锁，其它线程才有机会使用该对象
  一个线程释放同步锁的条件：
a. 正常运行完
b. 使用wait()方法
  同步中的方法： wait(), notify()/notifyAll()，用于同步中的线程通讯
  Wait（）： 释放持有的同步锁，本身进入锁等待状态，在线程中因为多个线程“同时“运作，可能导致运作的条件不满足，当条件不满足时，线程本身就需要进入等待状态（释放掉锁），等其它的线程改变了条件，它才能有机会继续执行
  NotifyAll(): 唤醒锁等待的线程，当一个持有线程锁的对象调用该方法后，其它处于锁等待的线程虽然被唤醒，但其本身不会立刻释放掉锁，需要等运行结束后（退出synchronized块）才释放掉，其它线程才有机会执行
举几个例子：
//线程同步
class SyncStack{ //同步堆栈类
　　　private int index = 0; //堆栈指针初始值为0
　　　private char []buffer = new char[6]; //堆栈有6个字符的空间

　　　public synchronized void push(char c){ //加上互斥锁
　　　　　while(index = = buffer.length){ //堆栈已满，不能压栈
　　　　　try{
　　　　　　　　this.wait(); //等待，直到有数据出栈
　　　　　　　}catch(InterruptedException e){}
　　　　　　　}
　　　this.notify(); //通知其它线程把数据出栈
　　　buffer[index] = c; //数据入栈
　　　index++; //指针向上移动
　　　}
　　　public synchronized char pop(){ //加上互斥锁
　　　　　　　while(index ==0){ //堆栈无数据，不能出栈
　　　　　　　　try{
　　　　　　　　　　　this.wait(); //等待其它线程把数据入栈
　　　　　　　　}catch(InterruptedException e){}
　　　　　　　　　　}
　　　　　　　this.notify(); //通知其它线程入栈
　　　　　　　index- -; //指针向下移动
　　　　　　　return buffer[index]; //数据出栈
　　　　}
　　　　　　　}
　　　　class Producer implements Runnable{ //生产者类
　　　　　　　SyncStack theStack;
　　　　　　　　//生产者类生成的字母都保存到同步堆栈中

　　　　　　　public Producer(SyncStack s){
　　　　　　　　　　theStack = s;
　　　　　　　}
　　　　　　　public void run(){
　　　　　　　　　　char c;
　　　　　　　　　　for(int i=0; i <20; i++){
　　　　　　　　　　　　c =(char)(Math.random()*26+'A');
　　　　　　　　　　　　　　　　　　　　　　　　　　//随机产生20个字符
　　　　　　　　　　　　theStack.push(c); //把字符入栈
　　　　　　　　　　　　System.out.println("Produced: "+c); //打印字符
　　　　　　　　　　　　try{
　　　　　　　　　　　　Thread.sleep((int)(Math.random()*1000));
　　　　　　　　　　　　　　　　　　　　　/*每产生一个字符线程就睡眠*/
　　　　　　　　　　　　}catch(InterruptedException e){}
　　　　　　　　　　}
　　　　　　　}
　　　　　}
　　　　　class Consumer implements Runnable{ //消费者类
　　　　　　　　　SyncStack theStack;
　　　　　　　　　　　　　　　　　　//消费者类获得的字符都来自同步堆栈

　　　　　　　　　public Consumer(SyncStack s){
　　　　　　　　　　　　　theStack = s;
　　　　　　　　　}
　　　　　　　　　public void run(){
　　　　　　　　　　　　　char c;
　　　　　　　　　　　　　for(int i=0;i <20;i++){
　　　　　　　　　　　　　　　c = theStack.pop(); //从堆栈中读取字符
　　　　　　　　　　　　　System.out.println("Consumed: "+c);
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　//打印字符
　　　　　　　　　　　　　try{
　　　　　　　　　　　　　Thread.sleep((int)(Math.random()*1000));
　　　　　　　　　　　　　　　　　　　　/*每读取一个字符线程就睡眠*/
　　　　　　　　　　　　　}catch(InterruptedException e){}
　　　　　　　　　}
　　　　　　　}
　　　　　}
　　　　　public class SyncTest{
　　　　　　　public static void main(String args[]){
　　　　　　　　　SyncStack stack = new SyncStack();
　　　//下面的消费者类对象和生产者类对象所操作的是同一个同步堆栈对象
　　　　　　　　　Runnable source=new Producer(stack);
　　　　　　　　　Runnable sink = new Consumer(stack);
　　　　　　　　　Thread t1 = new Thread(source); //线程实例化
　　　　　　　　　Thread t2 = new Thread(sink); //线程实例化
　　　　　　　　　t1.start(); //线程启动
　　　　　　　　　t2.start(); //线程启动
　　　　　　　}
　　　　　}
//下面的代码在绝大部分时间内都运行得很正常，请问在什么情况下会出现问题？问题的根源在哪里？
    import java.util.LinkedList;
    public class Stack {
        LinkedList list = new LinkedList();
        public synchronized void push(Object x) {
            synchronized(list) { 
                list.addLast( x );
                notify();
            }
        }

        public synchronized Object pop()
            throws Exception { 
            synchronized(list) { 
                if( list.size() <= 0 ) {
                    wait();
                }
                return list.removeLast();
            }
        }
    }

//可能死锁的线程
public class SyncTest{
    public static void main(String[] args) {
        final StringBuffer s1= new StringBuffer();
        final StringBuffer s2= new StringBuffer();
        new Thread (){
            public void run() {
                synchronized(s1) {
                    s2.append("A");
                    synchronized(s2) {
                        s2.append("B");
                        System.out.print(s1);
                        System.out.print(s2);
                    }
                }
          }
      }.start();

      new Thread() {
          public void run() {
              synchronized(s2) {
                  s2.append("C");
                  synchronized(s1) {
                      s1.append("D");
                      System.out.print(s2);
                      System.out.print(s1);
                    }
                }
            }
      }.start();
  }
}