Reentrantlock 返回锁对象异常

[ddddouche]

使用Reentrantlock实现可中断线程锁的时候返回：锁对象异常。代码如下
// 客户端及两个Runnable

package com.scl.thread.interrupt;

public class TestLockInterruptibly
{
	public static void main(String[] args) throws Exception
	{
		// 1. 根据lock控制中断
		FileHandlerByThreads fileControl = new FileHandlerByThreads();
		Thread readthr = new Thread(new ReadThread(fileControl), "reader");
		Thread writethr = new Thread(new WriteThread(fileControl), "writer");

		// 2. 使用synchronized关键字控制中断线程
		// SyncFileHandler sync = new SyncFileHandler();
		// Thread readthr = new Thread(new ReadThread(sync), "reader");
		// Thread writethr = new Thread(new WriteThread(sync), "writer");
		writethr.start();
		readthr.start();

		long startTime = System.currentTimeMillis();
		// 循环判是否有线程获取到了读锁断
		while (!fileControl.isGetReadLock())
		{
			long endTime = System.currentTimeMillis();
			// 如果4秒后读线程仍然没有等到读锁，离开等待
			if (endTime - startTime > 4000)
			{
				readthr.interrupt();
				System.out.println("4 seconds have passed,try to interrupt reader Thread");
				break;
			}
		}

	}
}

class ReadThread implements Runnable
{
	private IFileHandler fileControl;

	public ReadThread(IFileHandler fileControl)
	{
		this.fileControl = fileControl;
	}

	@Override
	public void run()
	{
		try
		{
			fileControl.read();
		}
		catch (InterruptedException e)
		{
			// e.printStackTrace();
			// 测试单纯使用synchronized关键字控制线程中断
			System.out.println("reader thread end");
			fileControl.formatFile();
		}
	}
}

class WriteThread implements Runnable
{
	private IFileHandler fileControl;

	public WriteThread(IFileHandler fileControl)
	{
		this.fileControl = fileControl;
	}

	@Override
	public void run()
	{
		fileControl.write();
	}
}

//线程逻辑代码

package com.scl.thread.interrupt;

import java.util.concurrent.locks.ReentrantLock;

public class FileHandlerByThreads implements IFileHandler
{

	private volatile boolean isGetReadLock = false;
	private ReentrantLock lock = new ReentrantLock();

	public boolean isGetReadLock()
	{
		return isGetReadLock;
	}

	public void read()
	{

		try
		{
			// 等待20毫秒再进行后续操作，防止主线程操作过快
			Thread.sleep(50);
			// 使用reentrantlock
			lock.lockInterruptibly();
			System.out.println(Thread.currentThread().getName() + " start");
			isGetReadLock = true;
		}
		catch (InterruptedException e)
		{
			// e.printStackTrace();
			System.out.println("reader Thread leave the file and going to format the file");
		}
		finally
		{
			lock.unlock();
		}

	}

	// 模拟运行时间比较久的写操作
	public void write()
	{
		try
		{

			// 1.使用lock实现写锁定
			// 等待20毫秒再进行后续操作，防止主线程操作过快
			Thread.sleep(20);
			lock.lock();
			System.out.println(Thread.currentThread().getName() + " start");
			long startTime = System.currentTimeMillis();
			// 模拟一个耗时较长的操作
			for (;;)
			{
				if (System.currentTimeMillis() - startTime > Integer.MAX_VALUE)
				{
					break;
				}
			}

			System.out.println("Writer has writered down everything! bravo");
		}
		catch (Exception e)
		{
			e.printStackTrace();
		}
		finally
		{
			lock.unlock();
		}
	}

	public void formatFile()
	{
		System.out.println("begin to format the file");
		// format the file
	}
}

在对比其他人的代码时发现引起锁对象异常是由 FileHandlerByThreads对象内read方法里面的lock.lockInterruptibly();位置引起，把该代码提到try代码块前面则代码不返回java.lang.IllegalMonitorStateException异常。请问这是怎么回事？

[NewMoons]

通常，IllegalMonitorStateException这个异常表示的是你的当前线程和锁没有关联。

[ddddouche]

好像是对的，因为read线程根本没有得到锁，然后我在finally里面调用了unlock把锁给释放了...