读写锁使用的Demo分析

之前我们提到的锁都是排它锁（同一时刻只允许一个线程进行访问），而读写锁维护了一对锁，一个读锁，一个写锁。读写锁在同一时刻允许多个线程进行读操作，但是写线程访问过程中，所有的读线程和其他写线程均被阻塞。如此，并发性有了很大的提升。这样，在某些读远远大于写的场景中，读写锁能够提供比排它锁更好的并发量和吞吐量。

本文源码可在我的github中找到。

一个关于读写锁的Demo：

分析：设计一个模拟队列，拥有一个data成员变量用于存储数据和存取两种操作。

import java.util.Random;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockDemo
{

    public static void main(String[] args)
    {
        DefQueue queue = new DefQueue();
        for (int i = 1; i < 10; i++)
        {
            //启动线程进行读操作
            new Thread(new Runnable()
            {
                @Override
                public void run()
                {
                    while (true)
                    {
                        queue.get();
                    }
                }

            }).start();

            //启动线程进行写操作
            new Thread(new Runnable()
            {
                @Override
                public void run()
                {
                    while(true)
                    {
                        queue.put(new Random().nextInt(10000));
                    }
                }
            }).start();
        }
    }

}

class DefQueue
{
    private int data;
    ReadWriteLock rwLock = new ReentrantReadWriteLock();

    public void get()
    {
        rwLock.readLock().lock();//加读锁
        try
        {
            System.out.println(Thread.currentThread().getName() + "be ready to get data");
            Thread.sleep((long) (Math.random() * 1000));

            System.out.println(Thread.currentThread().getName() + "get the data:    " + data);

        } catch (InterruptedException e)
        {
            e.printStackTrace();
        } finally
        {
            rwLock.readLock().unlock();//释放读锁
        }
    }

    public void put(int data)
    {
        rwLock.writeLock().lock();//加写锁

        try
        {
            System.out.println(Thread.currentThread().getName() + " be ready to write data");

            Thread.sleep((long) (Math.random() * 1000));

            this.data = data;

            System.out.println(Thread.currentThread().getName() + " has wrote the data:  "+data);
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        } finally
        {
            rwLock.writeLock().unlock();//释放写锁
        }

    }
}

程序部分运行结果：

Thread-0be ready to get data
Thread-0get the data:    0
Thread-1 be ready to write data
Thread-1 has wrote the data:  1156
Thread-2be ready to get data
Thread-2get the data:    1156
Thread-3 be ready to write data
Thread-3 has wrote the data:  9784
Thread-3 be ready to write data
Thread-3 has wrote the data:  4370
Thread-3 be ready to write data
Thread-3 has wrote the data:  1533
Thread-4be ready to get data
Thread-4get the data:    1533
Thread-5 be ready to write data
Thread-5 has wrote the data:  2345
Thread-6be ready to get data
Thread-6get the data:    2345
Thread-9 be ready to write data
Thread-9 has wrote the data:  9463
Thread-9 be ready to write data
Thread-9 has wrote the data:  9301
Thread-9 be ready to write data
Thread-9 has wrote the data:  549
Thread-9 be ready to write data
Thread-9 has wrote the data:  4673
Thread-9 be ready to write data

我们可以看到打印语句结果很正常。

下面我们再来实现一个模拟缓冲区的小Demo：

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/*
 * @author vayne
 * 
 * 多线程实现缓存的小demo
 */
class Cachend
{
    volatile Map<String, String> cachmap = new HashMap<String, String>();//加volatile关键字保证可见性。

    ReadWriteLock rwLock = new ReentrantReadWriteLock();//这个读写锁要定义在方法外面，使得每一个线程用的是同一个读写锁。
    public  String getS(String key)                     //如果定义在方法内部，就是跟方法栈有关的读写锁。这样可能不是同一个锁。
    {
        rwLock.readLock().lock();
        String value = null;
        try
        {
            value = cachmap.get(key);

            if (cachmap.get(key) == null)//这里要重新获得key对应的value值
            {
                rwLock.readLock().unlock();
                rwLock.writeLock().lock();
                try
                {
                    if (cachmap.get(key) == null)//这里也是
                    {
                        value = "" + Thread.currentThread().getName();

                        cachmap.put(key, value);

                        System.out.println(Thread.currentThread().getName()  + "  put the value ::::" + value);
                    }
                } finally
                {
                    rwLock.readLock().lock();   //将锁降级，这里跟下一句的顺序不能反。
                    rwLock.writeLock().unlock();//关于这里的顺序问题，下面我会提到。
                }
            }

        } finally
        {
            rwLock.readLock().unlock();
        }

        return cachmap.get(key);
    }
}

public class CachendDemo
{
    public static void main(String[] args)
    {
        Cachend ca = new Cachend();
        for (int i = 0; i < 4; i++)
        {
            new Thread(new Runnable()
            {
                @Override
                public void run()
                {
                    System.out.println(Thread.currentThread().getName()+"  "+ca.getS("demo1"));
                    System.out.println(Thread.currentThread().getName()+"  "+ca.cachmap.entrySet());
                }
            }).start();
        }
    }
}

运行结果：

Thread-0  put the value ::::Thread-0
Thread-0  Thread-0
Thread-0  [demo1=Thread-0]
Thread-2  Thread-0
Thread-2  [demo1=Thread-0]
Thread-3  Thread-0
Thread-3  [demo1=Thread-0]
Thread-1  Thread-0
Thread-1  [demo1=Thread-0]

上面我给出了一些注释，其实这个代码是很不好写的，考虑的东西很多。下面我来讲一下上面的代码中提到的顺序问题。

对于读写锁我们应该了解下面的一些性质（这些性质是由源代码得出来的，因为源代码的设计，所以才有下列性质）：

• 如果存在读锁，则写锁不能被获取，原因在于：读写锁要确保写锁的操作对读锁可见。，如果允许读锁在已被获取的情况下对写锁的获取，那么正在运行的其他读线程就无法感知到当前写线程的操作。因此，只有等待其他读线程都释放了读锁，写锁才能被当前线程获取，而写锁一旦被获取，则其他读写线程的后续访问将会被阻塞。
• 锁降级：指的是写锁降级成为读锁。具体操作是获取到写锁之后，在释放写锁之前，要先再次获取读锁。这也就是上面我写注释提醒大家注意的地方。为什么要这样处理呢，答案就是为了保证数据可见性。如果当前线程不获取读锁而是直接释放写锁，假设此刻另一个线程（记作T）获取了写锁并修改了数据，那么当前线程无法感知线程T的数据更新。如果当前线程获取读锁，即遵循锁降级的步骤，则线程T将会被阻塞，知道当前线程使用数据并释放读锁之后，T才能获取写锁进行数据更新。

第二条对应我们上面的程序就是，如果我们添加了“demo1”对应的value值，然后释放了写锁，此时在当前线程S还未获得读锁时，另一个线程T又获得了写锁，那么就会将S的操作给覆盖（如果取到的值已经缓存在S中，那么T的操作就无法被S感知了，到最后依然会返回S操作的值）。

最后

以上就是结实微笑为你收集整理的读写锁使用的Demo分析的全部内容，希望文章能够帮你解决读写锁使用的Demo分析所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。