v8::Unlocker Class Reference

Multiple threads in V8 are allowed, but only one thread at a time is allowed to use any given V8 isolate, see the comments in the Isolate class. More...

#include <v8.h>

Collaboration diagram for v8::Unlocker:

Public Member Functions
	Unlocker (Isolate *isolate)
	Initialize Unlocker for a given Isolate. More...
	~Unlocker ()

Private Member Functions
void	Initialize (Isolate *isolate)

Private Attributes
internal::Isolate *	isolate_

Detailed Description

Multiple threads in V8 are allowed, but only one thread at a time is allowed to use any given V8 isolate, see the comments in the Isolate class.

The definition of 'using a V8 isolate' includes accessing handles or holding onto object pointers obtained from V8 handles while in the particular V8 isolate. It is up to the user of V8 to ensure, perhaps with locking, that this constraint is not violated. In addition to any other synchronization mechanism that may be used, the v8::Locker and v8::Unlocker classes must be used to signal thead switches to V8.

v8::Locker is a scoped lock object. While it's active, i.e. between its construction and destruction, the current thread is allowed to use the locked isolate. V8 guarantees that an isolate can be locked by at most one thread at any time. In other words, the scope of a v8::Locker is a critical section.

Sample usage:

...
{
  v8::Locker locker(isolate);
  v8::Isolate::Scope isolate_scope(isolate);
  ...
  // Code using V8 and isolate goes here.
  ...
} // Destructor called here

If you wish to stop using V8 in a thread A you can do this either by destroying the v8::Locker object as above or by constructing a v8::Unlocker object:

{
  isolate->Exit();
  v8::Unlocker unlocker(isolate);
  ...
  // Code not using V8 goes here while V8 can run in another thread.
  ...
} // Destructor called here.
isolate->Enter();

The Unlocker object is intended for use in a long-running callback from V8, where you want to release the V8 lock for other threads to use.

The v8::Locker is a recursive lock, i.e. you can lock more than once in a given thread. This can be useful if you have code that can be called either from code that holds the lock or from code that does not. The Unlocker is not recursive so you can not have several Unlockers on the stack at once, and you can not use an Unlocker in a thread that is not inside a Locker's scope.

An unlocker will unlock several lockers if it has to and reinstate the correct depth of locking on its destruction, e.g.:

// V8 not locked.
{
  v8::Locker locker(isolate);
  Isolate::Scope isolate_scope(isolate);
  // V8 locked.
  {
    v8::Locker another_locker(isolate);
    // V8 still locked (2 levels).
    {
      isolate->Exit();
      v8::Unlocker unlocker(isolate);
      // V8 not locked.
    }
    isolate->Enter();
    // V8 locked again (2 levels).
  }
  // V8 still locked (1 level).
}
// V8 Now no longer locked.

Definition at line 5677 of file v8.h.

Constructor & Destructor Documentation

Unlocker()

v8::Unlocker::Unlocker ( Isolate *  isolate )

inlineexplicit

Initialize Unlocker for a given Isolate.

Definition at line 5682 of file v8.h.

{ Initialize(isolate); }

~Unlocker()

v8::Unlocker::~Unlocker

(

)

Definition at line 93 of file v8threads.cc.

                    {
  DCHECK(!isolate_->thread_manager()->IsLockedByCurrentThread());
  isolate_->thread_manager()->Lock();
  isolate_->thread_manager()->RestoreThread();
}

References DCHECK, v8::internal::ThreadManager::IsLockedByCurrentThread(), isolate_, v8::internal::ThreadManager::Lock(), v8::internal::ThreadManager::RestoreThread(), and v8::internal::Isolate::thread_manager().

Here is the call graph for this function:

Member Function Documentation

Initialize()

void v8::Unlocker::Initialize ( v8::Isolate *  isolate )

private

Definition at line 84 of file v8threads.cc.

                                            {
  DCHECK(isolate != NULL);
  isolate_ = reinterpret_cast<i::Isolate*>(isolate);
  DCHECK(isolate_->thread_manager()->IsLockedByCurrentThread());
  isolate_->thread_manager()->ArchiveThread();
  isolate_->thread_manager()->Unlock();
}

References v8::internal::ThreadManager::ArchiveThread(), DCHECK, v8::internal::ThreadManager::IsLockedByCurrentThread(), isolate_, NULL, v8::internal::Isolate::thread_manager(), and v8::internal::ThreadManager::Unlock().

Here is the call graph for this function:

Member Data Documentation

isolate_

internal::Isolate* v8::Unlocker::isolate_

private

Definition at line 5688 of file v8.h.

Referenced by Initialize(), and ~Unlocker().

---

The documentation for this class was generated from the following files:

• /mnt/V8SourceCode/include/v8.h
• /mnt/V8SourceCode/src/v8threads.cc