talk is easy, show the code

import Process.MaxResource.aMax
import Process.MaxResource.bMax
import Process.MaxResource.cMax
import Process.MaxResource.dMax

/**
 * 进程对象
 * @property name String 进程名
 * @property max Resource 该进程声明的最大所需资源
 * @property allocation Resource 为了创建进程所分配的资源
 * @property need Resource 为了执行进程所还需要的资源
 * @constructor 私有构造器, 防止被外部类直接实例化
 */
class Process private constructor(
    private val name: String,
    private val max: Resource,
    private val allocation: Resource
) {
    private lateinit var need: Resource

    /**
     * 使用静态变量存储系统最大资源值
     */
    private object MaxResource {
        var aMax = 3
        var bMax = 12
        var cMax = 14
        var dMax = 14

        /**
         * 以人能看懂的方式显示数据
         * @return String
         */
        override fun toString(): String {
            return "A -> $aMax B -> $bMax C -> $cMax D -> $dMax"
        }

        /**
         * 重载 比较 运算符, 方便检测系统安全性
         * @param other Resource 要比较的对象
         * @return Int 1 大于 0 等于 -1 小于
         */
        operator fun compareTo(other: Resource): Int {
            return if (other.A > aMax || other.B > bMax || other.C > cMax || other.D > dMax)
                1
            else if (other.A == aMax || other.B == bMax || other.C == cMax || other.D == dMax)
                0
            else -1
        }

    }

    /**
     * 资源对象
     * @property A Int
     * @property B Int
     * @property C Int
     * @property D Int
     * @constructor
     */
    private data class Resource(val A: Int, val B: Int, val C: Int, val D: Int) {
        /**
         * 申请资源
         */
        fun alloc() {
            aMax -= A
            bMax -= B
            cMax -= C
            dMax -= D
        }

        /**
         * 释放资源
         */
        fun free() {
            aMax += A
            bMax += B
            cMax += C
            dMax += D
        }

        /**
         * 以人能看懂的方式显示数据
         * @return String
         */
        override fun toString(): String {
            return "A -> $A B -> $B C -> $C D -> $D"
        }

        /**
         * 重载 - 运算符, 方便求还需要的资源
         * @param other Resource
         * @return Resource
         */
        operator fun minus(other: Resource): Resource {
            return Resource(
                A - other.A,
                B - other.B,
                C - other.C,
                D - other.D
            )
        }
    }

    /**
     * 使用 Builder 创建对象
     */
    object Builder {

        private lateinit var name: String
        private lateinit var maxResource: Resource
        private lateinit var allocResource: Resource

        /**
         * 进程名
         * @param value String
         * @return Builder
         */
        fun setName(value: String): Builder {
            this.name = value
            return this
        }

        /**
         * 已分配资源量
         * @param A Int
         * @param B Int
         * @param C Int
         * @param D Int
         * @return Builder
         */
        fun allocation(A: Int = 0, B: Int = 0, C: Int = 0, D: Int = 0): Builder {
            if (A > aMax || B > bMax || C > cMax || D > dMax)
                throw IllegalArgumentException("资源分配失败, 系统资源不够！")
            // 向系统申请资源创建进程
            allocResource = Resource(A, B, C, D).apply {
                alloc()
            }
            return this
        }

        /**
         * 资源最大需求量
         * @param A Int
         * @param B Int
         * @param C Int
         * @param D Int
         * @return Builder
         */
        fun max(A: Int = 0, B: Int = 0, C: Int = 0, D: Int = 0): Builder {
            maxResource = Resource(A, B, C, D)
            return this
        }

        /**
         * 构造 Process 对象
         * @return Process
         */
        fun build(): Process {
            // 如果存在没有初始化的对象, 那就使用默认参数初始化
            if (!this::name.isInitialized) setName("奥里给")
            if (!this::maxResource.isInitialized) max()
            if (!this::allocResource.isInitialized) allocation()
            return Process(name, maxResource, allocResource)
        }
    }

    /**
     * 检测系统安全性
     */
    fun checkSafe() {
        need = max - allocation
        println("进程名\t$name\n最大资源需求\t$max\n已分配资源\t$allocation\n还需要资源\t$need")
        println("当前剩余资源为 $MaxResource")
        if (MaxResource < need) {
            throw IllegalArgumentException("资源不够, 系统不安全！")
        } else {
            need.alloc()
            println(
                "资源正常分配, 系统安全\n当前剩余资源量为 $MaxResource\n" +
                        "$name 资源分配完毕, 进程结束释放资源"
            )
            need.free()
            allocation.free()
            println("资源释放完毕, 当前系统剩余资源量为 $MaxResource\n")
        }
    }
}

object Main {
    @JvmStatic
    fun main(args: Array<String>) {
        
        val p = listOf(
            Process.Builder.build(),
            Process.Builder
                .setName("P1")
                .max(C = 4, D = 4)
                .allocation(C = 3, D = 2)
                .build(),
            Process.Builder
                .setName("P2")
                .max(A = 2, B = 7, C = 5)
                .allocation(A = 1)
                .build(),
            Process.Builder
                .setName("P3")
                .max(A = 3, B = 6, C = 10, D = 10)
                .allocation(A = 1, B = 3, C = 5, D = 4)
                .build(),
            Process.Builder
                .setName("P4")
                .max(B = 9, C = 8, D = 4)
                .allocation(B = 3, C = 3, D = 2)
                .build(),
            Process.Builder
                .setName("P5")
                .max(B = 6, C = 6, D = 10)
                .allocation(C = 1, D = 4)
                .build()
        )
        p[1].checkSafe()
        p[4].checkSafe()
        p[5].checkSafe()
        p[2].checkSafe()
        p[3].checkSafe()
    }
}