用信号量semaphore实现互斥锁mutex

	技术文档>>JAVA>>新手入门>>基础入门>查看文档
	用信号量semaphore实现互斥锁mutex
	文章作者:未知文章来源:水木森林
	查看:92次录入:管理员--2007-11-17
	在doug lea的那本着名的《java并发编程—设计原则与模式》，英文名" concurrent programming in java™: design principles and patterns, second edition"，书中提到可以用信号量semaphore实现互斥锁mutex。虽然java中是通过synchronize关键字提供锁，并用这个基础设施实现信号量的。在有的系统中只有信号量这一原语，锁是通过信号量实现的。代码如下： import java.util.concurrent.semaphore; public class mutex ...{ private semaphore s = new semaphore(1); public void acquire() throws interruptedexception ...{ s.acquire(); } public void release()...{ s.release(); } public boolean attempt(int ms) throws interruptedexception ...{ return s.tryacquire(ms); } } 　上面的代码只能在java5中编译通过，因为semaphore是在java5中才提供的。我在读上面的代码时有疑问。因为如果错误的连续调用release两次，然后两个线程都调用acquire，岂不是这两个线程都可以同时运行，从而违背了互斥锁的定义？为了证明我的猜测，写了如下的代码： public class testmutex ...{ public static void main(string[] args) throws interruptedexception...{ mutex mutex=new mutex(); mutex.acquire(); mutex.release(); mutex.release(); new mythread(mutex).start(); new mythread(mutex).start(); } } class mythread extends thread...{ private mutex mutex; public mythread(mutex mutex) ...{ this.mutex=mutex; } public void run()...{ try ...{ mutex.acquire(); } catch (interruptedexception e1) ...{ throw new runtimeexception(e1); } for(int i=0;i<10;i++)...{ system.out.print(i); if(i%3==0)...{ try ...{ thread.sleep(100); } catch (interruptedexception e) ...{ e.printstacktrace(); } } } mutex.release(); } } 该程序的输出如下： 00123123456456789789 从而证实了我的猜测。作为对比，下面是采用synchronized关键字的互斥锁方案： public class testlock ...{ public static void main(string[] args) throws interruptedexception...{ new mythread2().start(); new mythread2().start(); } } class mythread2 extends thread...{ public void run()...{ synchronized(testlock.class)...{ for(int i=0;i<10;i++)...{ system.out.print(i); if(i%3==0)...{ try ...{ thread.sleep(100); } catch (interruptedexception e) ...{ e.printstacktrace(); } } } } } } 该程序的输出如下： 01234567890123456789 可见两个线程确实互斥运行。　这个问题产生的原因是虽然在mutex的定义中"private semaphore s = new semaphore(1)"，也就是该信号量的初始permits是1，但是在此后每次调用release方法都会导致permits加一。如果能限制permits最大值1，最小值0，那就是真正的mutex了。作为对比，下面是采用synchronized关键字的互斥锁方案： public class testlock ...{ public static void main(string[] args) throws interruptedexception...{ new mythread2().start(); new mythread2().start(); } } class mythread2 extends thread...{ public void run()...{ synchronized(testlock.class)...{ for(int i=0;i<10;i++)...{ system.out.print(i); if(i%3==0)...{ try ...{ thread.sleep(100); } catch (interruptedexception e) ...{ e.printstacktrace(); } } } } } } 该程序的输出如下： 01234567890123456789 可见两个线程确实互斥运行。　这个问题产生的原因是虽然在mutex的定义中"private semaphore s = new semaphore(1)"，也就是该信号量的初始permits是1，但是在此后每次调用release方法都会导致permits加一。如果能限制permits最大值1，最小值0，那就是真正的mutex了。作为对比，下面是采用synchronized关键字的互斥锁方案： public class testlock ...{ public static void main(string[] args) throws interruptedexception...{ new mythread2().start(); new mythread2().start(); } } class mythread2 extends thread...{ public void run()...{ synchronized(testlock.class)...{ for(int i=0;i<10;i++)...{ system.out.print(i); if(i%3==0)...{ try ...{ thread.sleep(100); } catch (interruptedexception e) ...{ e.printstacktrace(); } } } } } } 该程序的输出如下： 01234567890123456789 可见两个线程确实互斥运行。　这个问题产生的原因是虽然在mutex的定义中"private semaphore s = new semaphore(1)"，也就是该信号量的初始permits是1，但是在此后每次调用release方法都会导致permits加一。如果能限制permits最大值1，最小值0，那就是真正的mutex了。