读写锁原理

Question

用一个全局的boolean值做标志，在线程写资源之前判断boolean值，如为true（代表没有线程执行写操作），则把boolean值置为false，写完之后置为true，读资源不受限制。

Answer 1

写完之后不能置为true,因为因为有其它线程可能正在读,我参考写了一个如下
package com.yinzhaohui.container.sequance;/**
 * Created on 2004-7-25 Create author yinzhaohui
 */
public class ReadWriteLock
{
    //最大写等待线程数（如为n表于，当有n个写等待线程时那么不再允许读线读只有等到写线程写了后读线程才会写的）是用于写优先的方式
    private long maxWritersWaiting = 1;
    private boolean writingInProgress = false; //当前是否在写中
    private long writersWaiting = 0;  //当前等待的写线程数
    private long readers = 0;  //当前读线程数    public static ReadWriteLock CreateReadWriteLock(long maxWritersWaiting)
    {
        ReadWriteLock readWriteLock = new ReadWriteLock();
        readWriteLock.maxWritersWaiting=maxWritersWaiting;
        return readWriteLock;
    }
       
    //获取读锁
    public synchronized void getReadLock()
    {
        while (writingInProgress || (writersWaiting >= maxWritersWaiting))
        {
            try
            {
                wait();
            }
            catch (InterruptedException ie)
            {
            }
        }
        readers++;
    }    //获取写锁
    public synchronized void getWriteLock()
    {
        writersWaiting++;
        while ((readers > 0) || writingInProgress)
        {
            try
            {
                wait();
            }
            catch (InterruptedException ie)
            {
            }
        }
        writersWaiting--;
        writingInProgress = true;
    }    //释放读销
    public synchronized void releaseReadLock()
    {
        readers--;
        if ((readers == 0) && (writersWaiting > 0))
        {
            notifyAll();
        }
    }
    
    //释放写销
    public synchronized void releaseWriteLock()
    {
        writingInProgress = false;
        notifyAll();
    }
    
    /**
     * 静态方法
     * @param readWriteLock
     */
    public static void acquireReadLock(ReadWriteLock readWriteLock)
    {
        readWriteLock.getReadLock();
    }
    
    public static void acquireWriteLock(ReadWriteLock readWriteLock)
    {
        readWriteLock.getWriteLock();
    }
    
    public static void destoryReadLock(ReadWriteLock readWriteLock)
    {
        readWriteLock.releaseReadLock();
    }
    
    public static void destoryWriteLock(ReadWriteLock readWriteLock)
    {
        readWriteLock.releaseWriteLock();
    }
    
    
    
}

Answer 2

就是操作系统中的P、V操作呀，
呵， satangf(好好学习，天天向上！) 的办法应该是可行的。

Answer 3

最易懂的办法
public class Lock{
  public Lock(){}
}public class aaa{
  Lock l = new Lock();
  ...
  synchronized(l){
    同步操作...
  }
  ...
}

Answer 4

nhk_csdn(我呢) 你这样会行吗?

Answer 5

没有问题，我试过多次了，很方便，只要保证Lock实例化一次就可以了