ReentrantLock是一个可重入的互斥锁，重入锁是一种递归无阻塞的同步机制。要怎么样才能将reentrantlock锁暂停呢?接下来，我们就来给大家讲解一下这方面的内容。
代码如下：
class Activity extends Thread
{
private Integer goodsId;
private ReentrantLock lock;
private Condition continueRun;
private int status; // 1 进行 2暂停 3重置
private int remainingTime; //秒
private int initTime;
public Activity(int goodsId, Integer status, int initTime)
{
this.goodsId = goodsId;
this.status = status;
this.lock = new ReentrantLock();
this.continueRun = lock.newCondition();
this.initTime = initTime * 60;
this.remainingTime = initTime * 60;
}
public String getRemainingTimeString()
{
int ttime = this.remainingTime;
int minute = ttime / 60;
int second = ttime % 60;
StringBuilder stringBuilder = new StringBuilder();
if (minute < 10)
{
stringBuilder.append("0")
.append(minute);
}
else
{
stringBuilder.append(minute);
}
stringBuilder.append(":");
if (second < 10)
{
stringBuilder.append("0")
.append(second);
}
else
{
stringBuilder.append(second);
}
return stringBuilder.toString();
}
public void setStatus(Integer status)
{
if (status != 2)
{
final ReentrantLock lock = this.lock;
lock.lock();
try
{
continueRun.signal();
}
catch (Exception e)
{
e.printStackTrace();
}
finally
{
lock.unlock();
}
}
this.status = status;
}
public void run()
{
while (remainingTime > -1)
{
if (status == 2)
{
final ReentrantLock lock = this.lock;
try
{
lock.lockInterruptibly();
continueRun.await();
}
catch (Exception e)
{
e.printStackTrace();
}
finally
{
lock.unlock();
}
}
else if (status == 3)
{
remainingTime = initTime;
status = 1;
continue;
}
try
{
Thread.sleep(1 * 1000);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
System.out.println("剩余时间: " + getRemainingTimeString());
remainingTime--;
}
}
}
public class App
{
public static void main(String[] args)
{
Activity activity = new Activity(234, 1, 15);
activity.start();
Scanner scanner = new Scanner(System.in);
for (int i = 0; i < 50; i++)
{
System.out.print("input: ");
String s = scanner.nextLine();
int status = Integer.parseInt(s);
activity.setStatus(status); //控制线程状态
}
}
}reentrantlock如何理解?
重入锁(ReenturantLock)是Lock接口最常见的一种实现，顾名思义，它与synchronized一样是可重入的，在基本用法上，ReentrantLock也与synchronized很相似，只是代码实现方法上有些区别而且，另外一个很直接的区别是synchronized为Java中的一个关键字而ReentrantLock是一个接口。
此外，ReentrantLock与synchronized相比增加了一些高级功能，主要有以下三项：等待可中断，可实现公平锁及锁可以绑定多个条件。
等待可中断：是指当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情。可中断特性对处理执行时间非常长的同步块很有帮助。
公平锁：是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁;而非公平锁则不保证这一点，在锁被释放时，任何一个等待锁的线程都有机会获得锁。synchronized中的锁时非公平的，ReentrantLock在默认情况下也是非公平的，但可以通过带布尔值的构造函数要求使用公平锁不过一旦使用了公平锁，将会导致ReentrantLock的性能急剧下降，会明显影响吞吐量。
public ReentrantLock(boolean fair)
{
sync = fair ? new FairSync() : new NonfairSync();
}锁定多个条件：是指一个ReentrantLock对象可以同时绑定多个Condition对象。在synchronized中，锁对象的wait()和它notify()或者是notifyAll()方法配合可以实现一个隐含的条件，如果要和多于一个的条件关联时候，就不得不额外添加一个锁;而ReentrantLock则无须这样做，多次调用newCondition()方法即可。
其实ReentrantLock相比synchronized来说，功能更加丰富，使用起来更为灵活，也会更适合复杂的并发场景哦。最后大家如果想要了解更多java常见问题知识，敬请关注奇Q工具网。
推荐阅读：