java的互斥_转帖

这个文章不错

 

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了。

 

---摘自http://java.chinaitlab.com/advance/724058_2.html

你可能感兴趣的:(java)