在学习集合的时候，因为JDK1.2以后的集合都是线程不同步的，之前的比如Vector都是线程同步的，效率低，但在还是建议用效率较高的新的集合进行加锁，为什么呢？

楼主的问题原理可以上网找找资料。我给你提供个例子。或许对你有帮助
Java代码  
package ThreadTest;  
  
public class ThreadTest3 {  
    public static void main(String args[]){  
        MyThread mt = new MyThread() ;    // 定义线程对象  
     
        Thread t1 = new Thread(mt) ;    // 定义Thread对象  
//        Thread t2 = new Thread(mt) ;    // 定义Thread对象  
//        Thread t3 = new Thread(mt) ;    // 定义Thread对象  
        t1.start() ;  
//        t2.start() ;  
//        t3.start() ;  
    }  
}  
  
class MyThread implements Runnable{  
    private int ticket = 5 ;    // 假设一共有5张票  
    private long start = 0;  
    public void run(){  
        sale();  
    }  
    private synchronized void sale(){  
        if (start == 0){  
            start = System.currentTimeMillis();  
        }  
         while(ticket>0){  
             try {  
                 Thread.sleep(300);  
             } catch (InterruptedException e) {  
                 // TODO Auto-generated catch block  
                 e.printStackTrace();  
             }  
             System.out.println("卖票：ticket = " + ticket-- );  
         }  
         if (ticket == 0){  
              System.out.println("cost" + (System.currentTimeMillis() - start));  
         }  
    }  
}  

cost1515

在线程同步下，使用多线程和单线程时间都在1515ms之间，多线程效率并不比单线程效率高

在线程不同步下，使用多线程时间都在906ms之间，多线程效率比单线程效率高


Java代码  
package ThreadTest;  
  
public class ThreadTest3 {  
    public static void main(String args[]){  
        MyThread mt = new MyThread() ;    // 定义线程对象  
     
        Thread t1 = new Thread(mt) ;    // 定义Thread对象  
        Thread t2 = new Thread(mt) ;    // 定义Thread对象  
        Thread t3 = new Thread(mt) ;    // 定义Thread对象  
        t1.start() ;  
        t2.start() ;  
        t3.start() ;  
    }  
}  
  
class MyThread implements Runnable{  
    private int ticket = 5 ;    // 假设一共有5张票  
    private long start = 0;  
    public void run(){  
        sale();  
    }  
//    private synchronized void sale(){  
    private void sale(){  
        if (start == 0){  
            start = System.currentTimeMillis();  
            System.out.println("cost");  
        }  
         while(ticket>0){  
             try {  
                 Thread.sleep(300);  
             } catch (InterruptedException e) {  
                 // TODO Auto-generated catch block  
                 e.printStackTrace();  
             }  
             System.out.println("卖票：ticket = " + ticket-- );  
         }  
         if (ticket <= 0){  
              System.out.println("cost" + (System.currentTimeMillis() - start));  
         }  
    }  
}  
希望对楼主有所帮助。

你之所以问这个问题其实就是因为你还没有完全理解这两个集合的特点而已，现在总结如下：

1、出现的先后

        Vector先出现，ArrayList后出现

2、是否同步

        Vector：是同步的比较安全
        ArrayList:时非同步的，在多线程中不安全


3、效率问题

        Vector:由于涉及到锁的问题，所以效率较低
        ArrayList：效率较高

综上所述，在两者使用的场合总结如下：

1、当不涉及到多线程时：

        由于不涉及到安全问题，当然选择效率较高的ArrayList了！

2、当涉及到多线程时：

        为了安全的原因可以选择使用Vector，但如果想用ArrayList的话，也可以手动加锁


所以：虽然Vector效率低，但场合不同时它还是有使用的价值的。