code: public static <K,V> Relation<K,V> synchronizedRelation(final Relation<K,V> rel) {
  	return new SynchronizedRelation<K,V>(rel); 
      }
docs: Returns a synchronized (thread-safe) relation wrapper backed by
  the given relation <code>rel</code>.  Each operation
  synchronizes on <code>rel</code>.
  
  <p>For operations that return a collection (e.g., {@link
  #keys()}, {@link #values()}), it is strongly recommended to
  synchronize the whole block that (1) invokes the
  collection-returning relation operation, and (2) uses that
  collection.  This is similar to the recommended usage pattern
  for the JDK synchronized collections (e.g.,
  <code>Collections.synchronizedSet</code>.  Here is an example:
  
  <pre>
  Relation&lt;K,V&gt; syncRel = Relation.synchronizedRelation(someRel);
  ...
  synchronized(syncRel) {
  Iterator&lt;K&gt; it = syncRel.keys().iterator();
  while(it.hasNext()) {
  K key = it.next();
  ...
  }
  }
  </pre>
  
  This pattern prevents non-deterministic, hard-to-reproduce
  behavior due to modifications from other threads on the
  relation you iterate over.