Threaded SmartPtr questions

Dear C++ Users,

I am studying Modern C++ design and I simplified a threaded smart
pointer implementation as following code. As I execute it I found that
tsp is actually deleted twice. I am trying to see whether my approach
is correct and would like to hear your opinions.

dbtouch

 #include <iostream>

class Foo {
public:
  void func() {
    std::cout << "Foo::func()" << std::endl;
  }

  Foo(const Foo& f) {
     std::cout << "Foo::Foo(const Foo&)" << std::endl;
  }

  Foo() {
    std::cout << "Foo::Foo()" << std::endl;
  }

  ~Foo() {
    std::cout << "Foo:~Foo()" << std::endl;
  }
};

class Mutex {
public:
  void acquire() {
    std::cout << "Mutex.acquire()" << std::endl;
  }
  void release() {
    std::cout << "Mutex.release()" << std::endl;
  }
};

template <typename SharedObject, typename SyncPolicy>
class ThreadedSmartPtr {
  SharedObject* m_ptr;
  Mutex lock;

public:
  ThreadedSmartPtr(SharedObject* ptr, SyncPolicy& lck) :
    m_ptr(ptr), lock(lck) {
    lock.acquire();
  }

  ~ThreadedSmartPtr() {
    lock.release();
  }

  SharedObject* operator -> () {
    return m_ptr;
  }
};

template <typename T>
class SmartPtr {
  T *object;

public:
  SmartPtr(T* value) : object(value) {
  }

  T operator->() {
    return *object;
  }

  ~SmartPtr() {
    if (object)
      delete object;
  }
};

typedef ThreadedSmartPtr<Foo, Mutex> oldSmartPtr;

int main() {
  Foo *ptr = new Foo;
  Mutex m;
  oldSmartPtr tsp(ptr, m);

  SmartPtr<oldSmartPtr> sp(&tsp);
  sp->func();
}