diff --git a/ext/v8/backref.cc b/ext/v8/backref.cc
index 3e27bc4..60a67da 100644
--- a/ext/v8/backref.cc
+++ b/ext/v8/backref.cc
@@ -31,9 +31,7 @@ namespace rr {
     return rb_funcall(storage, object, 0);
   }
 
-  v8::Handle<v8::External> Backref::toExternal() {
-    v8::Isolate* isolate = v8::Isolate::GetCurrent();
-
+  v8::Handle<v8::External> Backref::toExternal(v8::Isolate* isolate) {
     v8::Local<v8::External> wrapper = v8::External::New(isolate, this);
     v8::Persistent<v8::External>(isolate, wrapper).SetWeak(this, &release);
 
diff --git a/ext/v8/backref.h b/ext/v8/backref.h
index c3b5cac..c835774 100644
--- a/ext/v8/backref.h
+++ b/ext/v8/backref.h
@@ -14,7 +14,7 @@ namespace rr {
     VALUE get();
     VALUE set(VALUE value);
 
-    v8::Handle<v8::External> toExternal();
+    v8::Handle<v8::External> toExternal(v8::Isolate*);
 
     static void release(const v8::WeakCallbackData<v8::External, Backref>& data);
   private:
diff --git a/ext/v8/context.cc b/ext/v8/context.cc
index 407e769..4789c12 100644
--- a/ext/v8/context.cc
+++ b/ext/v8/context.cc
@@ -19,11 +19,14 @@ namespace rr {
   }
 
   VALUE Context::New(int argc, VALUE argv[], VALUE self) {
-    VALUE isolate, extension_configuration, global_template, global_object;
-    rb_scan_args(argc, argv, "13", &isolate, &extension_configuration, &global_template, &global_object);
+    VALUE rb_isolate, extension_configuration, global_template, global_object;
+    rb_scan_args(argc, argv, "13", &rb_isolate, &extension_configuration, &global_template, &global_object);
+
+    Isolate isolate(rb_isolate);
+    Locker lock(isolate);
 
     return Context(v8::Context::New(
-      Isolate(isolate)
+      isolate
       // TODO
       // ,
       // ExtensionConfiguration(extension_configuration),
diff --git a/ext/v8/isolate.cc b/ext/v8/isolate.cc
index b241659..d989ee0 100644
--- a/ext/v8/isolate.cc
+++ b/ext/v8/isolate.cc
@@ -5,10 +5,7 @@ namespace rr {
   void Isolate::Init() {
     ClassBuilder("Isolate").
       defineSingletonMethod("New", &New).
-      defineSingletonMethod("GetCurrent", &GetCurrent).
 
-      defineMethod("Enter", &Enter).
-      defineMethod("Exit", &Exit).
       defineMethod("Equals", &rr::Isolate::PointerEquals).
 
       store(&Class);
@@ -18,26 +15,6 @@ namespace rr {
     return Isolate(v8::Isolate::New());
   }
 
-  VALUE Isolate::Enter(VALUE self) {
-    Isolate(self)->Enter();
-    return Qtrue;
-  }
-
-  VALUE Isolate::Exit(VALUE self) {
-    Isolate(self)->Exit();
-    return Qtrue;
-  }
-
-  VALUE Isolate::GetCurrent(VALUE self) {
-    v8::Isolate* currentIsolate = v8::Isolate::GetCurrent();
-
-    if (!currentIsolate) {
-      return Qnil;
-    }
-
-    return Isolate(currentIsolate);
-  }
-
   template <>
   void Pointer<v8::Isolate>::unwrap(VALUE value) {
     Data_Get_Struct(value, class v8::Isolate, pointer);
diff --git a/ext/v8/isolate.h b/ext/v8/isolate.h
index 9824a4f..b77f8ec 100644
--- a/ext/v8/isolate.h
+++ b/ext/v8/isolate.h
@@ -8,9 +8,6 @@ namespace rr {
     static void Init();
 
     static VALUE New(VALUE self);
-    static VALUE Enter(VALUE self);
-    static VALUE Exit(VALUE self);
-    static VALUE GetCurrent(VALUE self);
 
     // TODO: Add a Dispose method
 
diff --git a/ext/v8/object.cc b/ext/v8/object.cc
index 26daf68..4525385 100644
--- a/ext/v8/object.cc
+++ b/ext/v8/object.cc
@@ -43,6 +43,8 @@ namespace rr {
   }
 
   Object::operator VALUE() {
+    Locker lock(getIsolate());
+
     if (handle.IsEmpty()) {
       return Qnil;
     }
@@ -58,7 +60,7 @@ namespace rr {
       value = downcast();
       backref = new Backref(value);
 
-      handle->SetHiddenValue(key, backref->toExternal());
+      handle->SetHiddenValue(key, backref->toExternal(getIsolate()));
     } else {
       v8::External* wrapper = v8::External::Cast(*external);
       backref = (Backref*)wrapper->Value();
@@ -74,6 +76,8 @@ namespace rr {
   }
 
   VALUE Object::downcast() {
+    Locker lock(getIsolate());
+
     // TODO: Enable this when the methods are implemented
     // if (handle->IsFunction()) {
     //   return Function((v8::Handle<v8::Function>) v8::Function::Cast(*handle));
diff --git a/ext/v8/rr_string.cc b/ext/v8/rr_string.cc
index 1b13bb4..fe87b5c 100644
--- a/ext/v8/rr_string.cc
+++ b/ext/v8/rr_string.cc
@@ -14,6 +14,7 @@ namespace rr {
 
   VALUE String::NewFromUtf8(VALUE StringClass, VALUE rb_isolate, VALUE string) {
     Isolate isolate(rb_isolate);
+    Locker lock(isolate);
 
     v8::Local<v8::String> v8_string = v8::String::NewFromUtf8(isolate, RSTRING_PTR(string), v8::String::kNormalString, (int)RSTRING_LEN(string));
 
@@ -22,6 +23,7 @@ namespace rr {
 
   VALUE String::Utf8Value(VALUE self) {
     String string(self);
+    Locker lock(string.getIsolate());
 
     #ifdef HAVE_RUBY_ENCODING_H
     return rb_enc_str_new(*v8::String::Utf8Value(*string), string->Utf8Length(), rb_enc_find("utf-8"));
@@ -32,11 +34,14 @@ namespace rr {
 
   VALUE String::Concat(VALUE self, VALUE left, VALUE right) {
     String left_string(left);
+    Locker lock(left_string.getIsolate());
 
     return String(left_string.getIsolate(), v8::String::Concat(left_string, String(right)));
   }
 
   String::operator v8::Handle<v8::String>() const {
+    Locker lock(getIsolate());
+
     switch (TYPE(value)) {
     case T_STRING:
       return v8::String::NewFromUtf8(getIsolate(), RSTRING_PTR(value), v8::String::kNormalString, (int)RSTRING_LEN(value));
diff --git a/ext/v8/value.cc b/ext/v8/value.cc
index 22124b4..01bdb93 100644
--- a/ext/v8/value.cc
+++ b/ext/v8/value.cc
@@ -49,53 +49,87 @@ namespace rr {
   }
 
   VALUE Value::IsUndefined(VALUE self) {
-    return Bool(Value(self)->IsUndefined());
+    Value value(self);
+    Locker lock(value.getIsolate());
+
+    return Bool(value->IsUndefined());
   }
 
   VALUE Value::IsNull(VALUE self) {
-    return Bool(Value(self)->IsNull());
+    Value value(self);
+    Locker lock(value.getIsolate());
+
+    return Bool(value->IsNull());
   }
 
   VALUE Value::IsTrue(VALUE self) {
-    return Bool(Value(self)->IsTrue());
+    Value value(self);
+    Locker lock(value.getIsolate());
+
+    return Bool(value->IsTrue());
   }
 
   VALUE Value::IsFalse(VALUE self) {
-    return Bool(Value(self)->IsFalse());
+    Value value(self);
+    Locker lock(value.getIsolate());
+
+    return Bool(value->IsFalse());
   }
 
   VALUE Value::IsString(VALUE self) {
-    return Bool(Value(self)->IsString());
+    Value value(self);
+    Locker lock(value.getIsolate());
+
+    return Bool(value->IsString());
   }
 
   VALUE Value::IsObject(VALUE self) {
-    return Bool(Value(self)->IsObject());
+    Value value(self);
+    Locker lock(value.getIsolate());
+
+    return Bool(value->IsObject());
   }
 
   VALUE Value::IsExternal(VALUE self) {
-    return Bool(Value(self)->IsExternal());
+    Value value(self);
+    Locker lock(value.getIsolate());
+
+    return Bool(value->IsExternal());
   }
 
   VALUE Value::IsInt32(VALUE self) {
-    return Bool(Value(self)->IsInt32());
+    Value value(self);
+    Locker lock(value.getIsolate());
+
+    return Bool(value->IsInt32());
   }
 
   VALUE Value::IsUint32(VALUE self) {
-    return Bool(Value(self)->IsUint32());
+    Value value(self);
+    Locker lock(value.getIsolate());
+
+    return Bool(value->IsUint32());
   }
 
   VALUE Value::ToString(VALUE self) {
     Value value(self);
+    Locker lock(value.getIsolate());
 
     return String(value.getIsolate(), value->ToString());
   }
 
   VALUE Value::Equals(VALUE self, VALUE other) {
-    return Bool(Value(self)->Equals(Value(other)));
+    Value value(self);
+    Locker lock(value.getIsolate());
+
+    return Bool(value->Equals(Value(other)));
   }
 
   VALUE Value::StrictEquals(VALUE self, VALUE other) {
-    return Bool(Value(self)->StrictEquals(Value(other)));
+    Value value(self);
+    Locker lock(value.getIsolate());
+
+    return Bool(value->StrictEquals(Value(other)));
   }
 
   VALUE Value::ToRubyObject(VALUE self) {
@@ -164,8 +198,6 @@ namespace rr {
   }
 
   v8::Handle<v8::Value> Value::rubyObjectToHandle(v8::Isolate* isolate, VALUE value) {
-    Locker lock(isolate);
-
     if (rb_equal(value, Empty)) {
       return v8::Handle<v8::Value>();
     }