java基础知识篇

1.java序列化究竟是什么

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

    ps:使用场景

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

         根本应用场景是：
           1.当对象须要被网络传输时
           2.对象状态须要被持久化时

         典型应用 :

         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