Obviate synchronization via read-only Interfaces?

Question

is this an acceptable way to share Collections across Threads :
public Interface BalanceBookInspector {
  public double getLargestUnpaidBill();
public class BalanceBook extends HashMap implements BalanceBookInspector {
  public double getLargestUnpaidBill() { .... }
public class ClassA {
  public static void main(String[] args) {
    BalanceBook bb = new BalanaceBook();
    Thread t1 = new Thread1((BalanceBook) bb);
    Thread t2 = new Thread2((BalanceBookInspector) bb);
t1 perform inserts / deletes / updates.
t2 is restricted to only read access via the BalanceBookInspector interface.
so, is that a thread-safe thing to do??
(it has worked ok so far).
btw: what i really want is a Map that:
(1) extends HashMap
(2) is a Collections.synchronizedMap()
i don't know the syntax and/or if its possible.

Answer 1

this is my best understanding of what's going on:
bb = new BalanaceBook()
bb points to an area in memory of the size of BalanceBook [not in synchronized wrapper]
bb view of that memory is BalanceBook .
HashMap hash = Collections.synchronizedMap(bb)
hash points to the area in memory that is also pointed to by bb (not a new object)
hash 's view of the memory is Map .
[but is that area in memory now in a synchronized wrapper? i have no idea]
Thread t1 = new Thread1(hash);
t1 is given the pointer hash .
Thread t2 = new Thread2((BalanceBookInspector) bb);
t2 is given the pointer bb that has had its view of the shared memory location
stripped down to the BalanceBookInspector interface.
pubilc class BalanceBook implements BalanceBookInspector {
}so, i really don't know whats going on there.
it sure feels like that the Collections.synchronizedMap() wrapper should be applied when
the Map memory is allocated...?