Parallel Machine Scheduling Problem with Machine Rental Cost and Shared Service Cost

Abstract

With the rapid development of industrial internet, blockchain, and other new-generation information technology, the shared manufacturing model provides a new way to address the problems of low resource utilization of the traditional manufacturing industry and serious duplication of construction through the mechanism of collaborative resource sharing. Concurrently, to meet the requirements of sustainable development, manufacturing enterprises need to balance economic efficiency with production efficiency in their production practices. This study investigates an identical parallel machine offline scheduling problem with rental costs and shared service costs of shared machines. In machine renting, manufacturers with a certain number of identical parallel machines will incur fixed rental costs, unit variable rental costs, and shared service costs when renting the shared machines. The objective is to minimize the sum of the makespan and total sharing costs. To address this problem, an integer linear programming model is established, and several properties of the optimal solution are provided. A heuristic algorithm based on the number of rented machines is designed. Finally, numerical simulation experiments are conducted to compare the proposed heuristic algorithm with a genetic algorithm and the longest processing time (LPT) rule. The results demonstrate the effectiveness of the proposed heuristic algorithm in terms of calculation accuracy and efficiency. Additionally, the experimental findings reveal that the renting and scheduling results of the machines are influenced by various factors, such as the manufacturer’s production conditions, the characteristics of the jobs to be processed, production objectives, rental costs, and shared service costs.

1. Introduction

Shared manufacturing, relying on new infrastructures such as 5G, artificial intelligence, the industrial internet, and the internet of things, has quietly emerged and shown a booming development [1,2]. Shared manufacturing is the reuse of idle production capacity, which can optimize resource allocation, break information asymmetry, reduce manufacturing costs, expand effective supply, and enhance manufacturing service capabilities and levels [3], in line with the concept of sustainable development. As a result, shared manufacturing has become one of the key themes driving the high-quality and sustainable development of the manufacturing industry, aligning with the trend towards intelligent, efficient, and service-oriented economic development.

Under the impetus of development demands and policy support, many Chinese enterprises have achieved fruitful practices in implementing sharing systems. For example, the “Oscar COSMOPlat” has connected 900,000 enterprises, the INDICS platform has integrated over 1.7 million pieces of industrial equipment, and Tao Factory has enabled online collaboration for millions of factories and traders. In addition, there are also the Mould Lao crowd creative space, Shugen Internet, China Aerospace Cloud Platform, Haichuanghui, and the Shenyang Machine Tool Sharing Platform, among others. However, the supply and demand configuration of enterprise resources under shared manufacturing still faces many new challenges. These are primarily reflected in the lack of effective guidance for enterprises in sharing both internal and external manufacturing resources. Additionally, there are ongoing issues with the full utilization of resources and the optimization of manufacturing costs [1]. China’s small and medium-sized manufacturing enterprises are characterized by their relatively small scale and limited investment. They are often at a disadvantage in terms of human and material resources. However, these enterprises are numerous and densely distributed. If external shared resources can be reasonably allocated, it will effectively compensate for the shortage of manufacturing resources. This, in turn, will enhance production efficiency, profitability, and customer satisfaction. Moreover, it will help to narrow the gap between enterprises and promote the overall economic balance and sustainable development of society.

Production scheduling, as a crucial component of real-world production management, significantly impacts the production efficiency, cost, and competitiveness of enterprises [4,5]. However, most existing research on production scheduling focuses solely on the scheduling of enterprises’ own machines. In the context of shared manufacturing, optimizing the rental costs of shared machines while enhancing the production efficiency of small and medium-sized manufacturing enterprises with limited production capacity is essential. Formulating a rational and efficient machine renting and scheduling scheme is thus an urgent problem to be addressed. This paper investigates the offline scheduling problem of identical parallel machines, considering fixed rental costs, unit variable rental costs, and shared service costs. The objective is to minimize the sum of the maximum completion time (makespan) and the total shared costs. This study aims to provide a scientific basis for schedulers to make informed decisions regarding resource sharing and scheduling schemes. By doing so, it helps enterprises reduce sharing costs while improving production efficiency and customer satisfaction, ultimately promoting accurate and efficient matching of the supply and demand of manufacturing resources.

The main contributions of this work are as follows:

(1)

In the context of shared manufacturing, we incorporate shared machines with rental costs and shared service costs into the classic parallel machine scheduling problem. We investigate how machine sharing influences the production scheduling decisions of enterprises.

(2)

We establish an integer programming model, analyze the properties of the problem, and provide the optimal scheduling case without renting machines, the range of the number of machine rentals, and the upper bound of the problem.

(3)

We propose a heuristic algorithm based on the number of shared machine rentals to address large-scale instances of the considered problem.

The rest of this paper is organized as follows. Section 2 reviews the relevant papers in the literature. Section 3 describes the considered problem and constructs an integer programming model. Section 4 analyzes the properties of the problem. Section 5 proposes a heuristic algorithm. In Section 6, the experimental results, together with a sensitivity analysis, are presented. Finally, Section 7 concludes this work and suggests future research directions.

2. Literature Review

Manufacturing resource sharing offers new insights for optimizing resource allocation in the scheduling domain. Efficient resource utilization is closely tied to the rational design of sharing strategies and scheduling optimization. Existing related studies have analyzed the sharing strategies for various manufacturing resources, including processing capacity [6], multi-skilled human resources [7], orders [8], and information [9]. Some studies focus on how an additional flexible resource (e.g., operators) can speed up the process of jobs. They emphasize that different combinations of jobs and machines require varying amounts of flexible resources. Interested readers can refer to references [10,11]. This focus is distinct from studies on resource sharing that consider the cost of sharing. Since this paper primarily investigates the sharing and scheduling scheme of machine resources, this section focuses on reviewing studies related to the scheduling optimization of shared machine resources in detail. Parallel machine scheduling problems have been studied widely in the literature. A recent review of optimization algorithms for $P\left|\right|C_{max}$ problem can be seen in Ostojic et al. [12]. The significance of the literature in other scheduling areas, such as job shop scheduling [13,14] and flow shop scheduling [15,16], is acknowledged. This section mainly reviews the scheduling optimization research on the “time + cost” objective function and the usage cost of identical parallel machines, which is closely related to this paper.

2.1. Shared Machine Resource Scheduling Problem

Shared parallel machine scheduling is an important application of shared resource scheduling. Dereniowski and Kubiak [17,18] considered the preemptive job situation, assuming that each job could be executed on its private processor and simultaneously on possibly many shared processors. Their goal was to maximize the total weighted overlap of all jobs. Li et al. [19] considered two uniform parallel machine scheduling problems with fixed shared rental cost and proposed two heuristic algorithms to minimize the makespan with a given budget of total cost. Ji et al. [20] proposed a shared parallel machine scheduling model with machine processing set restrictions, aiming at minimizing the sum of makespan and total shared service cost. They designed a fully polynomial-time approximation scheme. Xu et al. [21] considered the shared benefit, time value of money, and due date-to-deadline window, with the objective of maximizing the total future value of profits. They designed a genetic algorithm and a heuristic algorithm. Zheng et al. [22] described a sharing platform as one parallel machine scheduling problem with machine-order type matching and order splitting. Their objective was to minimize the sum of the total processing cost of machines used and the total completion time of orders. They designed a hybrid multiobjective migrating bird optimization combined with a genetic operation and a discrete event system. Xu et al. [23,24] studied the online scheduling optimization problem of shared parallel machines, considering the shared machine rental costs and discounts. Cheng et al. [25] explored the problem of parallel machine scheduling in a shared manufacturing environment and incorporated energy scheduling where the optimization objective was to minimize the weighted sum of makespan, total energy consumption, and overall sharing costs.

A limited number of studies have also examined the shared shop scheduling problem. Wei and Wu [26] studied two two-machine hybrid flow-shop problems with fixed processing sequences in the context of shared manufacturing. Fu et al. [27] proposed a stochastic bi-objective two-stage open shop scheduling problem for shared professional equipment, aiming to minimize total tardiness and processing costs subject to various resource constraints.

2.2. Scheduling Problem with a Time + Cost Objective Function

When addressing scheduling problems that involve production costs, it is essential to consider not only traditional production performance objectives related to time but also other cost-related objectives. One of the more common forms of objective functions in related research is to minimize the weighted sum of time-related objectives and total cost objectives. Furthermore, much of the literature considers the time-related objective to be as important as the cost-related objective and assumes a weighting factor of 1 for both. For example, this can include minimizing the sum of the makespan and the total machine purchase cost [28], the total sharing cost [20,23], the total rejection cost [29,30], the total resource consumption cost [31,32], or the total outsourcing cost [33,34]. Other examples include minimizing the sum of the total weighted completion time and the total rejection cost [35] or the total outsourcing cost [36]. Additionally, there are objectives such as minimizing the sum of the total completion time and the total machine processing cost [22], the total rejection cost [37], or the total outsourcing cost [38], among others.

2.3. Scheduling Problem with the Usage Cost of Identical Parallel Machines

Ruiz-Torres et al. [39] assumed that machine costs consist of a fixed cost and a variable cost. For machine costs with concave functions, they derived the general characteristics of optimal solutions regarding decisions on the number of machines to use and the way to load machines. Rustogi and Strusevich [40] assumed that the machine cost is a linear function of the number of machines used. They examined the impact of increasing the number of machines on both makespan and total flow time. Lee et al. [41] assumed that each job–machine combination may have a different cost. They studied two bi-criteria scheduling problems, proposed fast heuristics, and established the corresponding worst-case performance bounds. Li Kai et al. believed that each machine has a cost per unit of time that differs from machine to machine. They considered the problem of minimizing the makespan or the total completion time [42] and the problem of minimizing the maximum lateness [43]. Jiang et al. [44] assumed that each machine has a different constant processing cost per unit of time and designed corresponding approximation algorithms for two different production objectives. Anghinolfi et al. [45] considered the energy consumption rate and the time-of-use electricity prices of different machines. They designed an ad hoc heuristic method to minimize both the makespan and the total energy consumption. Jarboui et al. [46] assumed that each machine has a fixed energy consumption rate and a positive energy price in each period. They explored the multiobjective problem of minimizing both the makespan and the total energy cost simultaneously and proposed an epsilon oscillation algorithm. Wu et al. [47] considered the fixed usage cost of each machine. $\epsilon$-LO-MILP, $\epsilon$-LBBD, and NSGA-II are presented to solve the bi-objective scheduling problem of minimizing the maximum completion time and the total cost including machine usage cost and resource consumption cost.

The existing scheduling literature considering machine costs assumes that the machines have the same cost components and that the scheduling scope is limited to self-owned machines. However, there are only a few studies on shared machine resource scheduling that consider both machines’ own scheduling schemes and shared machines’ renting and scheduling schemes. The differences from this paper mainly include the cost components, optimization objectives, problem characteristics, and optimization methods. This paper focuses on the fixed rental cost, unit variable rental cost, and shared service cost associated with shared machines. The goal is to provide a scientific basis for the formulation of resource-sharing and optimized scheduling schemes for small and medium-sized manufacturing enterprises with insufficient production capacity, thereby promoting the sustainable development of manufacturing enterprises.

3. Problem Description

Consider a machine set $\mathcal{M}=\left\{M_i\right|i=1,2,\dots ,m+k\}$ consisting of $m+k$ parallel machines with the same processing speed. Here, $m\ge 2$ represents the number of machines owned by the manufacturer, and $k\ge 1$ denotes the number of shared machines that can be rented on the sharing platform. Let h be the number of shared machines actually rented given a set of jobs $\mathcal{J}=\left\{J_j\right|j=1,2,\dots ,n\}$, where n is the total number of jobs. $p_j$ ($p_j>0$) denotes the processing time of job $J_j$. It is assumed that any job $J_j$ can be processed either on the manufacturer’s own machines or on a rented external machine. The manufacturer must pay a fixed rental cost a (e.g., preparation and cleaning costs of the shared machine) and a unit variable rental cost b for renting a shared machine $M_i$ ($m+1\le i\le m+k$). Specifically, the rental cost of the machine is $a+b{C}_i$, where $C_i$ represents the completion time of machine $M_i$. In addition, we consider the shared service cost $u_{ij}$ (e.g., transportation cost for raw materials or finished products, processing preparation cost, service cost, etc., collectively referred to as shared service cost) incurred when renting machine $M_i$ ($m+1\le i\le m+k$) to process job $J_j$. Here, it is assumed that all shared parallel machines have the same fixed rental cost and unit variable rental cost. That is, for $\forall i\in [m+1,m+k]$, $a_i=a$, $b_i=b$. Meanwhile, we do not consider the existing sunk cost associated with the manufacturer’s own machines. Therefore, for $\forall i\in [1,m]$, $a_i=b_i=u_{ij}=0$.

Without loss of generality, some basic assumptions are made [45]: (1) Each job is assigned to only one selected machine for processing; (2) Each machine only processes one job at a time; (3) Preemption is not allowed.

Similar to the “time + cost” objective function discussed in previous research reviews, this paper considers the time objective and the cost objective to be of equal importance. Dimensionless normalization of the data is achieved by adjusting the units of time-related and cost-related parameters. For example, time units such as minutes are converted to hours, or days to weeks, while cost units like dollars are transformed into hundreds, thousands, or tens of thousands of dollars. This approach ensures that temporal and cost parameters are scaled to the same order of magnitude. Let $\sigma$ denote a feasible scheduling scheme. The problem is to find the optimal scheduling scheme ${\sigma }^{\ast }$ that minimizes the sum of the makespan and the total shared cost. The three-parameter representation of the problem can be expressed as $P_{m+k}\parallel C_{max}+\sum S_i$, where $P_{m+k}$, $C_{max}$, and $\sum S_i$ denote the identical parallel machine, the maximum completion time, and the total shared cost (the sum of the total machine rental cost and the total shared service cost), respectively. We define two binary variables, $x_{ij}$ and ${\beta }_i$. If job $J_j$ is scheduled to be processed on machine $M_i$, let $x_{ij}=1$; otherwise, $x_{ij}=0$. If machine $M_i$ is used, let ${\beta }_i=1$; otherwise, ${\beta }_i=0$. Therefore, the shared cost of machine $M_i$ is $S_i=a_i{\beta }_i+b_i{\sum }_{j=1}^n{p}_j{x}_{ij}+{\sum }_{j=1}^n{u}_{ij}{x}_{ij}$. When $\forall b_i=0$, the problem reduces to a scheduling problem considering only the fixed rental cost and the shared service cost of shared machines. When $\forall u_{ij}=0$, the problem reduces to a scheduling problem considering the fixed rental cost and the unit variable cost of shared machines. It can be seen that this problem is more general.

4. Model Formulation

In this section, we introduce the notations, formulate the mathematical model based on the fixed rental cost, unit variable rental cost, and shared service cost associated with the shared machines, and provide detailed explanations of the constraints.

4.1. Notations

The indices, parameters, and decision variables used in the model are defined as follows:

Indices:

i: the index of machines, $i=1,2,\dots ,m+k$;

j: the index of jobs, $j=1,2,\dots ,n$.

Parameters:

m: the number of owned machines;

k: the number of shared machines;

n: the number of jobs;

$a_i$: the fixed rental cost, $a_i=a$ if machine $M_i$ ($i=m+1,m+2,\dots ,m+k$) is a shared machine and $a_i=0$ otherwise;

$b_i$: the unit variable rental cost, $b_i=b$ if machine $M_i$ ($i=m+1,m+2,\dots ,m+k$) is a shared machine and $b_i=0$ otherwise;

$p_j$: the processing time of job $J_j$, $j=1,2,\dots ,n$;

$u_{ij}$: the shared service cost, $u_{ij}>0$ if job $J_j$ is processed on shared machine $M_i$ ($i=m+1,m+2,\dots ,m+k$) and $u_{ij}=0$ otherwise;

Decision variables

${\beta }_i$: binary variable, ${\beta }_i=1$ when machine $M_i$ is used;

$x_{ij}$: binary variable, $x_{ij}=1$ when job $J_j$ is processed on machine $M_i$.

Dependent variables

$C_{max}$: the makespan;

$S_i$: the shared cost of machine $M_i$;

4.2. Mathematical Model

Based on the settings of the above parameters and variables, the following mathematical model is established for the considered problem. The objective is to minimize the sum of the makespan $C_{max}$ and the total shared cost ${\sum }_{i=1}^{m+k}{S}_i$, where $S_i$ is the shared cost of machine $M_i$. $S_i$ is defined as follows in Equation (1).

$$S_i=a_i{\beta }_i+b_i\sum _{j=1}^n{p}_j{x}_{ij}+\sum _{j=1}^n{u}_{ij}{x}_{ij}$$

(1)

The objective function can thereby be formulated as follows:

$$minZ=C_{max}+\sum _{i=1}^{m+k}{S}_i$$

(2)

Constraint (3) ensures that each job must be scheduled on a certain machine.

$$\sum _{i=1}^{m+k}{x}_{ij}=1,\forall j=1,\dots ,n$$

(3)

Constraint (4) indicates that the completion time of machine $M_i$ is not greater than the maximum completion time $C_{max}$.

$$\sum _{j=1}^n{p}_j{x}_{ij}\le C_{max},\forall i=1,\dots ,m+k$$

(4)

Constraint (5) establishes the relationship between variables ${\beta }_i$ and $x_{ij}$, indicating that only the machines that are used will be assigned jobs.

$$x_{ij}\le {\beta }_i,\forall i=1,\dots ,m+k\mathrm{and}j=1,\dots ,n$$

(5)

Finally, constraint (6) specifies the ranges of the binary variables.

$$x_{ij}\in \{0,1\},{\beta }_i\in \{0,1\},\forall i=1,\dots ,m+k\mathrm{and}j=1,\dots ,n$$

(6)

5. Problem Property

In this section, some problem-specific properties are derived for an in-depth understanding and solving the problem $P_{m+k}\parallel C_{max}+\sum S_i$.

When $a\to \infty$ or $a=0$, $b=0$, $\forall u_{ij}=0$, the problem simplifies to $P\parallel C_{max}$, which is known to be strong NP-hard [48]. Consequently, the problem $P_{m+k}\parallel C_{max}+\sum S_i$ is also a strong NP-hard problem. When $a=0$, the problem can be regarded as a special case of the problem discussed in the literature [20]. Therefore, we will focus on the case where $a>b\ge 0$ in the following discussion. When job $J_j$ is assigned to a shared machine $M_i$ ($m+1\le i\le m+k$) for processing, $C_{max}$ can decrease by at most $p_j$, while the rental cost will increase by at least $b{p}_j+u_{ij}$. If $b\ge 1$, the optimal scheduling would not involve renting the shared machine $M_i$. Hence, we will restrict our discussion to the case where $0\le b<1$.

Let $p_{max}={max}_{j=1}^n\left\{p_j\right\}$, $P={\sum }_{j=1}^n{p}_j$. For the problem $P\left|pmtn\right|C_{max}$, where $pmtn$ indicates that jobs are interruptible, McNaughton’s wrap-around rule [49] provides the optimal solution $C_{max}^{\ast }=max\{p_{max},P/m\}$. When jobs are non-interruptible, the optimal maximal completion time satisfies $C_{max}^{\ast }\ge p_{max}$ and $C_{max}^{\ast }\ge P/m$. Therefore, Properties 1 and 2 can be readily derived. In Property 1, $\lceil P/p_{max}\rceil$ denotes the minimum number of machines required such that the maximum processing time of all jobs is greater than or equal to the average completion time of the machines. Consequently, when the number of owned machines is greater than or equal to this value, the optimal scheduling does not involve renting shared machines. When the fixed rental cost a of the shared machine is sufficiently large, the optimal scheduling also avoids renting machines. Property 2 specifies the value range of a in this scenario. Proof is in the Appendix A.

Property 1. 

For problem $P_{m+k}\parallel C_{max}+\sum S_i$, if $m\ge \lceil P/p_{max}\rceil$, then the optimal scheduling does not rent shared machines, and the optimal objective value is $p_{max}$.

Property 2. 

For problem $P_{m+k}\parallel C_{max}+\sum S_i$, if $a\ge \lfloor P/(m+1)\rfloor$, then the optimal scheduling does not rent shared machines.

As mentioned above, if job $J_j$ is assigned to the shared machine $M_i$ ($m+1\le i\le m+k$), $C_{max}$ will decrease by at most $p_j$, and the rental cost will increase by at least $b{p}_j+u_{ij}$. If $u_{ij}\ge (1-b)p_j$, then $b{p}_j+u_{ij}\ge p_j$, and the optimal scheduling will not rent the shared machine $M_i$ to process job $J_j$. Therefore, Property 3 can be obtained.

Property 3. 

For problem $P_{m+k}\parallel C_{max}+\sum S_i$, if $u_{ij}\ge (1-b)p_j$, the optimal scheduling will not assign job $J_j$ to the shared machine $M_i$ for processing.

Before arranging the processing sequence of jobs, it is necessary to first determine the number of rented machines. Property 4 provides a range of the possible numbers of machines to be rented for optimal scheduling. Proof is in the Appendix A.

Property 4. 

Let the optimal scheduling ${\sigma }^{\ast }$ rent $h^{\ast }$ machines. Then, $h^{\ast }$ satisfies the following:

(1) When $1-bm>0$, if $\sqrt{P(1-bm)/a}-m\le 0$, $h^{\ast }=0$, if $0<\sqrt{P(1-bm)/a}-m<k$, $h^{\ast }\le \lceil \sqrt{P(1-bm)/a}\rceil -m$, and if $\sqrt{P(1-bm)/a}-m\ge k$, $h^{\ast }\le k$.

(2) When $1-bm\le 0$, $h^{\ast }=0$.

In the research problem, the manufacturer decides whether to rent a machine based on actual conditions in order to reduce the maximum completion time of the jobs. Therefore, when renting a shared machine is not considered, the maximum completion time $C^{LPT}$ obtained by scheduling all jobs on the manufacturer’s own machines using the LPT rule is an upper bound of the problem, i.e., Property 5.

Property 5. 

For problem $P_{m+k}\parallel C_{max}+\sum S_i$, $Z^{\ast }\le C^{LPT}$, where $C^{LPT}$ is the maximum completion time obtained using the LPT rule on owned machines.

6. Solution Approach

6.1. Algorithm Design Ideas

Although the optimal solution can be obtained using mathematical programming models, the computation time may be excessively long, particularly for large-scale problems. To provide decision-makers with an efficient scheduling solution in a timely manner, this section designs a heuristic algorithm based on the number of shared machine rentals (number of shared machine-dependent heuristic, NSMD-H). This algorithm builds upon the results of the problem property analysis. According to the properties discussed in Section 5, when $m\ge \lceil P/p_{max}\rceil$ or $a\ge \lfloor P/(m+1)\rfloor$ or $1-bm\le 0$ or $1-bm>0$ and $\sqrt{P(1-bm)/a}-m\le 0$, the optimal scheduling does not involve renting shared machines. At this time, the LPT rule is applied to schedule jobs on the manufacturer’s own machines, ensuring that $C^{LPT}\le ({\displaystyle \frac{4}{3}}-{\displaystyle \frac{1}{3m}})C_{max}^{\ast }$[50]. When none of the above four conditions hold, the heuristic algorithm NSMD-H is employed to solve the problem. If the LPT rule is still used to schedule jobs on the manufacturer’s own machines, then the performance ratio is $Z\left(LPT\right)/Z^{\ast }=O(k/m)$. For example, consider a scenario with $n\to \infty$ jobs, each with a processing time of p, which can be processed on m owned machines and k shared machines, where n is a multiple of m and $m+k$. Let $a\to 0$, $b=0$, and $\forall u_{ij}=0$. In this case, the performance ratio is given as follows: $Z\left(LPT\right)/Z^{\ast }=(np/m)/[(np/(m+k)+ak]=1+k/m$.

The main idea of the heuristic algorithm NSMD-H is to first determine the number of rented machines and then to obtain the minimum value of the maximum completion time for the owned machines. Based on this value and the ratio of service cost to job processing length, the algorithm determines which jobs should be assigned to the owned machines and which to the shared machines. It then schedules and adjusts the jobs accordingly. Specifically, the algorithm proceeds as follows:

(1)

Initial Scheduling: Schedule all jobs on the owned machines using the LPT rule.

(2)

Determine Number of Rented Machines: According to Property 4, determine the minimum number of rented machines, H. If $H>0$, iterate over the number of rented machines h from 1 to H and perform the following steps for each h:

(i)

Job Assignment: Determine the jobs assigned to the owned machines and each shared machine. Schedule jobs on the owned machines using the LPT rule, and sort jobs on the shared machines in non-decreasing order based on the ratio of service cost to job processing time.

(ii)

Remove Duplicates: Eliminate any jobs that are scheduled multiple times on the shared machines to ensure each job is processed only once.

(iii)

Adjust Shared Machine Jobs: For shared machines with completion times exceeding those of the owned machines, adjust the job assignments to balance the load.

(iv)

Optimize Machine Utilization: Adjust jobs on shared machines with lower completion times to minimize the number of rented machines and reduce the overall objective value.

(v)

Reassignment Check: Evaluate whether jobs initially assigned to the owned machines can be reassigned to rented shared machines to further reduce the objective value.

(vi)

Output Results: Record the scheduling result and the corresponding objective value for each h.

(3)

Select Optimal Solution: After completing the above steps for all possible values of h, select the scheduling scheme with the smallest objective value as the final result of the algorithm.

6.2. Algorithm Implementation Steps

The execution flow of NSMD-H is illustrated in Figure 1. The specific algorithm is described as follows:

Step 1. Assign all jobs to owned machines according to the LPT rule to obtain the initial schedule ${\sigma }_0$ and the target value $Z_0$. According to Property 4, if $\sqrt{P(1-bm)/a}-m\le 0$, then let $H=0$. If $0<\sqrt{P(1-bm)/a}-m<k$, then set $H=\lceil \sqrt{P(1-bm)/a}-m\rceil$. If $\sqrt{P(1-bm)/a}-m\ge k$, then set $H=k$. If $H>0$, then for each h from 1 to H, execute Steps 2 to 5 in sequence. Otherwise, proceed to Step 6.

Step 2. Sort the jobs in non-increasing order based on $\underset{i\in \{m+1,\dots ,m+k\}}{\min }{u}_{ij}/p_j$. Select the jobs sequentially until the sum of the processing times of the selected jobs exceeds $Pm/(m+h)$, and assign these selected jobs to the owned machines. Then, assign the jobs that satisfy $\underset{i\in \{m+1,\dots ,m+k\}}{\min }{u}_{ij}\ge (1-b)p_j$ to the owned machines according to Property 3. The jobs of the owned machines are scheduled according to the LPT rule, and the maximum completion time $C_{max}^0$ is calculated. The jobs on the shared machines are sorted in non-decreasing order according to $u_{ij}/p_j$, and the completion times of these machines are calculated. Let the set of completion times for the shared machines be $\mathcal{CI}=\{C_{m+1},\dots ,C_{m+k}\}$. If there are jobs that are processed repeatedly on the shared machines, run Step 3. Otherwise, obtain the feasible schedule ${\sigma }_h$ and determine whether there is a value greater than $C_{max}^0$ in $\mathcal{CI}$. If so, run Step 4; otherwise, run Step 5.

Step 3. Delete the repeatedly processed jobs, which mainly involves the following two steps:

Step 3.1. Let the set of repeatedly processed jobs on the shared machines be denoted by ${\mathcal{J}}_r$, and let $\mathcal{CI}\prime =\mathcal{CI}$. If $max\{\mathcal{CI}\prime \}>C_{max}^0$, determine whether there are any repeatedly processed jobs on the machine with a completion time equal to $max\{\mathcal{CI}\prime \}$. If so, delete the job with the largest processing position among the repeatedly processed jobs, and update $\mathcal{CI}$, $\mathcal{CI}\prime$, and ${\mathcal{J}}_r$. If not, set the completion time of the corresponding machine in $\mathcal{CI}\prime$ equal to 0, and repeat this step until $max\{\mathcal{CI}\prime \}\le C_{max}^0$.

Step 3.2. If ${\mathcal{J}}_r\ne \varnothing$, for each repeatedly processed job, retain only the instance on the machine with the smallest ratio of the job processing position to the number of jobs. If multiple machines have equal ratios, retain the job on the machine with the smallest machine number and delete the repeatedly processed jobs on the remaining machines. Sort the jobs on the shared machines by $u_{ij}/p_j$ in a non-decreasing order, update $\mathcal{CI}$, and obtain the schedule ${\sigma }_h$. If $max\left\{\mathcal{CI}\right\}>C_{max}^0$, run Step 4, otherwise, run Step 5.

Step 4. Let $M_I$ be the shared machine with a completion time equal to $max\left\{\mathcal{CI}\right\}$. If there are already rented machines with completion times less than $C_{max}^0$ (denoted by the set $\overline{\mathcal{M}}$ ), proceed to Step 4.1. Then, if $C_I>C_{max}^0$, there are unrented machines (denoted by the set ${\mathcal{M}}_0$), and $k-|{\mathcal{M}}_0|<h$, let the number of machines that need to be rented be $h_0=min\{\lceil (C_I-C_{max}^0)/C_{max}^0\rceil ,h-(k-|{\mathcal{M}}_0\left|\right)\}$, and run Step 4.2. Then, if $C_I>C_{max}^0$, proceed to Step 4.3. Repeat this step until $max\left\{\mathcal{CI}\right\}\le C_{max}^0$.

Step 4.1. Adjust the jobs on $M_I$ in sequence. For example, consider the job $J_g$ on $M_I$. Sort the machines in $\overline{\mathcal{M}}$ according to $u_{ig}$ (where $i\in \overline{\mathcal{M}}$) in non-decreasing order, and determine whether $J_g$ can be moved to each machine for processing in sequence. For instance, consider $M_l$ in $\overline{\mathcal{M}}$. If $J_g$ is moved to $M_l$, the following conditions must be satisfied: (1) $u_{lg}-s{c}_{Ig}\le z$ (where $z=p_g$ if $max\left\{\mathcal{CI}\right\}-C_{max}^0\ge p_g$, and $z=max\left\{\mathcal{CI}\right\}-C_{max}^0$ otherwise); (2) $C_l\le C_{max}^0$; (3) $u_{lg}<(1-b)p_g$. If all these conditions are met, move $J_g$ to $M_l$, update $\mathcal{CI}$ and ${\sigma }_h$, and do not consider other adjustable machines after $M_l$. If $C_I\le C_{max}^0$, there is no need to adjust any other jobs on $M_I$ after $J_g$.

Step 4.2. If $(C_I-C_{max}^0)/C_{max}^0\ge 1$, set $D=C_{max}^0$; otherwise, set $D=C_I-C_{max}^0$. Each machine in ${\mathcal{M}}_0$ performs the following operations in sequence. For example, consider machine $M_q$ in ${\mathcal{M}}_0$: The jobs on $M_I$ are sorted by $u_{qj}/p_j$ in non-decreasing order, and the processing times of the jobs that satisfy $u_{qj}<(1-b)p_j$ are added in sequence. When the cumulative sum of the jobs’ processing times $SP$ is greater than D, stop the summation. Let ${\mathcal{J}}_q$ be the set of jobs whose processing times are summed. If $C_I-SP\ge C_{max}^0$, set $W_q=SP-(a+\Delta u)$; otherwise, set $W_q=(C_I-SP)-(a+\Delta u)$, where $\Delta u$ represents the increase in service cost after adjusting the job. After all machines in ${\mathcal{M}}_0$ complete these operations, obtain the sets $\mathcal{W}$ and $\mathcal{J}$. If $max\left\{\mathcal{W}\right\}\ge 0$, identify the machine $M_u$ corresponding to $max\left\{\mathcal{W}\right\}$. Move the jobs in ${\mathcal{J}}_u$ from $M_I$ to $M_u$, and update $\mathcal{CI}$, ${\mathcal{M}}_0$, and ${\sigma }_h$. Perform the above operation $h_0$ times.

Step 4.3. The jobs on $M_I$ are sorted in non-increasing order based on $u_{Ij}/p_j$ and are assigned sequentially to the owned machines. When the sum of the processing times of the assigned jobs exceeds $m(C_I-C_{max}^0)/(m+1)$, no further jobs from $M_I$ are assigned to the owned machines. Update $\mathcal{CI}$, schedule the jobs on the owned machines according to the LPT rule, and update $C_{max}^0$ and ${\sigma }_h$.

Step 5. Let the set of rented machines be ${\mathcal{M}}_1$, and initialize ${\sigma }_h^{\prime }={\sigma }_h$ and $\mathcal{CI}\prime =\mathcal{CI}$. If ${\mathcal{M}}_1\ne ⌀$, identify the machine with the smallest completion time in ${\mathcal{M}}_1$ as $M_s$, with completion time $C_s$. If $C_s>\left(\right|{\mathcal{M}}_1|-1)C_{max}^0-({\displaystyle \sum _{i\in {\mathcal{M}}_1}}{C}_i-C_s)$, run Step 6. Otherwise, adjust the jobs on $M_s$ in ${\sigma }_h^{\prime }$ as follows. For example, consider a job $J_G$ on $M_s$. Sort the machines in ${\mathcal{M}}_1\setminus \left\{M_s\right\}$ according to $u_{iG}$ in non-decreasing order. Initialize $loop=0$. Determine if $J_G$ can be moved to them for processing in sequence. Take the machine $M_L$ in ${\mathcal{M}}_1\setminus \left\{M_s\right\}$ as an example. If moving $J_G$ to $M_L$ satisfies both $C_L+p_G\le C_{max}^0$ and $u_{LG}<(1-b)p_G$, then move $J_G$ to $M_L$. Calculate the increase in service cost $\Delta$. Set $loop=1$, update $\mathcal{CI}\prime$ and ${\sigma }_h^{\prime }$. No further machines need to be considered after $M_L$. If $loop=0$, set ${\sigma }_h^{\prime }={\sigma }_h$, $\mathcal{CI}\prime =\mathcal{CI}$. No further jobs need to be judged after $J_G$. If $a-\sum \Delta u>0$, set ${\sigma }_h={\sigma }_h^{\prime }$, $\mathcal{CI}=\mathcal{CI}\prime$; otherwise, set ${\sigma }_h^{\prime }={\sigma }_h$, $\mathcal{CI}\prime =\mathcal{CI}$. Remove $M_s$ from ${\mathcal{M}}_1$, ${\mathcal{M}}_1={\mathcal{M}}_1\setminus \left\{M_s\right\}$, and repeat the above operations until ${\mathcal{M}}_1=⌀$. Finally, calculate the target value $Z_h$ for ${\sigma }_h$.

Step 6. Select the scheduling scheme with the minimum objective value and perform local adjustments to further optimize it.

Step 6.1. Select the scheduling $\sigma$ and h corresponding to the minimum objective value from $Z_0$ and $Z=\{Z_1,Z_2,\dots ,Z_H\}$. If $h=0$, then $\sigma ={\sigma }_0$ is the scheduling result of the algorithm, with the objective value being $Z_0$. Otherwise, let the completion time of all machines be $\mathcal{C}=\{C_1,\dots ,C_{m+k}\}$, set $u_{ij}^{\prime }=u_{ij}$, let ${\mathcal{M}}_1$ be the set of rented machines, and let ${\mathcal{J}}_0$ be the set of jobs on the owned machines.

Step 6.2. Find the machine $M_{i^{\prime }}$ and the job $J_{j^{\prime }}$ that correspond to $\underset{i\in {\mathcal{M}}_1,j\in {\mathcal{J}}_0}{min}{u}_{ij}^{\prime }$. If assigning job $J_{j^{\prime }}$ to machine $M_{i^{\prime }}$ and sorting the jobs on the owned machines according to the LPT rule results in a decrease in the objective value, then perform this operation and update $\mathcal{C}$ and ${\mathcal{J}}_0$. Otherwise, set $u_{i^{\prime }{j}^{\prime }}^{\prime }=\sum p_j$. Repeat Step 6.2 until $\forall u_{i^{\prime }{j}^{\prime }}^{\prime }=\sum p_j$, $i^{\prime }\in {\mathcal{M}}_1$, $j^{\prime }\in {\mathcal{J}}_0$ or the maximum completion time of the shared machines is greater than or equal to the maximum completion time of the owned machines.

In this heuristic algorithm, the computation times of Step 1 and Step 2 are $O(nlogn)$. The computation time of Step 3 is $O\left(nk\right)$. The computation times of Step 4.1, Step 4.2, and Step 4.3 are $O\left(nk\right)$, $O\left(n{k}^2\right)$, and $O(nlogn)$, respectively. Since Step 4.1 to Step 4.3 are executed at most k times, the computation time of Step 4 is $max\{O\left(n{k}^3\right),O(knlogn)\}$. The computation times of Step 5 and Step 6 are $O\left(n{k}^2\right)$ and $O\left(nk\right)$, respectively. Since Step 2 to Step 5 are executed at most k times, the computation time complexity of NSMD-H is $max\{O\left(n{k}^4\right),O(k^{2}nlogn)\}$.

7. Computation Experiments

This section analyzes the performance of the proposed NSMD-H algorithm through numerical experiments. The mathematical programming model and the algorithm are coded in MATLAB R2024b and executed on a personal computer (Intel Core i7-8550U, 8 GB memory, Windows 11 64 bit). CPLEX12.10 is employed to solve the integer programming model accurately. CPLEX employs its default branch-and-bound algorithm for such problems. The optimal or satisfactory solution is found efficiently by systematically enumerating the space of potential solutions, combined with pruning techniques. The calculation time limit of CPLEX is set to 7200 s. The following will introduce data generation, experimental results, and analysis in sequence.

The problem parameters are randomly generated similar to references [19,22], and the case scale is shown in

Table 1. The related parameter ranges.

Parameter	Range
Number of jobs n	20, 50, 100, 200, 500, 800
Number of owned machines m	2, 4, 6, 8, 10
Number of shared machines k	4, 8, 10
Processing time of job $J_j$ $p_j$	$U[1,20]$
Fixed rental cost of shared machine a	$U(0,10]$
Unit variable rental cost of shared machine b	$U[0,1/m)$
Shared service cost $u_{ij}$	$U[0,\lceil p_j\rceil ]$

Note: $U[x,y]$ represents a uniform distribution on $[x,y]$.

.

For the above cases, CPLEX, NSMD-H, and a Genetic Algorithm (GA) are used to solve the problem, and the LPT rule is used to schedule jobs on the owned machines. The results obtained from these methods are compared and analyzed. The GA algorithm in this section is based on the work in [21], which shares similarities with this paper by considering jobs on both owned and external machines. The GA algorithm from [21] is known for its high computational accuracy. Therefore, the GA algorithm in this section adopts the same individual gene coding representation, mutation operator, and selection operator as in [21]. However, extensive experiments have shown that the single-point crossover operator used in [21] is not well-suited for this problem. Consequently, the GA algorithm in this section employs a two-point crossover operator, specifically for the second half of the parent chromosome. Additionally, the scheduling result obtained from the NSMD-H algorithm is transformed into a chromosome to form part of the initial population for the GA algorithm. An elite retention strategy is also implemented to preserve the individual with the highest fitness after each iteration.

In the GA, four key parameters need to be determined: the iteration number, the population size, the crossover probability, and the mutation probability. Therefore, the Taguchi method of design of experiment (DOE) is used, and the DOE is conducted with the following settings: $n=100$, $m=6$, and $k=10$. For each parameter, three levels are tested. Specifically, for iteration number, [100, 200, 300] for population size, [0.7, 0.8, 0.9] for crossover probability, and [0.1, 0.2, 0.3] for mutation probability are selected. For each combination, the test is repeated 10 times, and the mean value is calculated. The best-combined parameter configuration is as follows: iteration number = 200, population size = 100, crossover probability = 0.7, and mutation probability = 0.3.

A total of 51 sets of experiments are conducted, varying the number of machines, job sizes, and the values of the fixed rental cost a and the unit variable cost b of shared machines. The specific results for small-scale and large-scale cases are presented in

Table 2. Computational results for small-scale problems.

n	m	k	CPLEX			NSMD-H				GA				LPT
			${\mathit{Z}}^{\mathbf{*}}$	$\mathit{CPU}$	${\mathit{h}}^{\mathbf{*}}$	$\mathit{Z}$	$\mathit{CPU}$	$\mathit{gap}$	$\mathit{h}$	$\mathit{Z}$	$\mathit{CPU}$	$\mathit{gap}$	$\mathit{h}$	$\mathit{Z}$	$\mathit{gap}$
20	2	4	109.39	0.83	3	111.34	0.18	1.78	4	109.94	2.97	0.50	4	133.91	22.41
20	2	8	62.52	1.03	6	63.94	0.17	2.27	6	63.35	2.83	1.33	6	105.91	69.39
20	2	10	92.05	1.54	2	93.50	0.12	1.57	2	92.81	2.85	0.83	2	104.58	13.61
20	4	4	44.60	1.86	1	45.28	0.14	1.52	3	45.26	2.97	1.48	3	46.34	3.89
20	4	8	55.89	6.98	0	56.66	0.03	1.38	0	56.41	2.97	0.93	0	56.66	1.38
20	4	10	50.89	1.27	4	51.70	0.32	1.59	4	51.04	3.12	0.30	4	62.80	23.40
50	2	4	144.61	1.19	4	148.22	0.11	2.50	4	147.81	3.08	2.22	4	267.75	85.16
50	2	8	166.37	2.16	5	178.26	0.17	7.14	6	175.57	3.36	5.53	6	296.18	78.02
50	2	10	135.39	1.57	9	140.42	0.35	3.72	8	139.92	3.29	3.34	8	264.36	95.25
50	4	4	106.24	1.97	3	113.33	0.12	6.67	3	111.01	3.56	4.49	3	125.37	18.00
50	4	8	83.80	4.27	8	86.06	0.21	2.69	8	85.74	2.88	2.31	8	124.44	48.49
50	4	10	89.83	50.46	6	96.57	0.27	7.50	6	93.58	2.94	4.18	6	133.80	48.94
100	4	4	275.83	1.74	0	275.94	0.10	0.04	0	275.94	4.9	0.04	0	275.94	0.04
100	4	8	182.79	3.61	7	185.18	0.17	1.31	7	185.15	3.20	1.29	7	274.62	50.24
100	4	10	212.26	16.56	9	215.43	0.23	1.49	9	215.27	3.50	1.42	9	290.05	36.65
100	6	4	166.83	75.97	4	168.24	0.13	0.85	4	168.23	3.48	0.84	4	270.94	62.40
100	6	8	132.82	695.10	7	138.47	0.23	4.25	6	138.28	3.31	4.11	6	173.43	30.57
100	6	10	142.97	13.32	8	144.99	0.30	1.41	8	144.58	3.52	1.12	8	164.35	14.95
Average			125.28	48.97	4.78	128.53	0.19	2.76	4.89	127.77	3.26	2.01	4.89	176.19	39.04

and

Table 3. Computational results for large-scale problems.

n	m	k	CPLEX			NSMD-H				GA				LPT
			${\mathit{Z}}^{\mathbf{*}}$	$\mathit{CPU}$	${\mathit{h}}^{\mathbf{*}}$	$\mathit{Z}$	$\mathit{CPU}$	$\mathit{gap}$	$\mathit{h}$	$\mathit{Z}$	$\mathit{CPU}$	$\mathit{gap}$	$\mathit{h}$	$\mathit{Z}$	$\mathit{gap}$
200	6	4	272.07	6.43	4	276.04	0.23	1.45	4	276.04	4.84	1.45	4	349.87	28.59
200	6	8	292.25	19.89	8	297.24	0.30	1.71	8	296.77	5.04	1.55	8	355.80	21.75
200	6	10	194.20	118.28	10	198.82	0.31	2.38	10	198.79	4.90	2.36	10	331.79	70.85
200	8	4	230.63	73.60	4	233.25	0.21	1.14	4	233.17	5.05	1.10	4	271.50	17.72
200	8	8	241.76	18.32	5	250.41	0.30	3.58	7	250.18	5.09	3.48	7	263.22	8.88
200	8	10	185.71	2481.73	10	194.88	0.33	4.94	10	194.88	5.23	4.94	10	259.48	39.72
500	8	4	576.99	56.10	4	579.68	0.62	0.47	4	579.44	8.75	0.42	4	658.87	14.20
500	8	8	663.70	67.90	5	667.66	0.77	0.60	8	667.48	8.75	0.57	8	670.36	1.00
500	8	10	500.11	2366.50	10	505.61	0.68	1.10	10	505.55	8.74	1.09	10	658.66	31.70
500	10	4	449.28	316.75	4	450.83	0.66	0.34	4	450.80	8.59	0.34	4	515.71	14.79
500	10	8	—	—	—	434.65	0.36	—	8	434.56	8.75	—	8	529.86	—
500	10	10	449.24	1500.33	10	460.50	0.98	2.51	10	460.22	9.23	2.44	10	519.11	15.55
800	10	4	736.96	186.00	4	742.75	1.58	0.79	4	742.75	12.78	0.79	4	842.93	14.38
800	10	8	—	—	—	662.09	1.54	—	8	662.08	12.46	—	8	801.92	—
800	10	10	709.01	1527.76	10	713.75	1.63	0.67	10	713.49	12.77	0.63	10	825.33	16.41
Average			423.22	672.28	6.77	444.54	0.70	1.67	7.27	444.41	8.07	1.63	7.27	523.63	22.73

‘—’ indicates that the example has not produced an exact solution within two hours.

, respectively. A sensitivity analysis is performed on a and b to assess their impact on the experimental results. This analysis examines how changes in a and b (while keeping other parameters constant) affected the outcomes, using the control variable method. The experimental results are shown in

Table 4. Computational results for different values of a and b.

n	m	k	a	b	CPLEX			NSMD-H				GA				LPT
					${\mathit{Z}}^{\mathbf{*}}$	$\mathit{CPU}$	${\mathit{h}}^{\mathbf{*}}$	$\mathit{Z}$	$\mathit{CPU}$	$\mathit{gap}$	$\mathit{h}$	$\mathit{Z}$	$\mathit{CPU}$	$\mathit{gap}$	$\mathit{h}$	$\mathit{Z}$	$\mathit{gap}$
50	4	8	0.5	0.01	77.60	3.57	8	82.61	0.19	6.46	8	81.98	3.41	5.65	8	138.75	78.80
50	4	8	0.5	0.05	91.68	3.25	8	95.26	0.21	3.90	8	94.47	3.28	3.05	8	138.75	51.34
50	4	8	0.5	0.15	124.86	2.57	7	126.24	0.21	1.11	8	125.74	3.39	0.71	8	138.75	11.12
50	4	8	2.0	0.01	89.60	2.56	8	93.66	0.19	4.53	7	92.90	3.22	3.69	7	138.75	54.85
50	4	8	2.0	0.05	103.68	4.83	8	106.31	0.23	2.54	7	105.61	3.33	1.86	7	138.75	33.83
50	4	8	2.0	0.15	134.44	2.99	4	137.29	0.19	2.12	7	136.50	3.52	1.53	7	138.75	3.21
50	4	8	5.0	0.01	109.68	11.23	6	111.76	0.18	1.90	6	110.98	3.20	1.19	6	138.75	26.50
50	4	8	5.0	0.05	121.18	6.94	4	124.41	0.18	2.67	6	123.78	3.14	2.14	6	138.75	14.50
50	4	8	5.0	0.15	138.21	1.47	0	138.75	0.18	0.39	0	138.63	3.72	0.31	0	138.75	0.39
200	6	10	0.5	0.01	223.40	20.02	10	241.38	0.30	8.05	10	241.12	5.05	7.93	10	376.68	68.61
200	6	10	0.5	0.05	78.61	33.70	10	285.62	0.27	2.52	10	285.31	5.20	2.40	10	376.68	35.20
200	6	10	0.5	0.15	375.43	13.33	1	376.68	0.22	0.33	0	376.66	5.96	0.33	0	376.68	0.33
200	6	10	2.0	0.01	238.40	17.58	10	256.38	0.25	7.54	10	256.29	4.91	7.51	10	376.68	58.00
200	6	10	2.0	0.05	293.62	15.86	10	300.62	0.29	2.38	10	300.30	4.87	2.27	10	376.68	28.29
200	6	10	2.0	0.15	375.56	7.44	0	376.68	0.12	0.30	0	376.62	6.45	0.28	0	376.68	0.30
200	6	10	5.0	0.01	268.12	99.54	9	286.38	0.24	6.81	10	286.14	4.83	6.72	10	376.68	40.49
200	6	10	5.0	0.05	321.17	18.28	9	330.62	0.27	2.94	10	330.33	5.02	2.85	10	376.68	17.28
200	6	10	5.0	0.15	375.56	8.30	0	376.68	0.05	0.30	0	376.61	6.43	0.28	0	376.68	0.30
Average					207.82	15.19	6.22	213.74	0.21	3.15	6.50	213.33	4.38	2.82	6.50	257.72	29.08

.

Denote the objective value and the number of rented machines obtained by CPLEX as $Z^{\ast }$ and $h^{\ast }$. The columns Z, $CPU$, and h record the objective value, calculation time (in seconds), and the number of rented machines of each method, respectively. For the GA, the results shown are the average values obtained from five runs. The relative error gap between the algorithm’s objective value and the optimal value is calculated as $gap=(Z-Z^{\ast })/Z^{\ast }\times 100\%$. Since the calculation time for scheduling jobs on owned machines using the LPT rule was consistently less than 0.01 s across all cases, the calculation time for LPT is not listed in the tables.

Analyzing Table 2 and Table 3, the following conclusions can be drawn:

(1)

When the number of jobs and machines is small, CPLEX can accurately solve the problem. However, as the scale of the problem increases, its computation time tends to rise significantly, ranging from 0.83s to 7200s. When the number of jobs and machines is large, CPLEX becomes unstable in terms of computational efficiency. In some cases, CPLEX is unable to provide an accurate solution and corresponding scheduling scheme within two hours. For example, this occurs when there are 10 owned machines, 8 shared machines, and 500 jobs or 800 jobs.

(2)

The NSMD-H algorithm demonstrates a short computation time, even for large-scale cases with 800 jobs, 10 owned machines, and 10 shared machines, with a running time of only 1.63 s. In terms of computational accuracy, the NSMD-H algorithm performs well. The gap between the objective value obtained using the NSMD-H algorithm and the optimal value obtained using CPLEX ranges from 0.04% to 7.5%. The average gap values for small-scale and large-scale cases are 2.76% and 1.67%, respectively. The difference between the number of rented machines using the NSMD-H algorithm and the number of rented machines based on optimal scheduling is not significant. The maximum difference observed is three machines. This indicates that the objective value is influenced not only by the number of rented machines but also by the scheduling arrangement of jobs.

(3)

The computation time of the GA algorithm gradually increases from 2.83 s to 12.78 s, indicating relatively high running efficiency. However, compared to the NSMD-H algorithm, the GA algorithm does not significantly improve solution quality. The average gap values of small-scale and large-scale cases are 2.01% and 1.63%, respectively. Additionally, the number of shared machines rented based on the GA algorithm is consistent with that of the NSMD-H algorithm. The primary reason for this is that the quality of solutions generated by the GA algorithm through random chromosome initialization differs significantly from that of the NSMD-H algorithm. Consequently, the better solutions obtained during GA iterations are mostly local adjustments to the solutions initially obtained using the NSMD-H algorithm. This results in minimal changes to the objective value. Therefore, the GA algorithm, while increasing computation time, does not significantly enhance the quality of solutions obtained by the NSMD-H algorithm.

(4)

The LPT rule, which schedules jobs only on owned machines without considering rented machines, has a very low computation time (no more than 0.01 s). However, it deviates significantly from optimal scheduling. In some cases, the maximum deviation reaches 95.25%.

The following conclusions can be drawn from analyzing Table 4:

(1)

When other parameters remain unchanged, an increase in the fixed rental cost a leads to a higher objective value and a gradual decrease in the number of shared machines rented. The same trend is observed for the unit variable rental cost b.

(2)

The conclusions drawn from analyzing Table 2 and Table 3 are consistent. CPLEX exhibits significant variability in computational efficiency, with computation times ranging from 1.47 s to 99.54 s. The values of parameters a and b have a substantial impact on CPLEX’s computational time, with no discernible pattern.

(3)

The NSMD-H and GA algorithms demonstrate high computational efficiency, unaffected by the values of a and b. The average computational times are 0.21 s and 4.38 s, respectively. Both algorithms achieve higher computational accuracy, with average deviations of 3.15% and 2.82%, respectively.

(4)

All jobs are scheduled on owned machines using the LPT rule. The objective value is independent of the values of a and b. However, the deviation from the optimal value is significant, particularly in cases where the shared machine rental cost is low and the optimal number of rented machines is high (e.g., the 1st and 10th cases in the table). As previously noted, when parameters n, a, b, and $u_{ij}$ take extreme values, the deviation becomes unbounded.

In summary, the NSMD-H and GA algorithms are effective in solving the problem, maintaining high computational accuracy and solution efficiency even as the problem size increases. While both algorithms achieved similar levels of computational accuracy, the NSMD-H algorithm demonstrated superior computational efficiency, meeting the dual requirements of solution quality and computational speed necessary for practical production environments.

The primary motivation for studying this machine-sharing scheduling problem is to provide a theoretical foundation for enterprise managers to make informed decisions regarding the rental of shared machines and the arrangement of job production schedules. Through mathematical modeling, property analysis, algorithm design, and problem-solving, the following management insights are offered to assist enterprise decision-makers:

(1)

The rental and scheduling results of machines are influenced by multiple factors. Enterprises should comprehensively consider their own production conditions (such as the number of owned machines), the characteristics of jobs to be processed (including the number of jobs and their processing times), the production goals of the enterprise, and the costs associated with shared machines (fixed rental costs, unit variable costs, shared service costs).

(2)

Enterprises can utilize the proposed model and algorithm to determine the number of shared machines to be rented and to arrange the order of jobs on their own machines and shared machines. This approach helps reduce the maximum completion time of jobs (i.e., customer waiting time) while optimizing the enterprise’s shared costs. For small-scale problems, the model can be used to obtain exact solutions. For large-scale problems, the proposed algorithm can efficiently generate near-optimal solutions to support decision-making.

8. Conclusions

This paper examined an offline scheduling problem for identical parallel machines, incorporating the practical scenario of renting shared machines in manufacturing enterprises. Manufacturers with a certain number of machines can rent additional shared machines to process jobs. However, they must incur fixed rental costs, unit variable rental costs, and shared service costs associated with both jobs and machines. The optimization objective is to minimize the sum of the makespan and the total shared cost. To address this problem, an integer linear programming model was first developed and solved by the commercial solver, CPLEX. Subsequently, the optimal scheduling without renting machines and the range of optimal rental quantities when renting machines were analyzed. Based on the problem’s properties, the NSMD-H algorithm for large-scale problems was designed and applied to solve the considered problem. Furthermore, experiments were carried out to compare the proposed NSMD-H algorithm with GA and LPT rule. Compared with the GA algorithm, the designed algorithm had a higher solving efficiency and smaller gap values. Compared with the LPT rule, the designed algorithm had a higher calculational accuracy. Sensitivity analyses further showed that the number of shared machines decreased with the both the fixed rental cost and the unit variable rental cost, while the corresponding objective value increased.

In summary, shared machine scheduling becomes more necessary in optimizing the allocation of resources, improving productivity, and promoting sustainable industrial synergies. All of this leads to greater sustainability in manufacturing. Manufacturers can strategically implement the NSMD-H algorithm according to their specific production parameters, shared resource availability, and associated cost structures. This approach can effectively reduce both job completion times and machine-shared costs. By optimizing resource utilization efficiency and minimizing idle resource waste, the algorithm facilitates long-term equilibrium in socioeconomic systems while advancing sustainable development goals.

Future research directions may include (i) designing heuristics that can solve the problem more efficiently; (ii) considering more practical conditions, such as various rental discounts and multi-resource sharing; (iii) investigating scheduling problems where jobs are processed on shared machines of different machine types (e.g., uniform parallel machines, unrelated parallel machines, etc.); and (iv) studying the problem with other objective functions, such as scheduling problems with durations (maximum delay time, delay time, number of late jobs, etc.) or multi-objective functions.