在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了。
闽公网安备 35060202000074号