秒杀多线程第十四篇 读者写者问题继 读写锁SRWLock (续)

java 包实现了读写锁的操作:

package com.multithread.readwritelock;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

import com.multithread.main.ExampleInterface;
import com.multithread.readwrite.WriteThread;

public class ReadWriteLockExample extends ExampleInterface {

    public ReadWriteLock mReadwriteLock = new ReentrantReadWriteLock(false);
    public File mFile = null;
    public int mCash = 10000;
    public CountDownLatch mLatchDown = new CountDownLatch(6);
    private boolean mStopedFlag = false;

    @Override
    public void startDemo() {
        // TODO Auto-generated method stub
        mFile = new File("H:\\Project\\SST\\123.txt");
        try {

            mFile.createNewFile();
            Executor mEcecutor = Executors.newFixedThreadPool(2 + 4);
            mEcecutor.execute(new Reader("Reader1"));
            mEcecutor.execute(new Reader("Reader2"));
            mEcecutor.execute(new Reader("Reader3"));
            mEcecutor.execute(new Reader("Reader4"));
            mEcecutor.execute(new Writer("Writer1", 2000));
            mEcecutor.execute(new Writer("Writer2", -3000));

            mLatchDown.await();
            System.out.println("[startDemo]" + "Demo down");

        } catch (IOException | InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public class Reader extends Thread {

        public String name = null;
        boolean flag = true;
        private int index = 0;

        public Reader(String name) {
            this.name = name;
        }

        @Override
        public void run() {
            while (flag) {
                try {
                    mReadwriteLock.readLock().lock();
                    System.out.println("[Reader]" + name + "start");
                    Thread.sleep((long) (Math.random() * 100));
                    if (!mStopedFlag) {
                        System.out.println("[Reader]" + name + "get mcash now:"
                                + mCash);
                    } else {
                        flag = false;
                    }
                    Thread.sleep((long) (Math.random() * 100));
                    System.out.println("[Reader]" + name + "down");
                    mReadwriteLock.readLock().unlock();
                    Thread.sleep((long) (Math.random() * 1000));
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            }
            mLatchDown.countDown();

        }

    }

    public class Writer extends Thread {

        public String name = null;
        boolean flag = true;
        private int index = 0;
        private int cash = 0;

        public Writer(String name, int addcash) {
            this.name = name;
            this.cash = addcash;
        }

        @Override
        public void run() {
            System.out.println("[Writer]" + name + "start");
            while (flag) {

                try {
                    mReadwriteLock.writeLock().lock();
                    System.out.println("[Writer]" + name + "start");
                    Thread.sleep((long) (Math.random() * 100));
                    int oldcash = mCash;
                    if (mCash <= 0) {
                        flag = false;
                        mStopedFlag = true;
                    } else {
                        mCash += cash;
                        System.out.println("[Writer]" + name
                                + "operator cash old:" + oldcash + " To:"
                                + mCash);
                    }
                    Thread.sleep((long) (Math.random() * 100));
                    System.out.println("[Writer]" + name + "down");
                    mReadwriteLock.writeLock().unlock();
                    Thread.sleep((long) (Math.random() * 1000));
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            }
            mLatchDown.countDown();
        }

    }

}

读写锁的特点就是:

1.写者与读者是互斥的

2.每个写者之间是互斥的

3.读者之间可以同时进行

时间: 2024-10-30 20:58:54

秒杀多线程第十四篇 读者写者问题继 读写锁SRWLock (续)的相关文章

转---秒杀多线程第十四篇 读者写者问题继 读写锁SRWLock

在<秒杀多线程第十一篇读者写者问题>文章中我们使用事件和一个记录读者个数的变量来解决读者写者问题.问题虽然得到了解决,但代码有点复杂.本篇将介绍一种新方法——读写锁SRWLock来解决这一问题.读 写锁在对资源进行保护的同时,还能区分想要读取资源值的线程(读取者线程)和想要更新资源的线程(写入者线程).对于读取者线程,读写锁会允许他们并发的 执行.当有写入者线程在占有资源时,读写锁会让其它写入者线程和读取者线程等待.因此用读写锁来解决读者写者问题会使代码非常清晰和简洁. 下面就来看看如何使用读

多线程面试题系列(14):读者写者问题继 读写锁SRWLock

在第十一篇文章中我们使用事件和一个记录读者个数的变量来解决读者写者问题.问题虽然得到了解决,但代码有点复杂.本篇将介绍一种新方法--读写锁SRWLock来解决这一问题.读写锁在对资源进行保护的同时,还能区分想要读取资源值的线程(读取者线程)和想要更新资源的线程(写入者线程).对于读取者线程,读写锁会允许他们并发的执行.当有写入者线程在占有资源时,读写锁会让其它写入者线程和读取者线程等待.因此用读写锁来解决读者写者问题会使代码非常清晰和简洁. 下面就来看看如何使用读写锁,要注意编译读写锁程序需要V

秒杀多线程第十六篇 多线程十大经典案例之一 双线程读写队列数据

版权声明:本文为博主原创文章,未经博主允许不得转载. 目录(?)[+] 本文配套程序下载地址为:http://download.csdn.net/detail/morewindows/5136035 转载请标明出处,原文地址:http://blog.csdn.net/morewindows/article/details/8646902 欢迎关注微博:http://weibo.com/MoreWindows 在<秒杀多线程系列>的前十五篇中介绍多线程的相关概念,多线程同步互斥问题<秒杀多

秒杀多线程第十五篇 关键段,事件,互斥量,信号量的“遗弃”问题

版权声明:本文为博主原创文章,未经博主允许不得转载. 目录(?)[+] 秒杀多线程第十五篇 关键段,事件,互斥量,信号量的“遗弃”问题 在<秒杀多线程第九篇 经典线程同步总结 关键段 事件 互斥量 信号量>中对经典多线程同步互斥问题进行了回顾和总结,这篇文章对Windows系统下常用的线程同步互斥机制——关键段.事件.互斥量.信号量进行了总结.有网友问到互斥量能处理“遗弃”问题,事件和信号量是否也能处理“遗弃”问题.因此本文将对事件和信号量作个试验,看看事件和信号量能否处理“遗弃”问题. 一.

转---秒杀多线程第十二篇 多线程同步内功心法——PV操作上

阅读本篇之前推荐阅读以下姊妹篇: <秒杀多线程第四篇一个经典的多线程同步问题> <秒杀多线程第五篇经典线程同步关键段CS> <秒杀多线程第六篇经典线程同步事件Event> <秒杀多线程第七篇经典线程同步互斥量Mutex> <秒杀多线程第八篇经典线程同步信号量Semaphore> <秒杀多线程第九篇经典线程同步总结关键段事件互斥量信号量> <秒杀多线程第十篇生产者消费者问题> <秒杀多线程第十一篇读者写者问题>

秒杀多线程第十二篇 多线程同步内功心法——PV操作上

阅读本篇之前推荐阅读以下姊妹篇: <秒杀多线程第四篇一个经典的多线程同步问题> <秒杀多线程第五篇经典线程同步关键段CS> <秒杀多线程第六篇经典线程同步事件Event> <秒杀多线程第七篇经典线程同步互斥量Mutex> <秒杀多线程第八篇经典线程同步信号量Semaphore> <秒杀多线程第九篇经典线程同步总结关键段事件互斥量信号量> <秒杀多线程第十篇生产者消费者问题> <秒杀多线程第十一篇读者写者问题>

秒杀多线程第十一篇 读者写者问题

与上一篇<秒杀多线程第十篇 生产者消费者问题>的生产者消费者问题一样,读者写者也是一个非常著名的同步问题.读者写者问题描述非常简单,有一个写者很多读者,多个读者可以同时读文件,但写者在写文件时不允许有读者在读文件,同样有读者在读文件时写者也不去能写文件. 上面是读者写者问题示意图,类似于生产者消费者问题的分析过程,首先来找找哪些是属于“等待”情况. 第一.写者要等到没有读者时才能去写文件. 第二.所有读者要等待写者完成写文件后才能去读文件. 找完“等待”情况后,再看看有没有要互斥访问的资源.由

转---秒杀多线程第十一篇 读者写者问题

与上一篇<秒杀多线程第十篇 生产者消费者问题>的生产者消费者问题一样,读者写者也是一个非常著名的同步问题.读者写者问题描述非常简单,有一个写者很多读者,多个读者可以同时读文件,但写者在写文件时不允许有读者在读文件,同样有读者在读文件时写者也不去能写文件. 上面是读者写者问题示意图,类似于生产者消费者问题的分析过程,首先来找找哪些是属于“等待”情况. 第一.写者要等到没有读者时才能去写文件. 第二.所有读者要等待写者完成写文件后才能去读文件. 找完“等待”情况后,再看看有没有要互斥访问的资源.由

转----秒杀多线程第十篇 生产者消费者问题

继经典线程同步问题之 后,我们来看看生产者消费者问题及读者写者问题.生产者消费者问题是一个著名的线程同步问题,该问题描述如下:有一个生产者在生产产品,这些产品将提供给 若干个消费者去消费,为了使生产者和消费者能并发执行,在两者之间设置一个具有多个缓冲区的缓冲池,生产者将它生产的产品放入一个缓冲区中,消费者可以从 缓冲区中取走产品进行消费,显然生产者和消费者之间必须保持同步,即不允许消费者到一个空的缓冲区中取产品,也不允许生产者向一个已经放入产品的缓冲区中 再次投放产品. 这个生产者消费者题目不仅