1.java序列化到底是什么

    序列化是一种用来处理对象流的机制 ，所谓对象流就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。

    ps:使用场景

         分布式数据传输 ， 网络传输

         根本应用场景是：

         典型应用 :

         tomcat关闭以后会把session对象序列化到SESSIONS.ser文件中，等下次启动的时候就把这些session再加载到内存里面来。

2.线程安全、线程不安全

    概念:

    线程安全就是多线程访问的时候，采用了加锁机制，当前线程访问的时候其他线程不能访问。

    线程不安全就是不提供数据访问保护，可能出现脏数据。

    如果你的程序是多线程执行，然后执行结果和预期的一致，那么就是线程安全的。

    线程安全问题都是由全局变量及静态变量引起的。

    若每个线程对全局变量，静态变量只有读，没有写操作，那么也是线程安全的。若多线程同时执行写操作，那么就需要考虑线程同步。

3.java对象锁应用

    锁，java中只要加synchronized关键字即可，可以加到方法上，也可以加到代码块中

public synchronized String get(){     return null;}  public String get(){     synchronized{        //代码;     }     return null;}

/** * 当前是多个线程用一个SyncV1对象，所以，synchronized执行过程中同一时间只能有一个拿到锁 * 因此，执行结果为  * 	test开始..	test结束..	test开始..	test结束..	test开始..	test结束.. * @author mrg * */public class SyncV1 {	public synchronized void test() {          System.out.println("test开始..");          try {              Thread.sleep(1000);          } catch (InterruptedException e) {              e.printStackTrace();          }          System.out.println("test结束..");      }      public static void main(String[] args) {      	SyncV1 sync = new SyncV1();          for (int i = 0; i < 3; i++) {         	            Thread thread = new MyThread(sync);              thread.start();          }      }  }class MyThread extends Thread {  	SyncV1 sync ;    public MyThread(SyncV1 sync) {		super();		this.sync = sync;	}	public void run() {          sync.test();      }  }

/** * 这个是每执行一次都会创建一个SyncV2 ， 而synchronized只是控制同一个对象同一时间只有一个实例能执行， * 所以结果是同时执行的。   * test2()方法，锁住的也只是一个对象，所以test()方法和test2()方法结果一致 * 因此，执行结果为  * test开始.. * test开始.. * test开始.. * test结束.. * test结束.. * test结束.. * @author mrg * */public class SyncV2 {	public synchronized void test() {          System.out.println("test开始..");          try {              Thread.sleep(1000);          } catch (InterruptedException e) {              e.printStackTrace();          }          System.out.println("test结束..");      }  	public void test2() {  		synchronized (this) {			System.out.println("test开始..");  	        try {  	            Thread.sleep(1000);  	        } catch (InterruptedException e) {  	            e.printStackTrace();  	        }  	        System.out.println("test结束..");  		}    }      public static void main(String[] args) {          for (int i = 0; i < 3; i++) {             Thread thread = new MyThreadV2();              thread.start();          }      }  }class MyThreadV2 extends Thread {  	public void run() {  		SyncV2 sync = new SyncV2();        sync.test();      }  }

/** * 解释一下test(),test2()方法 * 	这里的synchronized锁定的是一个全局的类，和static synchronized是一致的。不论有多少个对象，同一时间只有一个对象能执行方法里的代码 * 因此结果为* 	test开始..	test结束..	test开始..	test结束..	test开始..	test结束.. * @author mrg * */public class SyncV3 {	public  void test() {  		synchronized (SyncV3.class) {			System.out.println("test开始..");  			System.out.println("当前对象:"+this);	        try {  	            Thread.sleep(1000);  	        } catch (InterruptedException e) {  	            e.printStackTrace();  	        }  	        System.out.println("test结束..");  		}    }  	public static synchronized void test2() {  		System.out.println("test开始..");          try {              Thread.sleep(1000);          } catch (InterruptedException e) {              e.printStackTrace();          }          System.out.println("test结束..");      }      public static void main(String[] args) {          for (int i = 0; i < 3; i++) {             Thread thread = new MyThreadV3();              thread.start();          }      }  }class MyThreadV3 extends Thread {  	public void run() {  		SyncV3 sync = new SyncV3();        sync.test2();      }  }

  引自:http://blog.csdn.net/xiao__gui/article/details/8188833

4.对于vector的一些解释（是否安全）

    http://mt.sohu.com/it/d20170226/127307378_494942.shtml

    http://talentluke.iteye.com/blog/1496976

    http://blog.csdn.net/ghevinn/article/details/37764791