用java语言实现银行家算法

银行家算法是用于避免死锁的一种算法。在多进程并发的环境下，如果进程请求的资源超过了系统所拥有的资源，就可能会导致死锁的情况出现。银行家算法可以通过合理地分配资源来避免死锁的出现。

Java语言实现银行家算法可以参考以下步骤：

1. 定义资源类（Resource），包括资源名称、资源数量、资源状态等属性；
2. 定义进程类（Process），包括进程名称、进程需要的资源数量、进程已经分配到的资源数量、进程状态等属性；
3. 定义银行家类（Banker），包括系统当前拥有的资源数量、系统当前可用的资源数量、已经分配给进程的资源数量等属性，以及分别处理进程请求资源和进程释放资源的方法；
4. 在银行家类中实现银行家算法，处理进程请求资源时检查系统当前是否能够满足进程的请求，如果能够满足就分配资源并更新系统状态，否则暂时不分配资源并将该进程加入等待队列中；
5. 在银行家类中实现进程释放资源的方法，当一个进程释放资源时，将已经释放的资源加回到系统可用资源中，并更新系统状态；
6. 根据需要在主函数中实例化资源、进程和银行家对象，模拟进程请求和释放资源的情况，检查系统状态是否正常。

相关问题

银行家算法java语言

以下是一个简单的银行家算法的Java实现：

public class BankerAlgorithm {
    private int[][] need; // 需求矩阵
    private int[][] allocation; // 分配矩阵
    private int[] available; // 可用资源向量
    private int[] safeSequence; // 安全序列

    public BankerAlgorithm(int[][] need, int[][] allocation, int[] available) {
        this.need = need;
        this.allocation = allocation;
        this.available = available;
        this.safeSequence = new int[allocation.length];
    }

    public boolean isSafe() {
        boolean[] finish = new boolean[allocation.length];
        int[] work = available.clone();

        int count = 0; // 安全序列计数器
        while (count < allocation.length) {
            boolean find = false;
            for (int i = 0; i < allocation.length; i++) {
                if (!finish[i] && lessEqual(need[i], work)) {
                    for (int j = 0; j < allocation[i].length; j++) {
                        work[j] += allocation[i][j];
                    }
                    finish[i] = true;
                    safeSequence[count++] = i;
                    find = true;
                }
            }
            if (!find) {
                return false; // 找不到满足条件的进程，说明不安全
            }
        }
        return true;
    }

    public int[] getSafeSequence() {
        return safeSequence;
    }

    private boolean lessEqual(int[] a, int[] b) {
        for (int i = 0; i < a.length; i++) {
            if (a[i] > b[i]) {
                return false;
            }
        }
        return true;
    }
}

使用时，可以按照以下步骤：

1. 定义需求矩阵、分配矩阵和可用资源向量。
2. 创建`BankerAlgorithm`对象，传入上述三个参数。
3. 调用`isSafe()`方法判断是否安全，如果返回true，则调用`getSafeSequence()`方法获取安全序列。

示例代码：

public static void main(String[] args) {
    int[][] need = {{3, 2, 2}, {6, 1, 3}, {3, 1, 4}, {4, 2, 2}, {4, 3, 3}};
    int[][] allocation = {{0, 1, 0}, {2, 0, 0}, {3, 0, 2}, {2, 1, 1}, {0, 0, 2}};
    int[] available = {1, 0, 2};

    BankerAlgorithm banker = new BankerAlgorithm(need, allocation, available);
    if (banker.isSafe()) {
        int[] safeSequence = banker.getSafeSequence();
        System.out.println("Safe sequence: " + Arrays.toString(safeSequence));
    } else {
        System.out.println("Not safe!");
    }
}

Java语言实现银行家算法、进程调度过程的模拟、读者-写者问题的写者优先算法。

银行家算法Java实现：

import java.util.Scanner;

public class BankerAlgorithm {
    private int need[][], allocate[][], max[][], available[][], np, nr;

    private void input() {
        Scanner sc = new Scanner(System.in);
        System.out.println("Enter no of processes and resources: ");
        np = sc.nextInt(); // no of processes
        nr = sc.nextInt(); // no of resources

        need = new int[np][nr]; // initializing arrays
        max = new int[np][nr];
        allocate = new int[np][nr];
        available = new int[1][nr];

        System.out.println("Enter allocation matrix: ");
        for (int i = 0; i < np; i++)
            for (int j = 0; j < nr; j++)
                allocate[i][j] = sc.nextInt(); // allocation matrix

        System.out.println("Enter max matrix: ");
        for (int i = 0; i < np; i++)
            for (int j = 0; j < nr; j++)
                max[i][j] = sc.nextInt(); // max matrix

        System.out.println("Enter available matrix: ");
        for (int j = 0; j < nr; j++)
            available[0][j] = sc.nextInt(); // available matrix
        sc.close();
    }

    private int[][] calc_need() {
        for (int i = 0; i < np; i++)
            for (int j = 0; j < nr; j++) // calculating need matrix
                need[i][j] = max[i][j] - allocate[i][j];

        return need;
    }

    private boolean check(int i) {
        // checking if all resources for ith process can be allocated
        for (int j = 0; j < nr; j++)
            if (available[0][j] < need[i][j])
                return false;

        return true;
    }

    public void isSafe() {
        input();
        calc_need(); // calculating need matrix

        boolean done[] = new boolean[np];
        int j = 0;

        while (j < np) { // until all process allocated
            boolean allocated = false;
            for (int i = 0; i < np; i++)
                if (!done[i] && check(i)) { // trying to allocate
                    for (int k = 0; k < nr; k++)
                        available[0][k] = available[0][k] - need[i][k] + max[i][k];
                    System.out.println("Allocated process : " + i);
                    allocated = done[i] = true;
                    j++;
                }
            if (!allocated)
                break; // if no allocation
        }
        if (j == np) // if all processes are allocated
            System.out.println("\nSafely allocated");
        else
            System.out.println("All process cant be allocated safely");
    }

    public static void main(String[] args) {
        new BankerAlgorithm().isSafe();
    }
}

进程调度过程的模拟Java实现：

import java.util.*;

public class ProcessSchedulingSimulation {
    static String processNames[];
    static int arrivalTimes[];
    static int burstTimes[];
    static int completionTimes[];
    static int turnaroundTimes[];
    static int waitingTimes[];
    static int numberOfProcesses;
    static float averageWaitingTime;
    static float averageTurnaroundTime;
    static int totalWaitingTime;
    static int totalTurnaroundTime;

    public static void main(String args[]) {
        acceptInput();
        computeOutput();
        printOutput();
    }

    static void acceptInput() {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Enter the number of processes: ");
        numberOfProcesses = scanner.nextInt();

        processNames = new String[numberOfProcesses];
        arrivalTimes = new int[numberOfProcesses];
        burstTimes = new int[numberOfProcesses];
        completionTimes = new int[numberOfProcesses];
        turnaroundTimes = new int[numberOfProcesses];
        waitingTimes = new int[numberOfProcesses];

        for (int i = 0; i < numberOfProcesses; i++) {
            System.out.print("Enter the name of process " + (i + 1) + ": ");
            processNames[i] = scanner.next();
            System.out.print("Enter the arrival time of process " + (i + 1) + ": ");
            arrivalTimes[i] = scanner.nextInt();
            System.out.print("Enter the burst time of process " + (i + 1) + ": ");
            burstTimes[i] = scanner.nextInt();
        }
    }

    static void computeOutput() {
        for (int i = 0; i < numberOfProcesses; i++) {
            if (i == 0) {
                completionTimes[i] = arrivalTimes[i] + burstTimes[i];
            } else {
                if (arrivalTimes[i] > completionTimes[i - 1]) {
                    completionTimes[i] = arrivalTimes[i] + burstTimes[i];
                } else {
                    completionTimes[i] = completionTimes[i - 1] + burstTimes[i];
                }
            }

            turnaroundTimes[i] = completionTimes[i] - arrivalTimes[i];
            waitingTimes[i] = turnaroundTimes[i] - burstTimes[i];

            totalWaitingTime += waitingTimes[i];
            totalTurnaroundTime += turnaroundTimes[i];
        }

        averageWaitingTime = (float) totalWaitingTime / numberOfProcesses;
        averageTurnaroundTime = (float) totalTurnaroundTime / numberOfProcesses;
    }

    static void printOutput() {
        System.out.println("\nProcess Name\tArrival Time\tBurst Time\tCompletion Time\tTurnaround Time\tWaiting Time");

        for (int i = 0; i < numberOfProcesses; i++) {
            System.out.println(
                    processNames[i] + "\t\t" + arrivalTimes[i] + "\t\t" + burstTimes[i] + "\t\t" + completionTimes[i]
                            + "\t\t" + turnaroundTimes[i] + "\t\t" + waitingTimes[i]);
        }

        System.out.println("\nAverage Turnaround Time: " + averageTurnaroundTime);
        System.out.println("Average Waiting Time: " + averageWaitingTime);
    }
}

读者-写者问题的写者优先算法Java实现：

import java.util.concurrent.Semaphore;
import java.util.logging.Level;
import java.util.logging.Logger;

public class WriterPriorityReaderWriter {
    public static void main(String[] args) {
        Semaphore resourceAccess = new Semaphore(1);
        Semaphore readCountAccess = new Semaphore(1);
        Semaphore serviceQueue = new Semaphore(1);
        int readCount = 0;

        Writer writer = new Writer(resourceAccess, readCountAccess, serviceQueue);
        Reader reader = new Reader(resourceAccess, readCountAccess, serviceQueue, readCount);

        writer.start();
        reader.start();
    }
}

class Writer extends Thread {
    Semaphore resourceAccess;
    Semaphore readCountAccess;
    Semaphore serviceQueue;

    public Writer(Semaphore resourceAccess, Semaphore readCountAccess, Semaphore serviceQueue) {
        super("Writer");
        this.resourceAccess = resourceAccess;
        this.readCountAccess = readCountAccess;
        this.serviceQueue = serviceQueue;
    }

    public void run() {
        while (true) {
            try {
                serviceQueue.acquire();
                resourceAccess.acquire();
                System.out.println("Writing");
                resourceAccess.release();
                serviceQueue.release();
                sleep(1000);
            } catch (InterruptedException ex) {
                Logger.getLogger(Writer.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }
}

class Reader extends Thread {
    Semaphore resourceAccess;
    Semaphore readCountAccess;
    Semaphore serviceQueue;
    int readCount;

    public Reader(Semaphore resourceAccess, Semaphore readCountAccess, Semaphore serviceQueue, int readCount) {
        super("Reader");
        this.resourceAccess = resourceAccess;
        this.readCountAccess = readCountAccess;
        this.serviceQueue = serviceQueue;
        this.readCount = readCount;
    }

    public void run() {
        while (true) {
            try {
                serviceQueue.acquire();
                readCountAccess.acquire();
                readCount++;
                if (readCount == 1) {
                    resourceAccess.acquire();
                }
                readCountAccess.release();
                serviceQueue.release();

                System.out.println("Reading");
                readCountAccess.acquire();
                readCount--;
                if (readCount == 0) {
                    resourceAccess.release();
                }
                readCountAccess.release();
                sleep(1000);
            } catch (InterruptedException ex) {
                Logger.getLogger(Reader.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }
}