/*

 * Copyright (c) 2007, 2018, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package nsk.share.locks;

/*

 *  Thread intended to hold given lock until method releaseLock() not called

 *

 *   Example of usage:

 *

 *   Object lockToHold = new Object();

 *   MonitorLockingThread lockingThread = new MonitorLockingThread(lockToHold);

 *

 *   // after calling this method lock 'lockToHold' is acquired by lockingThread

 *   lockingThread.acquireLock();

 *

 *   // after calling this method lockingThread releases 'lockToHold' and finishes execution

 *   lockingThread.releaseLock();

 */

public class MonitorLockingThread extends Thread {

    /*

     *   Class MonitorLockingThread is written for usage in tests provoking monitor contention.

     *   Typically in these tests exists thread holding lock (MonitorLockingThread) and another

     *   thread trying to acquire the same lock. But this scenario also requires one more thread

     *   which will force MonitorLockingThread to release lock when contention occurred, for this purpose

     *   auxiliary thread class LockFreeThread is written.

     *

     *   Example of usage of MonitorLockingThread and LockFreeThread:

     *

     *   Object lock = new Object();

     *   MonitorLockingThread monitorLockingThread = new MonitorLockingThread(lock);

     *

     *   MonitorLockingThread.LockFreeThread lockFreeThread =

     *       new MonitorLockingThread.LockFreeThread(Thread.currentThread(), monitorLockingThread);

     *

     *   monitorLockingThread.acquireLock();

     *

     *   lockFreeThread.start();

     *

     *   // try to acquire lock which is already held by MonitorLockingThread (here monitor contention should occur),

     *   // when LockFreeThread finds that contention occurred it forces MonitorLockingThread to release lock

     *   // and current thread is able to continue execution

     *   synchronized (lock) {

     *   }

     */

    public static class LockFreeThread extends Thread {

        private Thread blockedThread;

        private MonitorLockingThread lockingThread;

        public LockFreeThread(Thread blockedThread, MonitorLockingThread lockingThread) {

            this.blockedThread = blockedThread;

            this.lockingThread = lockingThread;

        }

        public void run() {

            /*

             * Wait when blockedThread's state will switch to 'BLOCKED' (at that moment monitor contention

             * should already occur) and then force MonitorLockingThread to release lock

             */

            while (blockedThread.getState() != Thread.State.BLOCKED)

            lockingThread.releaseLock();

        }

    }

    private volatile boolean isRunning = true;

    private volatile boolean holdsLock;

    private Object lockToHold;

    public MonitorLockingThread(Object lockToHold) {

        this.lockToHold = lockToHold;

    }

    public void run() {

        synchronized (lockToHold) {

            holdsLock = true;

            while (isRunning)

        }

        holdsLock = false;

    }

    public void releaseLock() {

        isRunning = false;

        while (holdsLock)

    }

    public void acquireLock() {

        start();

        while (!holdsLock)

    }

}