读者写者问题 | Java实现（详细注释）

写在前面

欢迎讨论！！

---

问题描述

题目：用JAVA语言的同步方法解决读者/写者问题，要求写者优先
要求：编写一个含有同步方法的类，其中含有四个同步方法start_read, finish_read, start_write, finish_write。
说明：读者使用方法：{start_read, 读操作, finish_read}; 写者使用方法：{start_write, 写操作, finish_write}。创建若干个读者和若干个写者，执行上述操作，并输出当前访问数据的读者或写者数量。

---

Java实现

Disk模拟磁盘
Reader 模拟读者
Writer 模拟写者
Main 启动线程

---

Disk类

import java.util.concurrent.Semaphore;

/**
 * 模拟被读和被写的对象
 */
public class Disk implements Runnable{
    private String data_str;    /*读写数据*/
    private int reader_count;   /*读者计数*/
    private Semaphore write_mutex;  /*写者信号量*/
    private Semaphore read_mutex;   /*读者信号量*/
    private Semaphore read_count_mutex; /*修改读者计数的信号量*/

    Disk()
    {
        /*new和设置最大信号量数*/
        write_mutex=new Semaphore(1);
        read_mutex=new Semaphore(1000);
        read_count_mutex=new Semaphore(1);
    }

    public void start_read() throws InterruptedException {
        /*有写者时忙等*/
        while (write_mutex.availablePermits()==0){ }

        /*修改读者计数*/
        read_count_mutex.acquire();
        reader_count++;
        read_count_mutex.release();

        /*获取信号量*/
        read_mutex.acquire();

    }

    public void finish_read() throws InterruptedException {

        /*修改读者计数*/
        read_count_mutex.acquire();
        reader_count--;
        read_count_mutex.release();

        /*获取读者信号量*/
        read_mutex.release();

    }

    public void start_write() throws InterruptedException {
        /*获取写者信号量*/
        write_mutex.acquire();
        /*当有读者时忙等*/
        while (getReader_count()!=0){}
    }

    public void finish_write()
    {
        /*释放写者信号量*/
        write_mutex.release();
    }

    /**
     * 读操作
     * @return 读取的数据
     * @throws InterruptedException
     */
    public String read() throws InterruptedException {
        return data_str;
    }

    /**
     * 写操作
     * @param new_data 写入的数据
     * @return 写入后的数据
     * @throws InterruptedException
     */
    public String write(String new_data) throws InterruptedException {
        this.data_str=new_data;
        return data_str;
    }

    public int getReader_count() {
        return reader_count;
    }

    public void setReader_count(int reader_count) {
        this.reader_count = reader_count;
    }

    @Override
    public void run() {

    }
}

---

Reader类

import java.util.concurrent.Semaphore;

/**
 * 模拟读者
 */
public class Reader implements Runnable {
    private Disk disk;

    public Reader(Disk disk) {
        this.disk = disk;
    }

    @Override
    public void run() {
        for (int i=10;i>=0;i--)
        {
            /*读操作*/
            try {
                read();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            /*暂停1s*/
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private void read() throws InterruptedException {
        disk.start_read();
        /*读数据并打印*/
        String str=disk.read();
        System.out.println("读操作："+Thread.currentThread().getId()+" 现在的数据为："+str);
        disk.finish_read();
    }

}

---

Writer类

/**
 * 模拟写者
 */
public class Writer implements Runnable{
    private Disk disk;

    public Writer(Disk disk) {
        this.disk = disk;
    }

    @Override
    public void run() {

        for (int i=10;i>=0;i--)
        {
            /*写操作*/
            try {
                write();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            /*等待1s*/
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private void write() throws InterruptedException {
        disk.start_write();
        /*写数据并打印*/
        String str=disk.write("data+"+Thread.currentThread().getId());
        System.out.println("写操作："+Thread.currentThread().getId()+" 现在的数据为："+str);
        disk.finish_write();

    }
}

---

Main 类

/**
 * 主函数
 */
public class Main {
    public static void main(String[] args) throws InterruptedException {
        int writerNumber=3;
        int readerNumber=7;
        int diskNumber=1;
        Disk[] disks=new Disk[diskNumber];
        Thread[] writer_threads=new Thread[writerNumber];
        Writer[] writers=new Writer[writerNumber];
        Thread[] reader_threads=new Thread[readerNumber];
        Reader[] readers=new Reader[readerNumber];
        Thread[] disk_threads=new Thread[diskNumber];

        /*模拟磁搬线程启动*/
        for (int i=0;i<diskNumber;i++)
        {
            disks[i]=new Disk();
            disk_threads[i]=new Thread(disks[i],Integer.toString(i));
            disk_threads[i].start();
        }


        /*启动部分写者*/
        for (int i=0;i<writerNumber/2;i++)
        {
            writers[i]=new Writer(disks[0]);
            writer_threads[i]=new Thread(writers[i],Integer.toString(i));
            writer_threads[i].start();
        }

        /*暂停等待写者启动*/
        Thread.sleep(100);
        /*启动读者*/
        for (int i=0;i<readerNumber;i++)
        {
            readers[i]=new Reader(disks[0]);
            reader_threads[i]=new Thread(readers[i],Integer.toString(i));
            reader_threads[i].start();
        }

        /*追加启动写者*/
        for (int i=writerNumber/2;i<writerNumber;i++)
        {
            writers[i]=new Writer(disks[0]);
            writer_threads[i]=new Thread(writers[i],Integer.toString(i));
            writer_threads[i].start();
        }

    }
}

---

实验结果