Watch 1 Star 1 Fork 0

ConstXiong / concurrencyJava

Join us
Explore and code with more than 2 million developers,Free private repositories !:)
Sign up
Java 并发编程学习记录 spread retract

Clone or download
019-Java中可重入锁、不可重入锁的测试.md 5.49 KB
Copy Edit Web IDE Raw Blame History
handsomX authored 2019-09-23 20:01 . 'concurrency'

Java 中可重入锁、不可重入锁的测试

可重入锁

指在同一个线程在外层方法获取锁的时候,进入内层方法会自动获取锁。

为了避免死锁的发生,JDK 中基本都是可重入锁。

下面我们来测试一下 synchronized 和 java.util.concurrent.lock.ReentrantLock 锁的可重入性

  • 测试 synchronized 加锁 可重入性
package constxiong.concurrency.a019;

/**
 * 测试 synchronized 加锁 可重入性
 * @author ConstXiong
 * @date 2019-09-20 15:55:27
 */
public class TestSynchronizedReentrant {
	
	public static void main(String[] args) {
		new Thread(new SynchronizedReentrant()).start();
	}
	
}

class SynchronizedReentrant implements Runnable {

	private final Object obj = new Object();
	
	/**
	 * 方法1,调用方法2
	 */
	public void method1() {
		synchronized (obj) {
			System.out.println(Thread.currentThread().getName() + " method1()");
			method2();
		}
	}
	
	/**
	 * 方法2,打印前获取 obj 锁
	 * 如果同一线程,锁不可重入的话,method2 需要等待 method1 释放 obj 锁
	 */
	public void method2() {
		synchronized (obj) {
			System.out.println(Thread.currentThread().getName() + " method2()");
		}
	}

	@Override
	public void run() {
		//线程启动 执行方法1
		method1();
	}
	
}

打印结果:

Thread-0 method1()
Thread-0 method2()
  • 测试 ReentrantLock 的可重入性
package constxiong.concurrency.a019;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 测试 ReentrantLock 的可重入性
 * @author ConstXiong
 * @date 2019-09-20 16:24:52
 */
public class TestLockReentrant {

	public static void main(String[] args) {
		new Thread(new LockReentrant()).start();
	}
	
}

class LockReentrant implements Runnable {

	private final Lock lock = new ReentrantLock();
	
	/**
	 * 方法1,调用方法2
	 */
	public void method1() {
		lock.lock();
		try {
			System.out.println(Thread.currentThread().getName() + " method1()");
			method2();
		} finally {
			lock.unlock();
		}
	}
	
	/**
	 * 方法2,打印前获取 obj 锁
	 * 如果同一线程,锁不可重入的话,method2 需要等待 method1 释放 obj 锁
	 */
	public void method2() {
		lock.lock();
		try {
			System.out.println(Thread.currentThread().getName() + " method2()");
		} finally {
			lock.unlock();
		}
	}

	@Override
	public void run() {
		//线程启动 执行方法1
		method1();
	}
	
}

打印结果:

Thread-0 method1()
Thread-0 method2()
  • 测试不可重入锁 我在 JDK 中没找到可重入锁,所以考虑自己实现一下。两种方式:通过 synchronized wait notify 实现;通过 CAS + 自旋方式实现
  1. synchronized wait notify 方式实现
package constxiong.concurrency.a019;


/**
 * 不可重入锁,通过 synchronized wait notify 实现
 * @author ConstXiong
 * @date 2019-09-20 16:53:34
 */
public class NonReentrantLockByWait {

	//是否被锁
	private volatile boolean locked = false;
	
	//加锁
	public synchronized void lock() {
		//当某个线程获取锁成功,其他线程进入等待状态
		while (locked) {
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		//加锁成功,locked 设置为 true
		locked = true;
	}
	
	//释放锁
	public synchronized void unlock() {
		locked = false;
		notify();
	}

}
  1. 通过 CAS + 自旋 方式实现
package constxiong.concurrency.a019;

import java.util.concurrent.atomic.AtomicReference;


/**
 * 不可重入锁,通过 CAS + 自旋 实现
 * @author ConstXiong
 * @date 2019-09-20 16:53:34
 */
public class NonReentrantLockByCAS {
	
	private AtomicReference<Thread> lockedThread = new AtomicReference<Thread>();

	public void lock() {
		Thread t = Thread.currentThread();
		//当 lockedThread 持有引用变量为 null 时,设置 lockedThread 持有引用为 当前线程变量
		while (!lockedThread.compareAndSet(null, t)) {
			//自旋,空循环,等到锁被释放
		}
	}
	
	public void unlock() {
		//如果是本线程锁定的,可以成功释放锁
		lockedThread.compareAndSet(Thread.currentThread(), null);
	}
}

测试类

package constxiong.concurrency.a019;

/**
 * 测试不可重入锁
 * @author ConstXiong
 * @date 2019-09-20 18:08:55
 */
public class TestLockNonReentrant{

	public static void main(String[] args) {
		new Thread(new LockNonReentrant()).start();
	}
	
}


class LockNonReentrant implements Runnable {
	
//	private final NonReentrantLockByWait lock = new NonReentrantLockByWait();
	private final NonReentrantLockByCAS lock = new NonReentrantLockByCAS();
	
	/**
	 * 方法1,调用方法2
	 */
	public void method1() {
		lock.lock();
		try {
			System.out.println(Thread.currentThread().getName() + " method1()");
			method2();
		} finally {
			lock.unlock();
		}
	}
	
	/**
	 * 方法2,打印前获取 obj 锁
	 * 如果同一线程,锁不可重入的话,method2 需要等待 method1 释放 obj 锁
	 */
	public void method2() {
		lock.lock();
		try {
			System.out.println(Thread.currentThread().getName() + " method2()");
		} finally {
			lock.unlock();
		}
	}

	@Override
	public void run() {
		//线程启动 执行方法1
		method1();
	}
}

测试结果,都是在 method1,调用 method2 的时候,导致了死锁,线程一直等待或者自旋下去。  

参考:

  1. http://ifeve.com/java_lock_see4/



返回顶部 返回

Comment ( 0 )

Sign in for post a comment

Java
1
https://gitee.com/ConstXiong/concurrency.git
git@gitee.com:ConstXiong/concurrency.git
ConstXiong
concurrency
concurrency
master

Help Search