2 u013179958 u013179958 于 2016.04.11 22:12 提问

懂java中lock锁的请进
 package thread;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class Foo {

    private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

    private final Lock r = rwl.readLock();

    private final Lock w = rwl.writeLock();

    public void read() {
        try {
            r.lock();
            Thread.sleep(1000);
            System.out.println("read...");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            r.unlock();
        }

    }

    public void wirte() {

        try {
            w.lock();
            Thread.sleep(1000);
            System.out.println("writing...");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            w.lock();
        }
    }
}

上面是我在书上看到的代码

书上说让我写一个实现runnable接口的类
然后测试读写锁

我没明白,谁能解释下

2个回答

wojiushiwo945you
wojiushiwo945you   Ds   Rxr 2016.04.12 13:20
已采纳

首先,你这个Foo对象必须是被多个线程共享的,然后定义两个任务,一个执行读操作,另一个任务执行写操作,然后定义2个写线程,5个读线程,测试这些线程分别执行读、写操作时不同锁的特点。
其次,你的这个Foo类定义的write的finally分支错误了,应该是w.unlock()才对,稍微修正下你的Foo代码,输出当前线程的名称:

 import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Foo {

    private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

    private final Lock r = rwl.readLock();

    private final Lock w = rwl.writeLock();

    // 读锁,允许同时N个线程进行读操作,不存在竞争
    public void read() {
        try {
            r.lock();
            Thread.sleep(10000);
            System.out.println(Thread.currentThread().getName() + " read...");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            r.unlock();
        }

    }

    //写锁,同时允许一个线程写,明显能看到互斥等待
    public void wirte() {

        try {
            w.lock();
            Thread.sleep(3000);
            System.out.println(Thread.currentThread().getName() + " writing...");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            w.unlock();
        }
    }
}

定义读任务:

 public class LockReadTask implements Runnable{

    private Foo source;

    public LockReadTask(Foo source){
        this.source = source;
    }

    @Override
    public void run() {
        source.read();
    }

}

定义写任务:

 public class LockWriteTask implements Runnable{
    private Foo source;

    public LockWriteTask(Foo source){
        this.source = source;
    }

    @Override
    public void run() {
        source.wirte();
    }
}

测试代码,定义2个写线程,看写锁的竞争状态;4个读线程,读锁步存在竞争。

 public class Main {
    public static void main(String[] args) {
        //定义共享数据源
        Foo source = new Foo();

        //开启2个写线程:能明显看到t1,t2写线程之间的互斥等待
        Thread t1 = new Thread(new LockWriteTask(source));
        t1.setName("write-Thread-1");
        Thread t2 = new Thread(new LockWriteTask(source));
        t2.setName("write-Thread-2");
        t1.start();
        t2.start();

        //开启5个读线程:读锁,允许同时N个线程进行操作,可以看到读打印操作同时秒出
        Thread rt1 = new Thread(new LockReadTask(source));
        rt1.setName("read-Thread-1");
        Thread rt2 = new Thread(new LockReadTask(source));
        rt2.setName("read-Thread-2");
        Thread rt3 = new Thread(new LockReadTask(source));
        rt3.setName("read-Thread-3");
        Thread rt4 = new Thread(new LockReadTask(source));
        rt4.setName("read-Thread-4");

        rt1.start();
        rt2.start();
        rt3.start();
        rt4.start();
    }
}   

可以看到测试结果:写线程之间有竞争,输出信息由先后;而都线程之间的读锁匙共享的,没有竞争,所以输出是同时秒出的。

wojiushiwo945you
wojiushiwo945you 回复据说名字太长不容易被发现: 谢谢。
一年多之前 回复
u013179958
u013179958 回复毕小宝: 赞一个
一年多之前 回复
wojiushiwo945you
wojiushiwo945you 读写锁真正需要测试的是,某个线程获取写锁时,其他线程不能读、不能写;而某个线程获取读锁时,其他线程仍然还可以读,即还可以获取读锁。
一年多之前 回复
caozhy
caozhy   Ds   Rxr 2016.04.11 23:46

一般经典的例子就是开两个线程,给一个共有的变量累加。每个线程比如各累加10万次。按理说结果应该是20万。
但是如果你不同步线程,结果就会小于20万。

u013179958
u013179958 那我想测一测我的这个例子,我应该怎么么做?
一年多之前 回复
Csdn user default icon
上传中...
上传图片
插入图片
准确详细的回答,更有利于被提问者采纳,从而获得C币。复制、灌水、广告等回答会被删除,是时候展现真正的技术了!