读/写Lock实现在Java中

Question

我读到有关某些网页的锁，并试图有些网站所描述的基本情况运行。我是新线程使用，因此这是怎样的代码查找文件，

1）读写锁功能（非重入，很基本的）

public ReadWriteLock() { 
    // TODO Auto-generated constructor stub 
} 



synchronized void readLock(String name) throws InterruptedException { 
    //tname = threadName; 

    if(writers>0 || writereq>0){ 
     wait(); 
    } 
    readers++; 
    System.out.println(name + " locks for reading resource...."); 
} 
synchronized void readUnLock(String name) throws InterruptedException{ 
    //tname = threadName; 
    readers--; 
    System.out.println(name + "unlocks reading resource...."); 
    notifyAll(); 
} 
synchronized void writeLock(String name) throws InterruptedException{ 
    //tname = threadName; 
    writereq++; 
    if(writers>0 || readers>0){ 
     System.out.println(name + " waits for writing..."); 
     wait(); 
    } 
    writereq--; 
    writers++; 
    System.out.println(" locks for writing resource...."); 
} 
synchronized void writeUnLock(String name) throws InterruptedException{ 
    //tname = threadName; 
    writers--; 
    System.out.println(name + " unlocks for writing resource...."); 
    notifyAll(); 

} 

2）的implementaiton可运行的界面，

public class Runner implements Runnable{ 

private ReadWriteLock rwl; 
private String name; 
public Runner(ReadWriteLock rwl, String name) { 
    // TODO Auto-generated constructor stub 
    this.rwl=rwl; 
    this.name = name; 
} 

void runlocks(int method){ 
    //String name = Thread.currentThread().getName(); 
    switch(method){ 
    case 1: 
     try { 
      rwl.readLock(name); 
     } catch (InterruptedException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     }break; 
    case 2: 
     try { 
      rwl.readUnLock(name); 
     } catch (InterruptedException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } break; 
    case 3: 
     try { 
      rwl.writeLock(name); 
     } catch (InterruptedException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } break; 
    case 4: 
     try { 
      rwl.writeUnLock(name); 
     } catch (InterruptedException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } break; 

    } 
} 

@Override 
public void run() { 
    //String name = Thread.currentThread().getName(); 
    // TODO Auto-generated method stub 
    //System.out.println("Thread started "+ name); 

    //int method = 1; 
    // TODO Auto-generated method stub 
    //System.out.println(this.threadName + " has started!"); 

} 

3）将试验CALSS

public class TestClass { 
public static void main(String[] args) throws InterruptedException { 
ReadWriteLock rwl = new ReadWriteLock(); 
Runner r1 =new Runner(rwl,"Thread1"); 
Thread t1 = new Thread(r1); 
t1.setName("Thread1"); 

Runner r2 =new Runner(rwl,"Thread2"); 
Thread t2 = new Thread(r2); 
t2.setName("Thread2"); 

t1.start(); 
t2.start(); 

r1.runlocks(1); //r1 locks to read 
r2.runlocks(1); //r2 locks to read 
r1.runlocks(2); //r1 unlocks read 
r2.runlocks(2); //r1 unlocks read 

r1.runlocks(3); //r1 locks to write 
r2.runlocks(1); //r2 tries to lock for read but waits.. and the code gets struck here 
r1.runlocks(4); //r1 releases lock of write 
} 

}

我的问题是..在测试类，线程1获取锁来写，那么线程2次尝试阅读，但它不能和等待。这时下面的语句是线程1个解锁写锁应执行和线程2自然应该读取锁定。但是这种情况并没有发生。是否有我缺少理解的东西？

Answer 1

你完全错过的是，你的测试启动了两个完全没有任何功能的线程，并立即停止运行，并且其余代码由一个线程按顺序执行：主线程。

事实上，您可运行没有按的run（）方法包含什么，但评论：

public void run() { 
    //String name = Thread.currentThread().getName(); 
    // TODO Auto-generated method stub 
    //System.out.println("Thread started "+ name); 

    //int method = 1; 
    // TODO Auto-generated method stub 
    //System.out.println(this.threadName + " has started!"); 
} 

而且我的建议是：了解线程一个很好的教程和java.util.concurrent类，它提供了简单易用，高层次的抽象。从lowèlevel方法，如wait()和notify()望而却步。

Answer 2

并发可能看起来像一个野兽在第一，这可能是因为它是一个不同的风味代码进展。对于您拥有的每个线程（并且您始终至少有一个用于您的进程），处理器会为每个线程分配少量时间进行处理。如果你已经使用过Swing，那么你已经有了一些并发的经验，因为每个JFrame实例化的都是一个新的线程。

由于每个线程只允许一小段时间，因此在修改对象时可能会在计算过程中停止。如果下一个线程也尝试修改这个相同的对象，您将收到一个ConcurrentModificationException异常。当使用Collections作为许多不是线程安全的，包括迭代器时，这是非常明显的。这就是锁进入的地方，并防止线程同时修改相同的资源。一个线程将对一个对象放置一个同步锁，任何试图访问该资源的线程都将被阻塞，直到发出该锁的线程退出同步部分。如果你有一个无限循环或从锁内的其他线程锁定的对象，你可能会遇到在其中没有任何进展可以制成具有锁也被阻止线程死锁。

我不能完全确定你的问题是什么，或者是否有任何。但多读一点并发性总会有帮助。