线程“pool-1-thread-7”中的异常java.lang.NullPointerException

Question

我正在试图解决这个问题，因为我在标题中写了这个例外。 我正在构建一个多线程MMU（内存管理单元）项目，首先我初始化并将一些页面添加到ram和我的HD中，然后我创建进程并运行所有系统。关于该项目的一些信息： 进入runConfig i;读取带有processCycles列表的json文件和每个processCycles，包括processCycle列表，其中包括带有这些页面数据列表的pageId列表。

我想我做的一切都还可以，但我仍然得到这个例外，有人能帮助我吗？

MMUDriver是运行所有系统的类：

    package hit.driver;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import com.google.gson.Gson;
import com.google.gson.JsonIOException;
import com.google.gson.JsonSyntaxException;
import com.google.gson.stream.JsonReader;
import com.hit.algorithm.IAlgoCache;
import com.hit.algorithm.LRUAlgoCacheImpl;
import com.hit.algorithm.MRUAlgoCacheImpl;
import com.hit.algorithm.RandomReplacementAlgoCacheImpl;

import hit.memoryunits.HardDisk;
import hit.memoryunits.MemoryManagementUnit;
import hit.memoryunits.MemoryManagementUnitTest;
import hit.memoryunits.Page;
import hit.processes.ProcessCycles;
import hit.processes.Process;
import hit.processes.RunConfiguration;

@SuppressWarnings("unused")
public class MMUDriver {

        private static final String CONFIG_FILE_NAME="Configuration.json";
    //  private static final String CONFIG_FILE_NAME="test.json";

        //read from JSON file the lists of processCycles
        private static  RunConfiguration readConfigurationFile() throws JsonIOException, JsonSyntaxException, FileNotFoundException{
            RunConfiguration runConfig = new Gson().fromJson(new JsonReader(new FileReader(CONFIG_FILE_NAME)), RunConfiguration.class);

            return runConfig;

        }

        //
        private static List<Process> createProcesses(List<ProcessCycles> processCycles,MemoryManagementUnit mmu ){

            int i=0;
            List<Process> processList = new ArrayList<Process>();
            for ( ProcessCycles currentListProcess : processCycles) {
                Process process = new Process(++i , mmu , currentListProcess);
                processList.add(process);
            }

            return processList;

        }

        //
        private static void runProcesses(List<Process> processes){
            //Executor is a interface that take care of threads מתי מתחיל טרד מתי נגמר  איך הם ירוצו במקביל וכו'
            //thread pool  - אוסף של threads
            ExecutorService  executorservice = Executors.newCachedThreadPool();
            for (Process process : processes)
                executorservice.execute(process);

            executorservice.shutdown();//
        }

        //
    public static void main(String[] args) throws java.lang.InterruptedException,
    InvocationTargetException, JsonIOException, JsonSyntaxException, ClassNotFoundException, IOException{

        CLI cli = new CLI(System.in,System.out);
        String [] configuration;
        while((configuration = cli.getConfiguration()) != null){
            IAlgoCache<Long, Long> algo = null;
            int capacity = Integer.valueOf(configuration[1]);
            switch(configuration[0]){ //which configuration to play on LRU|MRU|RR
            case "LRU":
                algo = new LRUAlgoCacheImpl<Long, Long>(capacity);
                break;
            case "MRU":
                algo = new MRUAlgoCacheImpl<Long, Long>(capacity);
                break;
            case "RR":
                algo = new RandomReplacementAlgoCacheImpl<Long, Long>(capacity);
                break;
            }

            MemoryManagementUnit mmu = new MemoryManagementUnit(algo, capacity);
            MemoryManagementUnitTest.test(mmu);//add some pages to ram for test

            RunConfiguration runConfig = readConfigurationFile(); //Getting the user request pages throw json file

            List<ProcessCycles> processCycles = runConfig.getProcessesCycles();

            List<Process> processes = createProcesses(processCycles , mmu);

            runProcesses(processes);
            Map<Long, Page<byte[]>> bla= mmu.getRam().getRamPages();
            System.out.println("1");
    //      mmu.shoutDown();

        }

    }

}

流程就像这个项目中的一个主题

    package hit.processes;

import java.io.IOException;
import java.util.List;
import hit.memoryunits.MemoryManagementUnit;
import hit.memoryunits.Page;


@SuppressWarnings("unused")

public class Process implements Runnable {
    private int id;
    private MemoryManagementUnit mmu;
    private ProcessCycles processCycles;
    private Thread processThread=null;


    public Process(int id, MemoryManagementUnit mmu, ProcessCycles processCycles){
        this.id=id;
        this.mmu=mmu;
        this.processCycles=processCycles;
    }

    public int getId(){
        return id;
    }

    public void setId(int id){
        this.id=id;
    }

    /*
    public void start(){
        if(processThread==null)
            processThread = new Thread(this,"process"); //
        processThread.start();
    }*/

    @Override
    public void run() {
            synchronized(mmu){
                //runing on all the list of processCycles
            for (ProcessCycle currentProcessCycle : processCycles.getProcessCycles()) {
                 List<Long> pages = currentProcessCycle.getPages();
                 List<byte[]> data = currentProcessCycle.getData();
                 Page<byte[]>[] pagesList = null;
                 //creating a boolean array to know if the page is for writing or reading in size of pages.size()
                 boolean [] writePages = new boolean[pages.size()];
                 for (int i = 0; i < pages.size(); i++)
                     if(data.get(i) == null) //if the page is empty
                         writePages[i] = false;
                     else{
                         writePages[i] = true ;//if there is data in the page and we want to write it to the ram
                     }
                try {
                    // Getting the pages from ram to see which we shall update
                    pagesList = mmu.getPages(pages.toArray(new Long[pages.size()]), writePages); 
                }
                catch (ClassNotFoundException e1) {
                    e1.printStackTrace();
                    } catch (IOException e1) {
                    e1.printStackTrace();
                    }
                 for (int j = 0; j < pages.size(); j++) 
                     if(writePages[j] == true) //if the page isn't for read only
                         pagesList[j].setContent(data.get(j));

                 try {
                    Thread.sleep(currentProcessCycle.getSleepMs());
                 }
                 catch (InterruptedException e) {
                    e.printStackTrace();
                    }
                }
            }
         }
    }

MMU类是负责处理来自用户的所有请求并管理所有pagging

的类

    package hit.memoryunits;

import java.io.FileNotFoundException;
import java.io.IOException;

import com.hit.algorithm.IAlgoCache;

public class MemoryManagementUnit {
    private IAlgoCache<Long,Long> algo;
    private RAM<Long, Page<byte[]>> ram;

    public MemoryManagementUnit(IAlgoCache<Long, Long> algo, int ramCapacity) {
        this.algo = algo;
        this.ram= new RAM<Long, Page<byte[]>>(ramCapacity);

    }

    @SuppressWarnings("null")
    public Page<byte[]> [] getPages(Long [] pageIds , boolean [] writePages) throws IOException, ClassNotFoundException{

        for (int i = 0; i < pageIds.length; i++) {
            if(algo.getElement((long) pageIds[i].hashCode())== null)//the page isn't exist in the cache 
                if(!ram.isFull())
                {
                    if(writePages[i] == true){//if the page is for write we need to overwrite data
                        Page<byte[]> pageToRam = null;
                        pageToRam.setPageId(pageIds[i]);
                        pageToRam.setContent(null);
                        ram.addPage(pageToRam);// ram is not full need to upload from hd
                    }
                    else{//if the page is for read-only so we need to upload the page from HD
                        ram.addPage(HardDisk.getInstance().pageFault(pageIds[i]));// ram is not full need to upload from hd
                    }
                    algo.putElement(Long.valueOf(pageIds[i].hashCode()),pageIds[i]);//update cache
                }
                else
                {

                    Page<byte[]> pageToRemove = ram.getPage(algo.putElement(Long.valueOf(pageIds[i].hashCode()),pageIds[i]));
                    ram.removePage(pageToRemove);
                    ram.addPage(HardDisk.getInstance().pageReplacement(pageToRemove,pageIds[i]));// ram full need to do replacement
                    algo.putElement(Long.valueOf(pageIds[i].hashCode()),pageIds[i]);//update cache
                }
        }

        return ram.getPages(pageIds);

        }



    public RAM<Long, Page<byte[]>> getRam(){
        return ram;
    }

    public IAlgoCache<Long,Long> getAlgo(){
        return algo;
    }

    public void setAlgo(IAlgoCache<Long,Long> algo){
        this.algo = algo;
    }

    public void setRam(RAM<Long, Page<byte[]>> ram){
        this.ram = ram;
    }

    public void shoutDown() throws FileNotFoundException, IOException, ClassNotFoundException{

        HardDisk.getInstance().saveToDisk(this.getRam().getRamPages());

    }
}