I know that both of them have thread safe methods. I want to know how they are thread safe? What is the implementation? This is a common question in all interviews.

• java

Take a look inside the code of Vector and Hashtable in OpenJDK, you'll notice that most of the public methods are synchronized, that's the implementation detail that makes the methods of both collections thread-safe. Also notice that other operations over these collections (iteration, for instance) need external synchronization for being thread-safe.

They aren't. All their methods are synchronized. It isn't the same thing. Iteration over them isn't and can't be thread-safe, unless the block enclosing the iteration is threadsafe, e.g. synchronized. So the caller still has a responsibility to provide thread-safeness. This is the reason the new classes in the Collections Framework didn't have synchronized methods by default.

The Vector class that shipped with my version of the Sun/Oracle JDK, which is 6 something, uses synchronized methods, like so

public synchronized void insertElementAt(E obj, int index) {
modCount++;
if (index > elementCount) {
    throw new ArrayIndexOutOfBoundsException(index
                         + " > " + elementCount);
}
ensureCapacityHelper(elementCount + 1);
System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
elementData[index] = obj;
elementCount++;
}

All the important methods are synchronized in such a way, right in the method signature.

Note, however, that this is not manditory. The contract only says you have to make it thread safe, it does not specify how.

These classes are conditionally thread-safe and using them is not a good style. A better option is using java.util.concurrent.* classes (e.g. ConcurrentHashMap, CopyOnWriteArrayList etc.) which are truly thread-safe and provide good performance

E.g. ConcurrentHashMap scales much better than synchronized HashMap: http://www.javamex.com/tutorials/concurrenthashmap_scalability.shtml

The problem with those two classes is that they give the impression of being thread safe by providing synchronized methods, but their internal state is modifiable by the iterators they provide you access to.

Synchronization in this only buys your thread exclusivity in executing in all the synchronized methods as they share the same synchronization lock.

It is terminology which indicate that the methods in the class are threadsafe i.e. synchronized! (A class in itself can not be Threadsafe. Its just the way of saying so.)