Java 读写优先权

我正在使用Java线程开发一个系统读写器，它必须有优先级：读写器优先于写器

我写了一个源代码，，它可以编译并且可以毫无问题地执行。但我想确定它是正确的

如果你看到一些错误，你能告诉我吗

首先我要向你解释一下我的小计划的目的。定期向用户显示一条消息。后者可以对其进行修改，并更改其显示延迟（“时间间隔”）。消息由ID标识

因此，如果用户键入：

0\n Hello\n 2

，则表示消息n°0现在为“Hello”，并将每隔2秒显示一次。

每条消息都由一个线程处理我必须使用信号量。

源代码。

读者：

public class Lecteur extends Thread {

    private Message<String> message;

    public Lecteur(Message<String> message) {
        this.message = message;
    }

    public void run() {
        try {
            while(true) {
                System.out.println(message.getContent());
                int time = message.getRefresh_time()*1000;
                Thread.sleep(time);
            }
        } catch(InterruptedException e) {
            System.out.println(e);
        }
    }

}

import java.util.HashMap;
import java.util.Scanner;

public class GestionnaireSaisie extends Thread {

    private HashMap<Integer, Message<String>> messages;

    public GestionnaireSaisie(HashMap<Integer, Message<String>> messages) {
        this.messages = messages;
    }

    public void run() {
        Scanner scanner = new Scanner(System.in);

        int id;
        String content;
        int time_refresh;

        while (true) {
            id = scanner.nextInt();
            content = scanner.next();
            time_refresh = scanner.nextInt();

            Message<String> found_msg = messages.get(id);
            found_msg.setContent(content);
            found_msg.setRefreshTime(time_refresh);
        }
    }

}

import java.util.concurrent.Semaphore;

public class Message<T> {

    private static int maxid;
    private int id;
    private T content;
    private int refresh_time;

    public Semaphore mutex_content, mutex_refresh_time, semNbl;
    public static int nbL = 0;

    public int getId() {
        return id;
    }

    public Message(T content, int refresh_time, Semaphore mutex_content, Semaphore mutex_refresh_time, Semaphore semNbl) {
        id = maxid;
        Message.maxid++;
        this.content = content;
        this.refresh_time = refresh_time;

        this.mutex_content = mutex_content;
        this.mutex_refresh_time = mutex_refresh_time;
        this.semNbl = semNbl;
    }

    // <!-- CONTENT
    public void setContent(T content) {
        try {
            mutex_content.acquire();
            this.content = content;
            mutex_content.release();
        } catch(InterruptedException e) {
            System.out.println(e);
        }
    }

    public T getContent() {
        T ret = null;
        try {
            semNbl.acquire();
            Message.nbL++;
            if(Message.nbL == 1) {
                mutex_content.acquire();
            }
            semNbl.release();

            ret = content;

            semNbl.acquire();
            Message.nbL--;
            if(Message.nbL == 0) {
                mutex_content.release();
            }
            semNbl.release();

        } catch(InterruptedException e) {
            System.out.println(e);
        }

        return ret;
    }
    // CONTENT -->

    // <!-- REFRESH TIME
    public void setRefreshTime(int refresh_time) {
        try {
            mutex_refresh_time.acquire();
            this.refresh_time = refresh_time;
            mutex_refresh_time.release();
        } catch(InterruptedException e) {
            System.out.println(e);
        }
    }

    public int getRefresh_time() {
        int ret = 0;

        try {
            semNbl.acquire();
            Message.nbL++;
            if(Message.nbL == 1) {
                mutex_refresh_time.acquire();
            }
            semNbl.release();

            ret = refresh_time;

            semNbl.acquire();
            Message.nbL--;
            if(Message.nbL == 0) {
                mutex_refresh_time.release();
            }
            semNbl.release();

        } catch(InterruptedException e) {
            System.out.println(e);
        }
        return ret;
    }
    // REFRESH TIME -->
}

Semaphore mutex_content = new Semaphore(1);
Semaphore mutex_refresh_time = new Semaphore(1);
Semaphore semNbl = new Semaphore(1);

Message<String> message1 = new Message<String>("Bonjour le monde !", 5, mutex_content, mutex_refresh_time, semNbl);
new Lecteur(message1).start();

HashMap<Integer, Message<String>> messages = new HashMap<Integer, Message<String>>();
messages.put(message1.getId(), message1);
GestionnaireSaisie gs = new GestionnaireSaisie(messages);
gs.start();

公共类选择器扩展线程{
私人信息；
公共选择器（消息）{
this.message=消息；
}
公开募捐{
试一试{
while（true）{
System.out.println（message.getContent（））；
int time=message.getRefresh\u time（）*1000；
睡眠（时间）；
}
}捕捉（中断异常e）{
系统输出打印ln（e）；
}
}
}

作者：

public class Lecteur extends Thread {

    private Message<String> message;

    public Lecteur(Message<String> message) {
        this.message = message;
    }

    public void run() {
        try {
            while(true) {
                System.out.println(message.getContent());
                int time = message.getRefresh_time()*1000;
                Thread.sleep(time);
            }
        } catch(InterruptedException e) {
            System.out.println(e);
        }
    }

}

import java.util.HashMap;
import java.util.Scanner;

public class GestionnaireSaisie extends Thread {

    private HashMap<Integer, Message<String>> messages;

    public GestionnaireSaisie(HashMap<Integer, Message<String>> messages) {
        this.messages = messages;
    }

    public void run() {
        Scanner scanner = new Scanner(System.in);

        int id;
        String content;
        int time_refresh;

        while (true) {
            id = scanner.nextInt();
            content = scanner.next();
            time_refresh = scanner.nextInt();

            Message<String> found_msg = messages.get(id);
            found_msg.setContent(content);
            found_msg.setRefreshTime(time_refresh);
        }
    }

}

import java.util.concurrent.Semaphore;

public class Message<T> {

    private static int maxid;
    private int id;
    private T content;
    private int refresh_time;

    public Semaphore mutex_content, mutex_refresh_time, semNbl;
    public static int nbL = 0;

    public int getId() {
        return id;
    }

    public Message(T content, int refresh_time, Semaphore mutex_content, Semaphore mutex_refresh_time, Semaphore semNbl) {
        id = maxid;
        Message.maxid++;
        this.content = content;
        this.refresh_time = refresh_time;

        this.mutex_content = mutex_content;
        this.mutex_refresh_time = mutex_refresh_time;
        this.semNbl = semNbl;
    }

    // <!-- CONTENT
    public void setContent(T content) {
        try {
            mutex_content.acquire();
            this.content = content;
            mutex_content.release();
        } catch(InterruptedException e) {
            System.out.println(e);
        }
    }

    public T getContent() {
        T ret = null;
        try {
            semNbl.acquire();
            Message.nbL++;
            if(Message.nbL == 1) {
                mutex_content.acquire();
            }
            semNbl.release();

            ret = content;

            semNbl.acquire();
            Message.nbL--;
            if(Message.nbL == 0) {
                mutex_content.release();
            }
            semNbl.release();

        } catch(InterruptedException e) {
            System.out.println(e);
        }

        return ret;
    }
    // CONTENT -->

    // <!-- REFRESH TIME
    public void setRefreshTime(int refresh_time) {
        try {
            mutex_refresh_time.acquire();
            this.refresh_time = refresh_time;
            mutex_refresh_time.release();
        } catch(InterruptedException e) {
            System.out.println(e);
        }
    }

    public int getRefresh_time() {
        int ret = 0;

        try {
            semNbl.acquire();
            Message.nbL++;
            if(Message.nbL == 1) {
                mutex_refresh_time.acquire();
            }
            semNbl.release();

            ret = refresh_time;

            semNbl.acquire();
            Message.nbL--;
            if(Message.nbL == 0) {
                mutex_refresh_time.release();
            }
            semNbl.release();

        } catch(InterruptedException e) {
            System.out.println(e);
        }
        return ret;
    }
    // REFRESH TIME -->
}

Semaphore mutex_content = new Semaphore(1);
Semaphore mutex_refresh_time = new Semaphore(1);
Semaphore semNbl = new Semaphore(1);

Message<String> message1 = new Message<String>("Bonjour le monde !", 5, mutex_content, mutex_refresh_time, semNbl);
new Lecteur(message1).start();

HashMap<Integer, Message<String>> messages = new HashMap<Integer, Message<String>>();
messages.put(message1.getId(), message1);
GestionnaireSaisie gs = new GestionnaireSaisie(messages);
gs.start();

import java.util.HashMap；
导入java.util.Scanner；
公共类gestionnairesasie扩展线程{
私有HashMap消息；
公共管理（HashMap消息）{
this.messages=消息；
}
公开募捐{
扫描仪=新的扫描仪（System.in）；
int-id；
字符串内容；
int time_刷新；
while（true）{
id=scanner.nextInt（）；
content=scanner.next（）；
time_refresh=scanner.nextInt（）；
Message found\u msg=messages.get（id）；
找到了\u msg.setContent（content）；
找到\u msg.setRefreshTime（时间\u刷新）；
}
}
}

最有趣的类是包含共享数据的共享对象：

public class Lecteur extends Thread {

    private Message<String> message;

    public Lecteur(Message<String> message) {
        this.message = message;
    }

    public void run() {
        try {
            while(true) {
                System.out.println(message.getContent());
                int time = message.getRefresh_time()*1000;
                Thread.sleep(time);
            }
        } catch(InterruptedException e) {
            System.out.println(e);
        }
    }

}

import java.util.HashMap;
import java.util.Scanner;

public class GestionnaireSaisie extends Thread {

    private HashMap<Integer, Message<String>> messages;

    public GestionnaireSaisie(HashMap<Integer, Message<String>> messages) {
        this.messages = messages;
    }

    public void run() {
        Scanner scanner = new Scanner(System.in);

        int id;
        String content;
        int time_refresh;

        while (true) {
            id = scanner.nextInt();
            content = scanner.next();
            time_refresh = scanner.nextInt();

            Message<String> found_msg = messages.get(id);
            found_msg.setContent(content);
            found_msg.setRefreshTime(time_refresh);
        }
    }

}

import java.util.concurrent.Semaphore;

public class Message<T> {

    private static int maxid;
    private int id;
    private T content;
    private int refresh_time;

    public Semaphore mutex_content, mutex_refresh_time, semNbl;
    public static int nbL = 0;

    public int getId() {
        return id;
    }

    public Message(T content, int refresh_time, Semaphore mutex_content, Semaphore mutex_refresh_time, Semaphore semNbl) {
        id = maxid;
        Message.maxid++;
        this.content = content;
        this.refresh_time = refresh_time;

        this.mutex_content = mutex_content;
        this.mutex_refresh_time = mutex_refresh_time;
        this.semNbl = semNbl;
    }

    // <!-- CONTENT
    public void setContent(T content) {
        try {
            mutex_content.acquire();
            this.content = content;
            mutex_content.release();
        } catch(InterruptedException e) {
            System.out.println(e);
        }
    }

    public T getContent() {
        T ret = null;
        try {
            semNbl.acquire();
            Message.nbL++;
            if(Message.nbL == 1) {
                mutex_content.acquire();
            }
            semNbl.release();

            ret = content;

            semNbl.acquire();
            Message.nbL--;
            if(Message.nbL == 0) {
                mutex_content.release();
            }
            semNbl.release();

        } catch(InterruptedException e) {
            System.out.println(e);
        }

        return ret;
    }
    // CONTENT -->

    // <!-- REFRESH TIME
    public void setRefreshTime(int refresh_time) {
        try {
            mutex_refresh_time.acquire();
            this.refresh_time = refresh_time;
            mutex_refresh_time.release();
        } catch(InterruptedException e) {
            System.out.println(e);
        }
    }

    public int getRefresh_time() {
        int ret = 0;

        try {
            semNbl.acquire();
            Message.nbL++;
            if(Message.nbL == 1) {
                mutex_refresh_time.acquire();
            }
            semNbl.release();

            ret = refresh_time;

            semNbl.acquire();
            Message.nbL--;
            if(Message.nbL == 0) {
                mutex_refresh_time.release();
            }
            semNbl.release();

        } catch(InterruptedException e) {
            System.out.println(e);
        }
        return ret;
    }
    // REFRESH TIME -->
}

Semaphore mutex_content = new Semaphore(1);
Semaphore mutex_refresh_time = new Semaphore(1);
Semaphore semNbl = new Semaphore(1);

Message<String> message1 = new Message<String>("Bonjour le monde !", 5, mutex_content, mutex_refresh_time, semNbl);
new Lecteur(message1).start();

HashMap<Integer, Message<String>> messages = new HashMap<Integer, Message<String>>();
messages.put(message1.getId(), message1);
GestionnaireSaisie gs = new GestionnaireSaisie(messages);
gs.start();

import java.util.concurrent.Semaphore；
公共类消息{
私有静态int-maxid；
私有int-id；
私有内容；
私有整数刷新时间；
公共信号量互斥内容，互斥刷新时间，semNbl；
公共静态int nbL=0；
公共int getId（）{
返回id；
}
公共消息（T内容、int刷新时间、信号量互斥内容、信号量互斥刷新时间、信号量semNbl）{
id=maxid；
Message.maxid++；
this.content=内容；
this.refresh\u time=刷新时间；
this.mutex\u content=互斥内容；
this.mutex\u refresh\u time=mutex\u refresh\u time；
this.semNbl=semNbl；
}
// 
// 
}

这里有一些测试代码：

public class Lecteur extends Thread {

    private Message<String> message;

    public Lecteur(Message<String> message) {
        this.message = message;
    }

    public void run() {
        try {
            while(true) {
                System.out.println(message.getContent());
                int time = message.getRefresh_time()*1000;
                Thread.sleep(time);
            }
        } catch(InterruptedException e) {
            System.out.println(e);
        }
    }

}

import java.util.HashMap;
import java.util.Scanner;

public class GestionnaireSaisie extends Thread {

    private HashMap<Integer, Message<String>> messages;

    public GestionnaireSaisie(HashMap<Integer, Message<String>> messages) {
        this.messages = messages;
    }

    public void run() {
        Scanner scanner = new Scanner(System.in);

        int id;
        String content;
        int time_refresh;

        while (true) {
            id = scanner.nextInt();
            content = scanner.next();
            time_refresh = scanner.nextInt();

            Message<String> found_msg = messages.get(id);
            found_msg.setContent(content);
            found_msg.setRefreshTime(time_refresh);
        }
    }

}

import java.util.concurrent.Semaphore;

public class Message<T> {

    private static int maxid;
    private int id;
    private T content;
    private int refresh_time;

    public Semaphore mutex_content, mutex_refresh_time, semNbl;
    public static int nbL = 0;

    public int getId() {
        return id;
    }

    public Message(T content, int refresh_time, Semaphore mutex_content, Semaphore mutex_refresh_time, Semaphore semNbl) {
        id = maxid;
        Message.maxid++;
        this.content = content;
        this.refresh_time = refresh_time;

        this.mutex_content = mutex_content;
        this.mutex_refresh_time = mutex_refresh_time;
        this.semNbl = semNbl;
    }

    // <!-- CONTENT
    public void setContent(T content) {
        try {
            mutex_content.acquire();
            this.content = content;
            mutex_content.release();
        } catch(InterruptedException e) {
            System.out.println(e);
        }
    }

    public T getContent() {
        T ret = null;
        try {
            semNbl.acquire();
            Message.nbL++;
            if(Message.nbL == 1) {
                mutex_content.acquire();
            }
            semNbl.release();

            ret = content;

            semNbl.acquire();
            Message.nbL--;
            if(Message.nbL == 0) {
                mutex_content.release();
            }
            semNbl.release();

        } catch(InterruptedException e) {
            System.out.println(e);
        }

        return ret;
    }
    // CONTENT -->

    // <!-- REFRESH TIME
    public void setRefreshTime(int refresh_time) {
        try {
            mutex_refresh_time.acquire();
            this.refresh_time = refresh_time;
            mutex_refresh_time.release();
        } catch(InterruptedException e) {
            System.out.println(e);
        }
    }

    public int getRefresh_time() {
        int ret = 0;

        try {
            semNbl.acquire();
            Message.nbL++;
            if(Message.nbL == 1) {
                mutex_refresh_time.acquire();
            }
            semNbl.release();

            ret = refresh_time;

            semNbl.acquire();
            Message.nbL--;
            if(Message.nbL == 0) {
                mutex_refresh_time.release();
            }
            semNbl.release();

        } catch(InterruptedException e) {
            System.out.println(e);
        }
        return ret;
    }
    // REFRESH TIME -->
}

Semaphore mutex_content = new Semaphore(1);
Semaphore mutex_refresh_time = new Semaphore(1);
Semaphore semNbl = new Semaphore(1);

Message<String> message1 = new Message<String>("Bonjour le monde !", 5, mutex_content, mutex_refresh_time, semNbl);
new Lecteur(message1).start();

HashMap<Integer, Message<String>> messages = new HashMap<Integer, Message<String>>();
messages.put(message1.getId(), message1);
GestionnaireSaisie gs = new GestionnaireSaisie(messages);
gs.start();

Semaphore mutex\u content=新信号量（1）；
信号量互斥\u刷新\u时间=新信号量（1）；
信号量semNbl=新信号量（1）；
Message message1=新消息（“你好，世界报！”，5，互斥内容，互斥刷新时间，semNbl）；
新的选择器（message1.start（）；
HashMap消息=新建HashMap（）；
messages.put（message1.getId（），message1）；
gestionnairesasie gs=新的gestionnairesasie（消息）；
gs.start（）；

为什么nbL是静态的？将共享给所有对象。nbL是读者的数量。有人能帮我吗？同样的问题“为什么nbL是静态的？”。要么我不理解代码，要么代码凌乱。nbL在所有：消息对象之间共享。为什么nbL是静态的？共享给所有对象。nbL是读者的数量。有人能帮我吗？同样的问题“为什么nbL是静态的？”。要么我不理解代码，要么代码凌乱。nbL在所有：消息对象之间共享。