java基础_设计模式_命令模式二（以计算机读取内存和硬盘为例）

我是野猪。

题目的要求如下：

“计算机系统中存在多个具有I/O操作的组件，比如内存、硬盘、声卡等；这些I/O组件都具有读和写的操作。

假设计算机系统要对这些I/O组件的操作统一管理，并把它们的操作（由用户代码触发）存放到系统中的唯一的一个队列中。

假设当前系统有两个线程，可以通过一个统一的接口处理队列中命令，但只能互斥的访问该队列；

此外，线程处理一个命令之后，为了便于观看，都随机的等待1-4s。

请选择合适的模式来模拟这个过程。PS：不考虑I/O组件自身读写的互斥问题，输出一跳语句来表示读、写操作即可。”

分析过程：

1.创建具体的组件，比如RAM和DIESK（内存和硬盘）；

2.创建具体的指令；

3.创建存放指令的队列（为保证只能互斥访问该队列设计成单列模式）；

4.运行时，指令放入队列中，创建线程，启动线程，查看运行结果。

1.创建组件（抽象父类和其有具体实现的子类）:

/**
 * 代指计算机中任何一个器件
 * 功能输入和输出
 * 真正能执行组件读、写操作的是组件本身;
 */

public abstract class Compent {

    protected final String name;

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

    public abstract void read();

    public abstract void write();

}

/**
 * 具体的控件
 * Ram 内存
 */

public class RAM extends Compent {

    public RAM(String name) {
        super(name);
    }

    @Override
    public void read() {
        System.out.println(name + " is reading");
    }

    @Override
    public void write() {
        System.out.println(name + " is writtng");
    }
}

/**
 * 具体控件 DIESK
 */

public class DIESK extends Compent {
    private DIESK(String name) {
        super(name);
    }

    @Override
    public void read() {
        System.out.println(name + " is reading");
    }

    @Override
    public void write() {
        System.out.println(name + " is writting");
    }
}

2.创建命令（命令的父类和具体到每一个I/O组件上的读写命令）：
通过一个统一的接口处理队列中命令；代码如下，很简单：

/**
 * 接口 职责就是执行命令
 */

public interface Command {
    void execute();
}

/**
 * 具体的硬盘读命令
 */

public class DieskReadCommand implements Command {
    
    Compent diesk;

    public DieskReadCommand(Compent compent) {
        this.diesk = compent;
    }

    @Override
    public void execute() {
        //执行什么？执行的是内存的读操作
        diesk.read();
    }
}

/**
 * 具体的硬盘写命令
 */

public class DieskWriteCommand implements Command {
    
    Compent diesk;

    public DieskWriteCommand(Compent compent) {
        this.diesk = compent;
    }
    @Override
    public void execute() {
        //执行什么？执行的是内存的读操作
        diesk.write();
    }
}

/**
 * 具体的内存读命令
 */

public class RamReadCommand implements Command {

    Compent ram;
    public RamReadCommand (Compent compent) {
        this.ram = compent;
    }

    @Override
    public void execute() {
        //执行什么？执行的是内存的读操作
        ram.read();
    }
}

/**
 * 具体的内存的写命令
 */

public class RamWriteCommand implements Command {
    
    Compent ram;
    public RamWriteCommand(Compent compent) {
        this.ram = compent;
    }

    @Override
    public void execute() {
        //执行什么？执行的是内存的读操作
        ram.write();
    }
}

3.使用单例模式创建存放指令的队列（队列应该具有插入和获取指令的方法）：

import java.util.LinkedList;
import java.util.Queue;

/**
 * 存放具体操作命令的队列
 * 线程不和任务直接沟通合适传话人
 */

public class CommandQueueSingleTon {
    private static CommandQueueSingleTon commandQueueSingetion = null;

    //存放命令的队列 之所以使用linkedlist 因为命令的读写操作频繁
    Queue<Command> commandQueue = new LinkedList<Command>();

    //1.私有构造
    private CommandQueueSingleTon() {

    }

    //2.对外暴露方法（获取一个有权限的引用指向这个实例）
    public static CommandQueueSingleTon getQueueSinglton() {
        if (commandQueueSingetion == null) {
            synchronized (CommandQueueSingleTon.class) {
                if (commandQueueSingetion == null) {
                    commandQueueSingetion = new CommandQueueSingleTon();
                }
            }
        }
        return commandQueueSingetion;
    }

    //4.以上是单例的书写方式 下面就是提供方式让命令插入队列和取出队列
    public void insertCommand(Command cmd) {
        commandQueue.add(cmd);
    }

    public Command getCommand() {

        if (commandQueue != null) {
            Command command = commandQueue.poll();
            return command;
        } else {
            return null;
        }
    }
}

4.main函数中测试，基本流程也是①创建I/O组件;②根据组件创建具体的命令;③命令入队;④创建两个线程，从队列中读取调用命令：

/**
 * 测试
 */

public class Test {
    public static void main(String[] args) {
        //1.执行命令的控件
        Compent ram = new RAM("RAM");
        Compent diesk = new RAM("Cpu");

        //2.传话人
        Command ramReadCommand = new RamReadCommand(ram);
        Command ramWriteCommand = new RamWriteCommand(ram);
        Command dieskReadCommand = new DieskReadCommand(diesk);
        Command dieskWritteCommand = new DieskWriteCommand(diesk);

        //3.命令入列
        CommandQueueSingleTon commandQueue = CommandQueueSingleTon.getQueueSinglton();
        commandQueue.insertCommand(ramReadCommand);
        commandQueue.insertCommand(ramWriteCommand);
        commandQueue.insertCommand(dieskReadCommand);
        commandQueue.insertCommand(ramWriteCommand);
        commandQueue.insertCommand(dieskWritteCommand);

        //4。创建线程
        Runnable commandProcessor1 = new CommandProcess();
        Runnable commandProcessor2 = new CommandProcess();

        //start 并不是启动线程而是代表只是把线程放到cpu执行队列中
        Thread thread1 = new Thread(commandProcessor1);
        thread1.start();

        Thread thread2 = new Thread(commandProcessor2);
        thread2.start();

    }

    static class CommandProcess implements Runnable {
        @Override
        public void run() {
            while (true) {
                try {
                    //随机睡上1-4s
                    Random RAND = new Random(1);
                    Thread.sleep(RAND.nextInt(4*1024));

                    CommandQueueSingleTon queueSinglton = CommandQueueSingleTon.getQueueSinglton();
                    Command command = queueSinglton.getCommand();
                    if (command != null) {
                        command.execute();
                    } else {
                        break;
                    }

                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

ps：这段代码比较简单，其中用到的随机数和伪随机数的概念在另一篇文章有简单介绍，线程的介绍也是，大家有需要的话可以自行阅览。
如果对以上代码有疑问的话，希望大家能随时指出。