public class Thread1 implements Runnable {private String flag = "start";private String control = "";public void run() {// TODO Auto-generated method stubint i = 0;while (true) {if (flag.equals("start")) {i++;System.out.println("The thread1 is running" + i);} else if (flag.equals("wait")) {try {System.out.println("===wait===");synchronized (control) {control.wait();}} catch (InterruptedException e) {// TODO Auto-generated catch block
                    e.printStackTrace();}}}}public void wait1() {this.flag = "wait";}public void start1() {this.flag = "start";if (flag.equals("start")) {synchronized (control) {control.notifyAll();}}}}

public static void main(String[] args) {// TODO Auto-generated method stubThread1 th1 = new Thread1();Thread t1 = new Thread(th1);t1.start();try {Thread.sleep(20);} catch (InterruptedException e) {// TODO Auto-generated catch block
            e.printStackTrace();}//thread线程暂停
        th1.wait1();try {Thread.sleep(2000);} catch (InterruptedException e) {// TODO Auto-generated catch block
            e.printStackTrace();}//thread线程继续运行
        th1.start1();//th1.wait1();//th1.start1();}

package com.thread;import java.util.concurrent.atomic.AtomicReference;public class UnreentrantLock {private AtomicReference<Thread> owner = new AtomicReference<Thread>();//记录当前锁的持有线程对象public void lock() {//加锁Thread current = Thread.currentThread();//获取当前线程对象for (; ; ) {//自旋（被当前线程或其他线程持有锁，就会循环）   for 的三种用法，class、增强型循环、无线循环if (owner.compareAndSet(null, current)) {//只有锁可用即为null，才能设置当前线程为锁持有对象，并返回truereturn;}}}public void unlock() {//解锁Thread current = Thread.currentThread();//获取当前线程对象owner.compareAndSet(current, null);//设置锁的持有对象为null
    }
}

package com.thread;import java.util.concurrent.atomic.AtomicReference;public class UnreentrantLock {private AtomicReference<Thread> owner = new AtomicReference<Thread>();//记录当前锁的持有线程对象private int state = 0;//记录重入次数public void lock() {//加锁Thread current = Thread.currentThread();//获取当前线程对象if (owner.compareAndSet(null, current)) {//当前锁可用state = 1;//状态置为1return;} else {if (current == owner.get()) {//如果当前线程持有锁state++;//重入次数加1return;}for (; ; ) {//被其他线程持有就会继续循环if (owner.compareAndSet(null, current)) {//只有锁可用即为null，才能设置当前线程为锁持有对象，并返回truereturn;}}}}public void unlock() {//解锁Thread current = Thread.currentThread();//获取当前线程对象if (current == owner.get()) {//如果当前线程持有锁if (state > 0) {//重入次数大于0state--;//重入次数减1} else {owner.compareAndSet(current, null);//设置锁的持有对象为null
            }}}
}

ReentrantLock中非公平的可重入锁实现：
// 非公平方式获取锁，用于tryLock()方法
final boolean nonfairTryAcquire(int acquires) {//当前线程final Thread current = Thread.currentThread();// 继承至AbstractQueuedSynchronizer的方法int c = getState();//获取锁状态值//没有线程正在竞争该锁if (c == 0) {// 继承至AbstractQueuedSynchronizer的方法if (compareAndSetState(0, acquires)) {//若state为0则将state修改为acquires的值，状态0表示锁没有被占用setExclusiveOwnerThread(current);// 设置当前线程独占return true;// 成功
      }} else if (current == getExclusiveOwnerThread()) {// 当前线程拥有该锁int nextc = c + acquires;// 增加重入次数if (nextc < 0) // overflow(计数值小于0,则抛出异常)throw new Error("Maximum lock count exceeded");// 继承至AbstractQueuedSynchronizer的方法setState(nextc);//设置锁状态值return true;// 成功
   }return false;// 失败
}

public void unlock() {sync.release(1);
}
public final boolean release(int arg) {if (tryRelease(arg)) {Node h = head;if (h != null && h.waitStatus != 0)unparkSuccessor(h);return true;}return false;
}
protected final boolean tryRelease(int releases) {int c = getState() - releases;if (Thread.currentThread() != getExclusiveOwnerThread())throw new IllegalMonitorStateException();boolean free = false;if (c == 0) {free = true;setExclusiveOwnerThread(null);}setState(c);return free;
}

public class IntLock implements Runnable{public static ReentrantLock lock1 = new ReentrantLock();public static ReentrantLock lock2 = new ReentrantLock();int lock;/*** 控制加锁顺序，产生死锁*/public IntLock(int lock) {this.lock = lock;}public void run() {try {if (lock == 1) {lock1.lockInterruptibly(); // 如果当前线程未被 中断，则获取锁。try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}lock2.lockInterruptibly();System.out.println(Thread.currentThread().getName()+"，执行完毕！");} else {lock2.lockInterruptibly();try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}lock1.lockInterruptibly();System.out.println(Thread.currentThread().getName()+"，执行完毕！");}} catch (InterruptedException e) {e.printStackTrace();} finally {// 查询当前线程是否保持此锁。if (lock1.isHeldByCurrentThread()) {lock1.unlock();}if (lock2.isHeldByCurrentThread()) {lock2.unlock();}System.out.println(Thread.currentThread().getName() + "，退出。");}}public static void main(String[] args) throws InterruptedException {IntLock intLock1 = new IntLock(1);IntLock intLock2 = new IntLock(2);Thread thread1 = new Thread(intLock1, "线程1");Thread thread2 = new Thread(intLock2, "线程2");thread1.start();thread2.start();Thread.sleep(1000);thread2.interrupt(); // 中断线程2
    }
}

public class TimeLock implements Runnable{public static ReentrantLock lock = new ReentrantLock();public void run() {try {if (lock.tryLock(5, TimeUnit.SECONDS)) {Thread.sleep(6 * 1000);}else {System.out.println(Thread.currentThread().getName()+" get Lock Failed");}} catch (InterruptedException e) {e.printStackTrace();}finally {// 查询当前线程是否保持此锁。if (lock.isHeldByCurrentThread()) {System.out.println(Thread.currentThread().getName()+" release lock");lock.unlock();}}}/*** 在本例中，由于占用锁的线程会持有锁长达6秒，故另一个线程无法再5秒的等待时间内获得锁，因此请求锁会失败。*/public static void main(String[] args) {TimeLock timeLock = new TimeLock();Thread t1 = new Thread(timeLock, "线程1");Thread t2 = new Thread(timeLock, "线程2");t1.start();t2.start();}
}

public class FairLock implements Runnable{public static ReentrantLock fairLock = new ReentrantLock(true);public void run() {while (true) {try {fairLock.lock();System.out.println(Thread.currentThread().getName()+"，获得锁!");}finally {fairLock.unlock();}}}public static void main(String[] args) {FairLock fairLock = new FairLock();Thread t1 = new Thread(fairLock, "线程1");Thread t2 = new Thread(fairLock, "线程2");t1.start();t2.start();}
}