The ILock interface provides concurrency control for objects operating in a multithreaded environment (for example, in applications that use distributed state).

• A lock mode. You can specify an exclusive or shared lock. An exclusive lock prevents other threads from accessing a locked object. You can also use the lock mode to specify that an operation may continue even if the desired locking mode is not available.
• A caller ID. This setting provides a unique identifer for the caller that places or removes a lock. The identifier is an array of bytes.

Syntax

public int changeMode(
	int dwOldMode,
	int dwNewMode,
	byte[] pID,
	int nSize);

dwOldMode. Current lock mode applied to an object. The mode is one of GXLOCK_EXCL (exclusive lock) or GXLOCK_SHARE (shared lock).

dwNewMode. New locking mode, one of GXLOCK_EXCL (exclusive lock) or GXLOCK_SHARE (shared lock). Optionally, the mode may also include GXLOCK_NOBLOCK if the operation should be allowed to continue if the desired locking mode is not available. If GXLOCK_NOBLOCK is not specified, then a thread is blocked if the desired locking mode is not available.

pID. ID of the caller requesting the change to the lock. This value is read only.

nSize. Size of the identifier.

public int lock(
	int dwFlags,
	byte[] pID,
	int nSize);

dwFlags. Locking mode, one of GXLOCK_EXCL (exclusive lock) or GXLOCK_SHARE (shared lock). Optionally, the mode may also include GXLOCK_NOBLOCK if the operation should be allowed to continue if the desired locking mode is not available. If GXLOCK_NOBLOCK is not specified, then a thread is blocked if the desired locking mode is not available.

pID. ID of the caller requesting the lock. This value is a byte array. For state and session objects that implement the locking interface, you can pass in a null value for pID because these implementations automatically use the ID of the calling thread for pID.

nSize. Size of the identifier.

• After locking a parent state node, do not create or delete a child node under it.
• After locking a state or session node, do not delete the node.

IState2 marketnews = cacheroot.getStateChild("mktnews"); 
if (marketnews == null)
	return; 

// we expect marketnews state node to be accessed concurrently 
// let's lock it 

ILock l = null; 
int ret; 
if (marketnews instanceof ILock) 
{ 
	l = (ILock)marketnews; 
	ret = l.lock(GXLOCK.GXLOCK_EXCL, null, 0); 
	if (ret != GXE.SUCCESS) 
	{ 
		log("lock error"); 
		return;
	} 
}
else
{
	log("IState2 object doesn't implement the ILock interface");
	return;
}
if (l == null) 
	return; 

// we now have the node locked in exclusive mode 
// ..... do work .......... 
// and unlock the node 

ret = l.unlock(GXLOCK.GXLOCK_EXCL, null, 0); 
if (ret != GXE.SUCCESS) 
	log("unlock error"); 

public int unlock(
	int dwFlags,
	byte[] pID,
	int nSize);

dwFlags. The locking mode previously used to lock the object, either GXLOCK_EXCL (exclusive lock), or GXLOCK_SHARE (shared lock).

pID. The ID of the caller that requests lock removal. This value is a byte array. The ID must match the ID with which you set the lock.

nSize. Size of the identifier.

IState2 marketnews = cacheroot.getStateChild("mktnews"); 
if (marketnews == null)
	return; 

// we expect marketnews state node to be accessed concurrently 
// let's lock it 

ILock l = null; 
int ret; 
if (marketnews instanceof ILock) 
{ 
	l = (ILock)marketnews; 
	ret = l.lock(GXLOCK.GXLOCK_EXCL, null, 0); 
	if (ret != GXE.SUCCESS) 
	{ 
		log("lock error"); 
		return;
	} 
}
else
{
	log("IState2 doesn't implement the ILock interface");
	return;
}
if (l == null) 
	return; 

// we now have the node locked in exclusive mode 
// ..... do work .......... 
// and unlock the node 

ret = l.unlock(GXLOCK.GXLOCK_EXCL, null, 0); 
if (ret != GXE.SUCCESS) 
	log("unlock error");