读者写者问题

book抽象类下面是读者优先，写者优先，公平，每个类对read，write重写
reader和writer线程调用book

import java.util.concurrent.Semaphore;

import java.lang.Thread;

/**
 * 读者优先
 * 当有读者源源不断（个人理解是前一个还未出访问区，后一个就在等待/进入）进入时，写者会一直阻塞
 * readerSemaphore   读者对读者个数修改互斥访问
 * readerAndWriterSemaphore  读者和写者对数据的互斥访问
 * 写者优先
 * 当有写者源源不断进入时，读者会一直阻塞
 * readerAndWriterSemaphore
 * readerSemaphore
 * WriterPrioritySemaphore  当有写者在等待时，阻塞读者
 * writerSemaphore  写者个数的互斥访问
 * 公平
 * 公平竞争
 * 每次两者公平竞争FairSemaphore，不能立即释放，不然最后还是读者优先。
 * 2022-06-14 17:09
 */
abstract class Book  {
    abstract void read(String name) throws InterruptedException;
    abstract void write(String name) throws InterruptedException;
}
class ReaderPriorityBook extends Book {
    int readerCount = 0;
    Semaphore readerAndWriterSemaphore = new Semaphore(1);
    Semaphore readerSemaphore = new Semaphore(1);
    void read(String name) throws InterruptedException {
        readerSemaphore.acquire();
//        互斥访问readerCount，拿锁
        if (readerCount == 0){
            readerAndWriterSemaphore.acquire();
        }
        readerCount++;
        readerSemaphore.release();

        System.out.println(name+"reading");

//        互斥访问readerCount，看条件是否释放锁
        readerSemaphore.acquire();
        readerCount--;
        if (readerCount == 0){
            readerAndWriterSemaphore.release();
        }
        readerSemaphore.release();
//        Thread.sleep(100);
    }

    void write(String name) throws InterruptedException {
//        拿到锁后写，写完释放锁
        readerAndWriterSemaphore.acquire();
        System.out.println(name+"writing");

        readerAndWriterSemaphore.release();
//        Thread.sleep(100);
    }
}
class WriterPriorityBook extends Book {
    int readerCount = 0;
    int writeCount = 0;
    Semaphore readerAndWriterSemaphore = new Semaphore(1);
    Semaphore WriterPrioritySemaphore = new Semaphore(1);
    Semaphore readerSemaphore = new Semaphore(1);
    Semaphore writerSemaphore = new Semaphore(1);
    void read(String name) throws InterruptedException {

        WriterPrioritySemaphore.acquire();
        readerSemaphore.acquire();
//        互斥访问readerCount，拿锁
        if (readerCount == 0){
            readerAndWriterSemaphore.acquire();
        }
        readerCount++;
        readerSemaphore.release();
        WriterPrioritySemaphore.release();

        System.out.println(name+"reading");

//        互斥访问readerCount，看条件是否释放锁
        readerSemaphore.acquire();
        readerCount--;
        if (readerCount == 0){
            readerAndWriterSemaphore.release();
        }
        readerSemaphore.release();

//        Thread.sleep(100);
    }

    void write(String name) throws InterruptedException {
//        拿到锁后写，写完释放锁
        writerSemaphore.acquire();
        if (writeCount == 0){
            WriterPrioritySemaphore.acquire();
        }
        writeCount++;
        writerSemaphore.release();

        readerAndWriterSemaphore.acquire();
        System.out.println(name+"writing");
        readerAndWriterSemaphore.release();

        writerSemaphore.acquire();
        writeCount--;
        if (writeCount == 0){
            WriterPrioritySemaphore.release();
        }
        writerSemaphore.release();

//        Thread.sleep(100);

    }
}
class FairBook extends Book {
    int readerCount = 0;
    Semaphore readerAndWriterSemaphore = new Semaphore(1);
    Semaphore readerSemaphore = new Semaphore(1);
    Semaphore FairSemaphore = new Semaphore(1);

    void read(String name) throws InterruptedException {
        FairSemaphore.acquire();
        readerSemaphore.acquire();
//        Thread.sleep(100);
//        互斥访问readerCount，拿锁
        if (readerCount == 0){
            readerAndWriterSemaphore.acquire();
        }
        readerCount++;
        readerSemaphore.release();
        FairSemaphore.release();
//        Thread.sleep(100);
        System.out.println(name+"reading");

//        互斥访问readerCount，看条件是否释放锁
        readerSemaphore.acquire();
        readerCount--;
        if (readerCount == 0){
            readerAndWriterSemaphore.release();
        }
        readerSemaphore.release();
//        Thread.sleep(100);
    }

    void write(String name) throws InterruptedException {
        FairSemaphore.acquire();
//        Thread.sleep(100);
//        拿到锁后写，写完释放锁
        readerAndWriterSemaphore.acquire();
        System.out.println(name+"writing");
        readerAndWriterSemaphore.release();

        FairSemaphore.release();
//        Thread.sleep(100);
    }
}

class Reader extends Thread{
    private final Book book;
    private final String name;

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

    @Override
    public void run() {
       while (true){
           try {
               book.read(name+": ");
           } catch (InterruptedException e) {
               throw new RuntimeException(e);
           }
       }
    }
}
class Writer extends Thread{
    final private Book book;
    final private String name;
    public Writer(Book book,String name) {
        this.book = book;
        this.name = name;
    }

    @Override
    public void run() {
        while (true){
            try {
                book.write(name+": ");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
public class ReaderAndWriter_ReaderPriority {
    public static void main(String[] args) {
        ReaderPriorityBook readerPriorityBook = new ReaderPriorityBook();
        WriterPriorityBook writerPriorityBook = new WriterPriorityBook();
        FairBook fairBook = new FairBook();
//         读者优先
//        new Reader(readerPriorityBook,"r1").start();
//        new Reader(readerPriorityBook,"r2").start();
//        new Writer(readerPriorityBook,"w1").start();
//        new Writer(readerPriorityBook,"w2").start();
//         写者优先
        new Reader(writerPriorityBook,"r1").start();
        new Reader(writerPriorityBook,"r2").start();
        new Writer(writerPriorityBook,"w1").start();
        new Writer(writerPriorityBook,"w2").start();
//         公平
//        new Reader(fairBook,"r1").start();
//        new Reader(fairBook,"r2").start();
//        new Writer(fairBook,"w1").start();
//        new Writer(fairBook,"w2").start();
    }
}