SyncronizingProxyFactory: Pattern or antipattern?

I'm creating several interfaces (which actually may be remote). The
implementations need to perform several operations "atomically" on one
target object.
I thought that it might be annoying to write stuff like:
    synchronized(target) { target.doOp(); target.doOp2(); }
over and over again. So I thought to borrow a concept from Aspect
Oriented Programming, and wrote myself a proxy factory.

If my interfaces extend java.rmi.Remote, does this preclude me from
using this Proxy class?
<sscce>
import java.lang.reflect.Proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.InvocationTargetException;

/**
 */
public class SynchronizingProxyFactory {
  private static class SynchronizedInvocationHandler<E> implements
InvocationHandler {
    private final E target;
    private final Object sync;

    public SynchronizedInvocationHandler(E target, Object sync) {
      this.target = target;
      this.sync = sync;
    }

    public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable{
      synchronized(sync) {
        try {
          return method.invoke(target, args);
        } catch (InvocationTargetException e) {
          throw e.getTargetException();
        }
      }
    }
  }
  public static <E> E synchronizedProxy(Class<E> iface, E target,
Object sync) {
    return (E)Proxy.newProxyInstance(iface.getClassLoader(),
        new Class[]{iface}, new
SynchronizedInvocationHandler<E>(target, sync)) ;
  }
}
</sscce>

Thanks,
Daniel.