CODEWITHSUNDEEP
javavectorarraylistcollections
user3839347
user3839347

Reputation: 139

ArrayList vs Vector performance in single-threaded application

I was just looking for the answer for the question why ArrayList is faster than Vector and i found ArrayList is faster as it is not synchronized. so my doubt is:

  1. If ArrayList is not synchronized why would we use it in multithreaded environment and compare it with Vector.

  2. If we are in a single threaded environment then how the performance of the Vector decreases as there is no Synchronization going on as we are dealing with a single thread.

Why should we compare the performance considering the above points ?

Please guide me :)

Upvotes: 3

Views: 1378

Answers (4)

Peter Lawrey
Peter Lawrey

Reputation: 533660

Just because a component is single threaded doesn't mean that it cannot be used in a thread safe context. Your application may have it's own locking in which case additional locking is redundant work.

Conversely, just because a component is thread safe, it doesn't mean that you cannot use it in an unsafe manner. Typically thread safety extends to a single operation. E.g. if you take an Iterator and call next() on a collection this is two operations and they are no longer thread safe when used in combination. You still have to use locking for Vector. Another simple example is

private Vector<Integer> vec = 

vec.add(1);
int n = vec.remove(vec.size());
assert n == 1;

This is atleast three operations however the number of things which can go wrong are much more than you might suppose. This is why you end up doing your own locking and why the locking inside Vector might be redundant, even unwanted.

For you own interest;

  • vec can change at any point t another Vector or null
  • vec.add(2) can happen between any operation, changing the size and the last element.
  • vec.remove() can happen between any operation.
  • vec.add(null) can happen between any operation resulting in a possible NullPointerException

The vec can /* change */ in these places.

private Vector<Integer> vec = 

vec.add(1); /* change*/
int n = vec.remove(vec.size() /* change*/);
assert n == 1;

In short, assuming that just because you used a thread safe collection your code is now thread safe is a big assumption.

A common pattern which breaks is

for(int n : vec) {
   // do something.
}

Look harmless enough except

for(Iterator iter = vec.iterator(); /* change */ vec.hasNext(); ) {
   /* change */ int n = vec.next();

I have marked with /* change */ where another thread could change the collection meaning this loop can get a ConcurrentModificationException (but might not)

there is no Synchronization

The JVM doesn't know there is no need for synchronization and so it still has to do something. It has an optimisation to reduce the cost of uncontended locks, but it still has to do work.

Upvotes: 1

Evgeniy Dorofeev
Evgeniy Dorofeev

Reputation: 136062

  1. a) Methods using ArrayList in a multithreaded program may be synchronized.

    class X {

    List l = new ArrayList();

synchronized void add(Object e) {
    l.add(e);
}
...

    b) We can use ArrayList without exposing it to other threads, this is when ArrayList is referenced only from local variables

    void x() { List l = new ArrayList(); // no other thread except current can access l ...

  2. Even in a single threaded environment entering a synchronized method takes a lock, this is where we lose performance

    public synchronized boolean add(E e) { // current thread will take a lock here
    modCount++;

    ...

Upvotes: 3

Pavan Kumar K
Pavan Kumar K

Reputation: 1376

You need to understand the basic concept to know answer for your above questions...

When you say array list is not syncronized and vector is, we mean that the methods in those classes (like add(), get(), remove() etc...) are synchronized in vector class and not in array list class. These methods will act upon tha data being stored .

So, the data saved in vector class cannot be edited / read parallely as add, get, remove metods are synchornized and the same in array list can be done parallely as these methods in array list are not synchronized...

This parallel activity makes array list fast and vector slow... This behavior remains same though you use them in either multithreaded (or) single threaded enviornment...

Hope this answers your question...

Upvotes: 0

Davide Lorenzo MARINO
Davide Lorenzo MARINO

Reputation: 26926

You can use ArrayList in a multithread environment if the list is not shared between threads.

If the list is shared between threads you can synchronize the access to that list.

Otherwise you can use Collections.synchronizedList() to get a List that can be used thread safely.

Vector is an old implementation of a synchronized List that is no longer used because the internal implementation basically synchronize every method. Generally you want to synchronize a sequence of operations. Otherwyse you can throw a ConcurrentModificationException when iterating the list another thread modify it. In addition synchronize every method is not good from a performance point of view.

In addition also in a single thread environment accessing a synchronized method needs to perform some operations, so also in a single thread application Vector is not a good solution.

Upvotes: 1

Related Questions