CareerCup

/* atomic execution by hardware */
boolean test_and_set(boolean &mutex) {
   boolean tmp=mutex;
   mutex = true;
   return tmp;
}

void mutex_init(boolean &mutex) {
   mutex = false;
}

void mutex_lock(boolean &mutex) {
   while(test_and_set(mutex));
}

void mutex_unlock(boolean &mutex) {
   mutex = false;
}

public class Lock {
  private Object lockObj = new Object();
  private Thread owner;
  private int lockCount;

  /**
   * Waits for up to 'maxWait' milliseconds to acquire the lock,
   * and returns true if the lock was acquired.
   **/
  public boolean acquireLock(int maxWait) throws InterruptedException {
    Thread currentThread = Thread.currentThread();
    synchronized (lockObj) {
      if (owner == currentThread) {
        lockCount++;
        return true;
      }
      long waitedSoFar = 0L;
      while (owner != null) {
        long t0 = System.currentTimeMillis();
        long timeToWait = maxWait - waitedSoFar;
        if (timeToWait <= 0)
          return false;
        lockObj.wait(timeToWait);
        if (owner != null) {
          waitedSoFar += System.currentTimeMillis() - t0;
        }
      }
      owner = currentThread;
      lockCount = 1;
      return true;
    }
  }
  public void releaseLock() {
    Thread currentThread = Thread.currentThread();
    synchronized (lockObj) {
      if (owner == currentThread) {
        lockCount--;
        if (lockCount == 0) {
          owner = null;
          lockObj.notify();
        }
        return;
      } else {
        // Only the owner can release the lock!
        throw new IllegalStateException();
      }
    }
  }
}

I guess, the answer they are looking for is-
By using atomic instructions like test and set

class mutex
{
int val;
public:
mutex(){val=0;}
lock()
{
while(testandset(&val));
}

unlock()
{
val=0;
}
}

try_again: test_set address;
cmp address 0;
branch_equal return;
call sleep;
jump try_again;
return:

/* By swap&test */
void swap(boolean &a, boolean &b) {boolean tmp=a; a=b; b=tmp;}
void mutex_init(boolean &mutex) {mutex=false;}
void mutex_lock(boolean &mutex) {
boolean wait=true;
while(wait) { swap(&wait, &mutex); }
}
void mutex_unlock(boolean &mutex) {
mutex=false;
}