An Adaptive Search Algorithm for Multiplicity Dynamic Flexible Job Shop Scheduling with New Order Arrivals

Abstract

In today’s customer-centric economy, the demand for personalized products has compelled corporations to develop manufacturing processes that are more flexible, efficient, and cost-effective. Flexible job shops offer organizations the agility and cost-efficiency that traditional manufacturing processes lack. However, the dynamics of modern manufacturing, including machine breakdown and new order arrivals, introduce unpredictability and complexity. This study investigates the multiplicity dynamic flexible job shop scheduling problem (MDFJSP) with new order arrivals. To address this problem, we incorporate the fluid model to propose a fluid randomized adaptive search (FRAS) algorithm, comprising a construction phase and a local search phase. Firstly, in the construction phase, a fluid construction heuristic with an online fluid dynamic tracking policy generates high-quality initial solutions. Secondly, in the local search phase, we employ an improved tabu search procedure to enhance search efficiency in the solution space, incorporating symmetry considerations. The results of the numerical experiments demonstrate the superior effectiveness of the FRAS algorithm in solving the MDFJSP when compared to other algorithms. Specifically, the proposed algorithm demonstrates a superior quality of solution relative to existing algorithms, with an average improvement of 29.90%; and exhibits an acceleration in solution speed, with an average increase of 1.95%.

1. Introduction

The individualized requirements in the market are increasing, which is placing higher demands on manufacturing systems [1,2]. To remain competitive, companies are increasing the flexibility of their manufacturing systems [3,4]. However, flexibility in the manufacturing environment can lead to increased complexity, posing challenges for production managers when making decisions [5,6]. Industry 4.0 has led to the emergence and evolution of various technologies that support decision-making in manufacturing systems [7,8]. This enables continuous iteration and upgrading of both hardware and software in manufacturing systems. Benefiting from the support and maturity of these technologies, dynamic scheduling has become a trend of general interest for enterprises and researchers. Compared to traditional scheduling, dynamic scheduling is more adaptable [9,10,11]. Specifically, the dynamic flexible job shop scheduling problem (DFJSP) is considered more valuable than the traditional job shop scheduling problem (JSP) [12,13]. This is because it encapsulates most of the scheduling challenges of high-mix, low-volume production in modern discrete manufacturing systems. Moreover, it deals with uncertainties inherent in the production environment, such as fluctuating demand, machine downtime, and unpredictable lead times [14].

Among the various iterations of the standard DFJSP, the multiplicity dynamic flexible job shop scheduling problem (MDFJSP) stands out as particularly applicable to manufacturing systems characterized by a significant volume of identical or similar jobs that can be grouped in the production process. Industries such as semiconductor manufacturing and motorcycle component production serve as prime examples of such systems [15,16,17]. Addressing the MDFJSP can assist production managers in increasing throughput, decreasing lead times, minimizing machine downtime, and maximizing resource utilization. Enterprises can enhance their market competitiveness by effectively managing the scheduling of multiple job instances, which can increase productivity and enable prompt response to customer requirements. The literature contains extensive research on the DFJSP, but few studies have addressed the MDFJSP [18,19,20]. Ding et al. (2022) [21] proposed a fluid master-apprentice evolutionary method to address the multiplicity flexible job shop scheduling problem, and Ding et al. (2024) [22] presented a multi-policy deep reinforcement learning method for multi-objective multiplicity flexible job shop scheduling problem. But these two papers are only applicable to static scheduling problems, and are not suitable for addressing dynamic scheduling challenges.

To fill this research gap, we investigate the MDFJSP with new order arrivals. The inclusion of numerous new jobs in new orders is more indicative of actual production scenarios [23]. However, new order arrivals frequently generate numerous new positions, leading to an extensive solution space that challenges achieving high-quality solutions. The current methods, such as meta-heuristics and dispatching rules for the DFJSP, have been observed to have shortcomings in terms of time efficiency and long-term solution quality [24,25,26]. The current literature indicates that fluid models can rapidly identify near-optimal solutions in the context of multiplicity job shop scheduling. Therefore, we propose a new algorithm called the fluid randomized adaptive search (FRAS) algorithm for the MDFJSP, by incorporating a fluid model. The FRAS algorithm integrates a fluid model-based approach named the fluid construction heuristic (FCH) with the GRAS framework. The main function of the FCH in this algorithm is to optimize the initial solution. By incorporating the FCH, which captures the system’s continuous dynamics, the FRAS algorithm offers a more robust and adaptive solution approach for the MDFJSP. The results of numerical experiments prove this novel algorithm can efficiently generate high-quality scheduling schemes for the MDFJSP with varying problem scales in a reasonable computation time. This study makes the following key contributions.

(1)

We propose a fluid randomized adaptive search algorithm for addressing the MDFJSP, effectively bridging the existing research gap in this area.

(2)

A dynamic fluid model is developed for the first time to address the MDFJSP with new order arrivals.

(3)

The proposed FRAS algorithm surpasses existing algorithms due to two design features. Firstly, we developed a fluid construction heuristic that incorporates an online fluid dynamic tracking policy to optimize the initial solution. Secondly, we propose a tabu search procedure based on the public critical operation to enhance the efficiency of the solution space search.

The following sections of this article are structured as follows: Section 2 reviews the related papers. Section 3 describes the MDFJSP and introduces a mathematical model along with an illustrative example. Section 3 delineates the FRAS algorithm. Section 4 provides the results and analyses. Finally, we summarize this article in Section 5, and outline future directions and recommendations.

2. Literature Review

This section provides a review of the relevant work, which consists of two main parts. Due to the scarcity of research on the MDFJSP, the first part focuses on methodologies used to solve the FJSP. The second part reviews the current state of research on fluid modeling in scheduling.

2.1. Methodologies for the FJSP

To solve FJSPs, researchers have proposed various optimization strategies, including dispatching rule-based, and meta-heuristic. Even though exact solution methods can produce the optimal solution to a problem, their complexity makes it difficult to obtain viable solutions in a reasonable timeframe [27]. Dispatching rules are widely used to address FJSPs in practical production systems [28]. However, choosing a specific dispatching rule for a particular problem is complex. Therefore, numerous methods to extract and select dispatching rules for FJSPs have been presented by researchers [29]. Furthermore, many researchers have extracted dispatching rules using the genetic programming-based method to solve the DFJSP with particular constraints [30,31]. Although dispatching rules are easy to implement, they often exhibit myopic behavior, which means they may not guarantee to reach a local optimum in the long run [32].

In addition to dispatching rule-based methods, many meta-heuristics have been proposed to generate feasible and promising schedule schemes [33,34]. Meta-heuristics can achieve new near-optimal solutions by utilizing global information at each rescheduling point [35,36]. However, these methods often encounter challenges in terms of time efficiency, primarily attributed to their intricate evolutionary processes and search methods in an expansive search space [37,38,39]. This limitation hinders their application in manufacturing systems, where new disturbances may happen unexpectedly, even before a new rescheduling scheme has been established. For more information about meta-heuristic-based methods, refer to the overview literature by Xie et al. (2019) [40].

2.2. Fluid Model

The fluid model was first proposed by Chen (1993) [41] to address the dynamic scheduling challenges associated with multiple classes of fluid traffic. The fluid model method offers a robust mathematical framework for analyzing and solving job shop scheduling problems with multiplicity characteristics [42,43,44,45]. By representing the discrete scheduling problem as a continuous fluid model, researchers can gain valuable insights into system behavior by analyzing the performance measures and developing optimization techniques. Fluid models are deterministic, continuous approximations of stochastic. Several researchers have effectively employed fluid models in both static and dynamic JSP [45,46]. However, most of the existing literature works have primarily focused on addressing the JSP. When it comes to the FJSP, applying the fluid model approach becomes more challenging due to the additional complexities involved in decision-making and representation.

Because of the limited literature on the fluid model in FJSPs, we just can conduct a comprehensive analysis of the existing literature on fluid modeling in JSPs.

Table 1. Literature review of fluid models in JSPs.

Paper	Type of JSPs			Problem Scale		Objective
	Number of Multiplicity	Deterministic	Stochastic	Small	Large	Makespan	Holding Cost
Bertsimas and Gamarnik (1999) [47]	Up to 2500	✔		✔		✔
Boudoukh et al. (2001) [50]	Up to 1000		✔		✔	✔
Dai and Weiss (2002) [42]	Up to 100,000	✔		✔		✔
Bertsimas and Sethuraman (2002) [48]	Up to 1000	✔				✔
Bertsimas et al. (2003) [43]	Up to 10,000	✔		✔			✔
Nazarathy and Weiss (2010) [49]	Up to $2^{14}$	✔			✔	✔
Masin and Raviv (2014) [44]	Up to 10	✔		✔		✔
Gu et al. (2018) [45]	Up to 100		✔	✔		✔

analyzes the application of fluid models in JSP from three key perspectives: problem type, problem scale, and objective function. Our findings indicate that fluid models are primarily used in JSP research to obtain approximate solutions in a relatively short time frame. Consequently, they are often combined with other heuristic algorithms to enhance the efficiency of the algorithmic solution. The existing research primarily concerns deterministic problems [42,44,47,48,49], with only very few papers addressing stochastic problems [45,50]. Fluid modeling can rapidly resolve large-scale problems in certain specific contexts. However, its application is contingent on certain parameters, which means that it is applicable to a limited number of practical scenarios and some scenarios are not applicable.Furthermore, a review of the existing literature reveals that most studies on fluid models are conducted in the context of JSPs with high multiplicity [43,44]. The application of the fluid model in these papers remains constrained, and the scenarios in which the fluid model is applicable are not sufficiently discussed. This represents an avenue for further exploration.

Despite the extensive research on DFJSPs, there is a lack of studies specifically addressing the multiplicity of characteristics of DFJSPs. This research gap highlights the need to develop an optimization model and propose an efficient solution approach for addressing the complexities introduced by multiplicity in DFJSPs. By considering the unique challenges posed by multiplicity, future research efforts can contribute to the advancement of scheduling methodologies and provide valuable insights for optimizing the performance of DFJSPs in practical manufacturing environments.

3. Problem Description

This article studies a special variant of the DFJSP called the multiplicity dynamic flexible job shop scheduling problem (MDFJSP). In MDFJSPs, multiple jobs are permitted for any job type. It consists of M machines, S orders with random arrival times, and R job types. Each job type r comprises $J_r$ several operations. All jobs are classified into a total of R unique types. The orders s arrive randomly, containing $N_{sr}$ jobs for job type r. The job quantity belonging to a specific job type r in order s is called its multiplicity ($N_{sr}\ge 1$). In the actual manufacturing environment, the arrival of new orders containing multiple jobs for each job type follows the Poisson distribution [51], which means the time interval between new orders’ arrival obeys an exponential distribution [52]. Rescheduling occurs when a new order s arrives at $A_s$, serving as the rescheduling point. All operations are divided into four sets: completed, being processed, unprocessed, and new arrived operations. To handle complexity, some assumptions were made:

(1)

Machines are assumed to be ready for operation at the beginning of the time horizon.

(2)

The same type of jobs can be processed on a specified series of machines. However, it is not permitted for any given machine to perform more than one operation simultaneously.

(3)

Operations must be completed without interruption.

(4)

Operations must be conducted in a specified order, with no operation starting before the previous one has finished.

(5)

Setup times between operations are not considered.

The mathematical model uses the following notations:

Notation	Description
Indexes:
s	Orders, $s=1,2,\dots ,S$.
m	Machines, $m=1,2,\dots ,M$.
$r,r^{\prime }$	Job types, $r,r^{\prime }=1,2,\dots ,R$.
$n,n^{\prime }$	Jobs belonging to job types r and $r^{\prime }$, $n=1,2,\dots ,N_r$, $n^{\prime }=1,2,\dots ,N_{r^{\prime }}^{\prime }$.
$j,j^{\prime }$	Operations of job types r and $r^{\prime }$, $j=1,2,\dots ,J_r$, $j^{\prime }=1,2,\dots ,J_{r^{\prime }}^{\prime }$.
Parameters:
R	The number of job types.
M	The number of machines.
$J_r$	The operation quantity of job type r.
$J_{rn}$	Job $nth$ of type r.
$o_{rnj}$	Operation $jth$ of the job $nth$ pertaining to job type r.
$o_{rj}$	Operation $jth$ of type r.
$t_{rjm}$	The processing time for operation $o_{rj}$ on machine m.

Notation	Description
Sets:
$M_m$	The complete set of machines, $M_m=\{1,2,\dots ,M\}$.
$M_{rj}$	The specific set of machines that are eligible to perform the operation $o_{rj}$.
$R_r$	The set of all job types, $R_r=\{1,2,\dots ,R\}$.
$I_r$	The set of all jobs belonging to type r, $I_r=\{1,2,\dots ,N_r\}$.
$O_r$	The set of all operations belonging to job type r, $O_r=\{1,2,\dots ,J_r\}$.
$O_{RJ}$	The complete set of operations belonging to all job types, $O_{RJ}=\{o_{rj}\mid r\in R_r,j\in O_r\}$.
$O_m^{RJ}$	The set of operations that machine m can perform, $O_m^{RJ}=\{o_{rj}\mid r\in R_r,j\in O_r,m\in M_{rj}\}$.
Variables:
S	The quantity of new orders.
$A_s$	The arrival time of order s; order $s=1$ is the first order, and $A_1=0$.
$D_s$	The due date of order s.
$d_{rn}$	The due date of job $J_{rn}$; $d_{rn}=D_s$ if $z_{rns}=1$.
$N_{sr}$	The total job quantity of job type r in order s.
$N_s$	The total job quantity in order s, $N_s={\sum }_{r=1}^R{N}_{sr}$.
$N_r$	The total job quantity of job type r in all orders, $N_r={\sum }_{s=1}^S{N}_{sr}$.
N	The number of jobs in all orders, $N={\sum }_{s=1}^S{N}_s$.
$c{t}_{rnj}$	The completion time of operation $o_{rnj}$.
Decision variables:
$x_{rnjm}$	$x_{rnjm}=\left\{\begin{array}{cc}1,\hfill & \mathrm{if}{o}_{rnj}\mathrm{is}\mathrm{assigned}\mathrm{on}\mathrm{machine}m.\hfill \\ 0,\hfill & \mathrm{otherwise}.\hfill \end{array}\right.$
$y_{rnj{r}^{\prime }{n}^{\prime }{j}^{\prime }}$	$y_{rnj{r}^{\prime }{n}^{\prime }{j}^{\prime }}=\left\{\begin{array}{cc}1,\hfill & \mathrm{if}{o}_{rnj}\mathrm{is}\mathrm{a}\mathrm{predecessor}\mathrm{of}{o}_{r^{\prime }{n}^{\prime }{j}^{\prime }}.\hfill \\ -1,\hfill & \mathrm{if}{o}_{rnj}\mathrm{is}\mathrm{a}\mathrm{successor}\mathrm{of}{o}_{r^{\prime }{n}^{\prime }{j}^{\prime }}.\hfill \end{array}\right.$
$z_{rns}$	$z_{rns}=\left\{\begin{array}{cc}1,\hfill & \mathrm{if}\mathrm{job}{J}_{rn}\mathrm{belongs}\mathrm{to}\mathrm{order}s.\hfill \\ 0,\hfill & \mathrm{otherwise}.\hfill \end{array}\right.$

We describe the mathematical model as follows:

$$min{C}_{\max }=\min \left(\max \right\{c{t}_{rnj}\mid r\in R_r,n\in I_r,j\in O_r\left\}\right)$$

(1)

Subject to:

$$\begin{array}{cc}& c{t}_{rn0}=0,c{t}_{rnj}>0,\forall r,n,j\hfill \end{array}$$

(2)

$$\sum _{m\in M_{rj}}{x}_{rnjm}=1,\forall r,n,j$$

(3)

$$\sum _{s=1}^S{z}_{rns}=1,\forall r,n$$

(4)

$$(c{t}_{rnj}-t_{rjm}-c{t}_{r,n,j-1})x_{rnjm}\ge 0,\forall r,n,j,m$$

(5)

$$(c{t}_{rnj}-t_{rjm}-A_s)z_{rns}{x}_{rnjm}\ge 0,\forall r,n,j,m,s$$

(6)

$$\begin{array}{c}\hfill (c{t}_{r^{\prime }{n}^{\prime }{j}^{\prime }}-t_{r^{\prime }{n}^{\prime }m}-c{t}_{rnj})x_{rnjm}{x}_{r^{\prime }{n}^{\prime }{j}^{\prime }m}(y_{rnj{r}^{\prime }{n}^{\prime }{j}^{\prime }}+1)+\\ \hfill (c{t}_{rnj}-t_{rnm}-c{t}_{r^{\prime }{n}^{\prime }{j}^{\prime }})x_{rnjm}{x}_{r^{\prime }{n}^{\prime }{j}^{\prime }m}(1-y_{rnj{r}^{\prime }{n}^{\prime }{j}^{\prime }})\ge 0,\forall r,r^{\prime },n,n^{\prime },j,j^{\prime },m\end{array}$$

(7)

Equation (1) represents the objective of minimizing the maximum completion time in the mathematical model, where $C_{max}$ means the maximum completion time, i.e., the makespan. Equation (2) implies that the completion time of each operation is non-negative. Equation (3) indicates that each operation can be assigned to only one available machine. Equation (4) indicates that each job belongs to only one order. Equation (5) states the precedence constraint of operations for each job, while Equation (6) ensures jobs are processed only upon arrival. Equation (7) ensures that the scheduling schemes are feasible for the capacity of machines.

To facilitate comprehension for the reader,

Table 2. An example for the MDFJSP with 2 new orders and 3 machines.

${\mathit{N}}_{1\mathit{r}}$	${\mathit{N}}_{2\mathit{r}}$	r	j	$\mathit{M}1$	$\mathit{M}2$	$\mathit{M}3$
			1	29	11	28
3	2	1	2	14	15	24
			3	18	25	25
			1	12	16	25
3	2	2	2	22	15	14
			3	26	26	20

provides an illustrative example of MDFJSP with two new orders and three machines. Initially (in order 1), each job type is allocated a specific number of available positions. The dynamic scheduling system then implements the schedule until the next order arrives. The process of dynamic scheduling is repeated until all jobs have been completed.

Figure 1 presents the details of the example of the MDFJSP. Figure 1a illustrates that two task types, r = 1, 2, are processed on three machines, m = 1, 2, 3. In addition, six jobs, 11, 12, 13, 21, 22, and 23, in order one must be planned, and order two includes four new jobs, 14, 15, 24, and 25, which come at time 50. First, we establish the scheduling scheme based on the first order, as depicted in Figure 1a. At time 50, the ongoing activities 222, 122, and 113 are not halted, but rather the rescheduling procedure is initiated when order number two arrives. All non-processed operations are rescheduled following the proposed DA3C once a rescheduling process commences. Consequently, 19 operations must be scheduled for time 50 (Reschedule point). Figure 1b depicts the new schedule scheme acquired following the arrival of the second order.

4. Fluid Randomized Adaptive Search Algorithm

In the construction phase of the fluid randomized adaptive search (FRAS) algorithm, the fluid construction heuristic (FCH) method is used to construct a solution step by step, considering symmetry. For each decision time, one operation and one corresponding available machine are selected according to the online fluid dynamic tracking policy. D solutions are constructed with the FCH. Then, the proposed tabu search procedure improves the best solution of the D solutions. Figure 2 presents the flow diagram of dynamic scheduling systems and the basic flow of the FRAS algorithm.

4.1. Construction Phase

4.1.1. Dynamic Fluid Model and Control Problem

The proposed dynamic fluid model has the advantage of being a linear programming model that can be easily solved using CPLEX. We define the solution of the fluid model as a fluid solution. The solution of the fluid model is called the fluid solution. In the dynamic fluid model, the operation $o_{rj}$ is represented as fluids $k_{rj}$. Then, the set of all operations of all job types can be represented as fluid set $F=\{k_{rj}\mid r\in R_r,j\in O_r\}$. The dynamic fluid model provides a fluid solution, which is a time proportion $\{u_{m{k}_{rj}}\in \mathbb{R}\mid 0\le u_{m{k}_{rj}}\le 1,m\in M_m,k_{rj}\in F\}$ that each machine devotes to each fluid. Here, we illustrate with a simple example. If machine m is equipped to perform the set of operations $\{o_{11},o_{12},o_{21}\}$. After solving the fluid model, the deduced optimal time fractions that machine m spends on each operation are $\{u_{m{k}_{11}}=0.3,u_{m{k}_{12}}=0.4,u_{m{k}_{21}}=0.2\}$. The interpretation of these fractions is such that for each unit of time, $30\%$, $40\%$, and $20\%$ of that duration is allocated by machine m for performing operations $o_{11}$, $o_{12}$, and $o_{21}$, respectively. The details of the dynamic fluid model are as follows:

Notations	Description
Indexes:
$k_{rj}$	The fluid which represents the operation $o_{rj}$ in the dynamic fluid model.
Parameters:
$e_{m{k}_{rj}}$	The processing rate of fluid $k_{rj}$ on machine m.
$e_{k_{rj}}$	The total processing rate of fluid $k_{rj}$, $e_{k_{rj}}={\sum }_{m=1}^M{e}_{m{k}_{rj}}{u}_{m{k}_{rj}}$.
Sets:
F	The set of fluids, $F=\{k_{rj}\mid r\in R_r,j\in O_r\}$.
$F_m$	The subset of fluids that machine m can process, $F_m=\{k_{rj}\mid r\in R_r,j\in O_r,o_{rj}\in O_m^{RJ}\}$.
$M_{k_{rj}}$	The subset of machines that can process fluid $k_{rj}$, $M_{k_{rj}}=\{m\mid m\in M,m\in M_{rj}\}$.
Variables:
$u_{m{k}_{rj}}$	The proportion of processing time that machine m devotes to fluid $k_{rj}$.
$c_{k_{rj}}$	The completion time of fluid $k_{rj}$.
$q_{k_{rj}}\left(t\right)$	The amount of fluid $k_{rj}$ at time t.
$Q_{rj}\left(t\right)$	The job quantity in operation stage $o_{rj}$ at time t.
$q_{k_{rj}}^{+}\left(t\right)$	The total amount of fluid $k_{rj}$ not processed at time t.
$Q_{rj}^{+}\left(t\right)$	The total job quantity in operation $o_{rj}$ not processed at time t.
$q_{m{k}_{rj}}^{+}\left(t\right)$	The total amount of fluid $k_{rj}$ not processed by machine m at time t.
$Q_{mrj}^{+}\left(t\right)$	The total job quantity in operation $o_{rj}$ not processed by machine m at time t.

After the arrival of order s and before the arrival of order $s+1$, the dynamic fluid model satisfies the following Equations (8)–(16). Obviously, the time $t\in [A_s,A_{s+1})$. Equation (8) means the number of fluid $k_{rj}$ at time t. The number of fluid $k_{rj}$ that has not yet been processed can be calculated as Equation (9). The number of the fluid $k_{rj}$ that has not yet been processed by machine m can be calculated as Equations (10) and (11). The computation time of each fluid k is shown in Equation (12). Equation (13) indicates that the utilization rate must be less than 100% for each machine. Equation (14) demonstrates that if $q_{k_{rj}}\left(A_s\right)=0$, then the total processing rate of fluid $k_{rj}$ is no more than its arrival rate. This makes $q_{k_{rj}}\left(t\right)\ge 0$, which ensures that the fluid solution is feasible. Equation (15) denotes the range of decision variables.

$$q_{k_{rj}}\left(t\right)=\left\{\begin{array}{cc}{q}_{k_{rj}}\left(A_s\right)+(t-A_s)(e_{k_{r,j-1}}-e_{k_{rj}}),\hfill & \forall k_{rj}\in F,j\ge 2\hfill \\ q_{k_{rj}}\left(A_s\right)-(t-A_s)e_{k_{rj}},\hfill & \forall k_{rj}\in F,j=1\hfill \end{array}\right.$$

(8)

$$q_{k_{rj}}^{+}\left(t\right)=q_{k_{rj}}^{+}\left(A_s\right)-(t-A_s)e_{k_{rj}},\forall k_{rj}\in F$$

(9)

$$q_{m{k}_{rj}}^{+}\left(A_s\right)=q_{k_{rj}}^{+}\left(A_s\right)\frac{e_{m{k}_{rj}}{u}_{m{k}_{rj}}}{e_{k_{rj}}},\forall k_{rj}\in F,m\in M_{k_{rj}}$$

(10)

$$q_{m{k}_{rj}}^{+}\left(t\right)=q_{m{k}_{rj}}^{+}\left(A_s\right)-(t-A_s)e_{m{k}_{rj}}{u}_{m{k}_{rj}},\forall k_{rj}\in F,m\in M_{k_{rj}}$$

(11)

$$c_{k_{rj}}=\frac{q_{k_{rj}}^{+}\left(A_s\right)}{e_{k_{rj}}},\forall k_{rj}\in F$$

(12)

$$\sum _{k_{rj}\in F}{u}_{m{k}_{rj}}\le 1,\forall m\in M_m$$

(13)

$$e_{k_{rj}}\le e_{k_{r,j-1}},\forall k_{rj}\in F,j\ge 2,q_{k_{rj}}\left(A_s\right)=0$$

(14)

$$u_{m{k}_{rj}}\in [0,1],\forall k_{rj}\in F,m\in M_{k_{rj}}$$

(15)

The dynamic fluid model aims to minimize the maximum completion time at each rescheduled point $A_s$, which is shown in Equation (16).

$$C_f^s=min\left\{max\left\{c_{k_{rj}}|k_{rj}\in F\right\}\right\}$$

(16)

Note that we must solve the dynamic fluid model based on both the unprocessed operations and the new operations when order s arrives at the time $A_s$. Therefore, the fluid solution changes dynamically with the arrival of new orders.

4.1.2. Online Fluid Dynamic Tracking Policy

The dynamic fluid model above offers a fluid solution for each rearrangement point $A_s$. The fluid solution only specifies the fraction of time devoted to a particular operation $o_{rj}$ on machine m, but does not specify the job sequence for each machine. However, the dynamic flexible job shop scheduling is a process in a discrete manufacturing environment, and job sequencing must be considered along with machine assignment. Consequently, to construct high-quality discrete solutions, the fluid solution needs to transform into a policy that can guide us to finish selecting an operation and assigning it to an available machine. To generate the policy, two metrics are defined to measure the similarity between the constructed discrete and fluid solutions.

• Fluid-Gap: At time t, the gap between the total job quantity that operation $o_{rj}$ has not been processed and the amount of fluid $k_{rj}$, which has not been processed, is calculated as follows:

$${\mathrm{gap}}_{rj}\left(t\right)=\frac{Q_{rj}^{+}\left(t\right)-q_{k_{rj}}^{+}\left(t\right)}{q_{k_{rj}}^{+}\left(A_s\right)},\forall k_{rj}\in F$$

(17)

• Fluid–Machine-Gap: At time t, the gap between the total job quantity with operation $o_{rj}$ not processed by machine m and the number of fluid $k_{rj}$ not processed by machine m is calculated as follows:

$${\mathrm{gap}}_{mrj}\left(t\right)=\frac{Q_{mrj}^{+}\left(t\right)-q_{m{k}_{rj}}^{+}\left(t\right)}{q_{m{k}_{rj}}^{+}\left(A_s\right)},\forall k_{rj}\in F,m\in M_{k_{rj}}$$

(18)

In Equation (17), $Q_{rj}^{+}\left(t\right)$ is related to the construction state of the discrete solution at time t. The ${\mathrm{gap}}_{rj}\left(t\right)$ indicates a gap between the constructed discrete solution and the fluid solution. In Equation (18), $Q_{mrj}^{+}\left(t\right)=q_{m{k}_{rj}}^{+}\left(A_s\right)-Q_{mrj}^{-}\left(t\right)$, the parameter $Q_{mrj}^{-}\left(t\right)$ is the number of the operation $o_{rj}$ that has been processed by machine m at time t. Therefore, $Q_{mrj}^{-}\left(t\right)$ is related to the construction state of the discrete solution at time t. The ${\mathrm{gap}}_{mrj}\left(t\right)$ indicates a gap between the processing state of the operation $o_{rj}$ on machine m in the constructed discrete solution and that in the fluid solution. Based on the two defined metrics, an online fluid dynamic tracking policy is designed, consisting of two steps: operation selection and machine selection.

• Operation selection step: At decision point t, one operation $o_{r^{\prime }{n}^{\prime }{j}^{\prime }}$ is selected according to Equations (19) and (20).

$$o_{r^{\prime }{j}^{\prime }}\leftarrow {\{o_{rj}\mid o_{rj}\in O_{RJ}\left(t\right),{\mathrm{gap}}_{rj}\left(t\right)\ge {\mathrm{gap}}^{*}\left(t\right)\}}_{\mathrm{random}}$$

(19)

$$o_{r^{\prime }{n}^{\prime }{j}^{\prime }}\leftarrow {\{o_{r^{\prime }{n}^{\prime }{j}^{\prime }}\mid n\in I_{r^{\prime }{j}^{\prime }}\left(t\right)\}}_{min\_{\mathrm{ct}}_{r^{\prime },n^{\prime },j^{\prime }-1}}$$

(20)

In Equation (19), $O_{RJ}\left(t\right)$ is the operation set that is available processed by idle machines. $O_{RJ}\left(t\right)=\{o_{rj}\mid m\in M_{\mathrm{idle}}\left(t\right),o_{rj}\in O_m^{RJ},Q_{rj}\left(t\right)>0\}$, $M_{\mathrm{idle}}\left(t\right)$ is the set of idle machines, $Q_{rj}\left(t\right)>0$ means there are jobs in the operation stage $o_{rj}$, so operation $o_{rj}$ is selectable. In this step, the operation $o_{r^{\prime }{j}^{\prime }}$ is selected randomly based on Equation (19), in which a threshold value ${\mathrm{gap}}^{*}\left(t\right)={\mathrm{gap}}^{-}\left(t\right)+b({\mathrm{gap}}^{+}\left(t\right)-{\mathrm{gap}}^{-}\left(t\right))$. The parameters ${\mathrm{gap}}^{-}$ and ${\mathrm{gap}}^{+}$ are the minimum and maximum ${\mathrm{gap}}_{rj}\left(t\right)$ value of all operations belongs to $O_{RJ}\left(t\right)$, b is applied to balance the stochasticity and covetousness. However, due to the multiplicity of our research problem, there may be multiple jobs in the operation stage $o_{r^{\prime }{j}^{\prime }}$. In Equation (20), $I_{r^{\prime }{j}^{\prime }}\left(t\right)$ is the set of jobs in the operation stage $o_{r^{\prime }{j}^{\prime }}$. Therefore, the operation $o_{r^{\prime }{n}^{\prime }{j}^{\prime }}$, which has the minimum ${\mathrm{ct}}_{r^{\prime },n,j^{\prime }-1}$ value, is selected according to Equation (20). The job $n^{\prime }$ which is the first arrival operation stage $o_{r^{\prime }{j}^{\prime }}$ is selected.

• Machine selection step: The machine $m^{\prime }$ is selected to process the selected operation $o_{r^{\prime }{n}^{\prime }{j}^{\prime }}$ at the operation selection step.

$$m^{\prime }\leftarrow \left\{{m\mid m\in M_{r^{\prime }{j}^{\prime }}\cap M_{\mathrm{idle}}\left(t\right)}_{max\_{\mathrm{gap}}_{m{r}^{\prime }{j}^{\prime }}\left(t\right)}\right\}$$

(21)

Based on Equation (21), where $m^{\prime }$ with the maximum value of ${\mathrm{gap}}_{m{r}^{\prime }{j}^{\prime }}\left(t\right)$ is chosen to perform operation $o_{r^{\prime }{n}^{\prime }{j}^{\prime }}$.

4.1.3. The Fluid Construction Heuristic Method

Once new order s arrives at the time $A_s$, the dynamic fluid model is resolved to obtain the fluid solution. Then, the FCH is used to construct D high-quality initial solutions at the rescheduling point $A_s$. Pseudo-code Algorithm 1 illustrates the detailed steps of the FCH. $O_s^{RNJ}$ is the set of operations that contain the unprocessed operations and the new operations at the rescheduling point $A_s$. $O_{RNJ}\left(t\right)$ is the set of unprocessed operations for all jobs at time t. $D_{FCH}=\{d_1,\dots ,d_D\}$ is the set of initial solutions constructed by the FCH, in which $d_i$ is the ith solution.

4.2. Local Search

Tabu search has been used effectively in diverse scheduling problems since it was proposed by Glover (1990) [53]. In the local search phase of the FRAS algorithm, an improved tabu search (ITS) procedure is presented to improve the feasible solutions obtained with the FCH. In the ITS, neighborhood solutions are formed by relocating a public critical operation to a different machine and repositioning a public critical operation on the same machine. In the disjunctive graph representation of the current solution, the longest path is the critical path and each operation on the critical path is a critical operation. However, the current solution may have more than one critical path. Then, the operation is a public critical operation if it belongs to all the critical paths [54]. For example, in Figure 3, three public critical operations belong to two critical paths 111, 112, 211.

Algorithm 1 The fluid construction heuristic method.

Require:  $D_{FCH}$ Ensure:  $D_{FCH}$   1: Initialization:   2: Solve the dynamic fluid model and obtain the fluid model.   3: The set of initial solutions: $D_{FCH}\leftarrow \varnothing$.   4: for $i=1$ to D do   5:    The current time: $t\leftarrow A_s$.   6:    Next idle time of all machines: $\left\{{\mathrm{time}}_{\mathrm{idle}}^m\right|m\in M_m\}$.   7:    $O_{RNJ}\left(t\right)\leftarrow O_s^{RNJ}$. // Construct a solution $d_i$ with the online fluid dynamic tracking policy.   8:    while $O_{RNJ}\left(t\right)\ne \varnothing$// If there are operations that have not been assigned. do   9:      if $O_{RJ}\left(t\right)=\varnothing$// If no operations can be selected at the current decision point t.      then 10:         // Move the time to the next decision point. 11:         $t\leftarrow min\left\{{\mathrm{time}}_{\mathrm{idle}}^m\right|m\in M_m\}$. 12:      else 13:         //Select the operation $o_{r^{\prime }{n}^{\prime }{j}^{\prime }}$ according to the operation selection step. 14:         $o_{r^{\prime }{j}^{\prime }}\leftarrow {\left\{o_{rj}\right|o_{rj}\in O_{RJ}\left(t\right),{\mathrm{gap}}_{rj}\left(t\right)\ge {\mathrm{gap}}^{*}\left(t\right)\}}_{\mathrm{random}}$. 15:         $o_{r^{\prime }{n}^{\prime }{j}^{\prime }}\leftarrow {\left\{o_{\left(r^{\prime }n{j}^{\prime }\right)}\right|n\in I_{\left(r^{\prime }{j}^{\prime }\right)}\left(t\right)\}}_{min\_{\mathrm{ct}}_{r^{\prime },n,j^{\prime }-1}}$. 16:         //Select machine $m^{\prime }$ to perform operation $o_{r^{\prime }{n}^{\prime }{j}^{\prime }}$. 17:         $m^{\prime }\leftarrow {\left\{m\right|m\in M_{r^{\prime }{j}^{\prime }}\cap M_{\mathrm{idle}}\left(t\right)\}}_{max{\mathrm{gap}}_{m{r}^{\prime }{j}^{\prime }}\left(t\right)}$. 18:         // Update the unprocessed operations set $O_{RNJ}\left(t\right)$. 19:         Remove the operation $o_{r^{\prime }{n}^{\prime }{j}^{\prime }}$ from $O_{RNJ}\left(t\right)$. 20:         // Update the next idle time of machine $m^{\prime }$. 21:         ${\mathrm{time}}_{\mathrm{idle}}^{m^{\prime }}\leftarrow {\mathrm{time}}_{\mathrm{idle}}^{m^{\prime }}+t_{r^{\prime }{j}^{\prime }{m}^{\prime }}$. 22:      end if 23:    end while 24:    Add the constructed solution $d_i$ to $D_{FCH}$. 25: end for 26: return $D_{FCH}=\{d_1,\dots ,d_D\}$.

In the ITS, a public critical operation is reallocated on the same machine based on the neighborhood structure $N^{\pi }$ [55] and move a critical operation to another machine and insert it into a feasible position according to the neighborhood structure $N_1^{(\alpha -\rho )}$ [56]. Moreover, the makespan estimate approach [56] is adopted to estimate the neighborhood quality for accelerating the local search. The procedure of the ITS is outlined in Algorithm 2.

Algorithm 2 The improved tabu search algorithm.

Require:  The best solution $d^{*}$ in the set $D_{FCH}$. Ensure:  The best solution $d_{best}$.   1: Initialize the maximum iteration number ${iter}_{stop}$.   2: Initialize the count of iterations without improvement in the optimal solution: ${iter}_{number}\leftarrow 0$.   3: while ${iter}_{number}<{iter}_{stop}$ do   4:    The neighborhood structures $N^{\pi }$ and $N_1^{(\alpha -\rho )}$ are selected with the same probability to generate neighborhood solutions.   5:    Estimate the makespan of all neighborhood solutions.   6:    if the criteria for aspiration is fulfilled then   7:      ${iter}_{number}\leftarrow 0$.   8:      Update both the current solution $d^{*}$ and the best solution $d_{best}$.   9:    else 10:      ${iter}_{number}\leftarrow {iter}_{number}+1$. 11:      Choose the best no-tabu solution from all neighborhood solutions as the current solution. 12:    end if 13:    Update the tabu list. 14: end while 15: return the best solution $d_{best}$.

4.3. Implementation

Pseudo-code Algorithm 3 details the procedure of the proposed FRAS algorithm. The FRAS algorithm obtains the best solution $d_{global}^s$ at the rescheduling point $A_s$.

Algorithm 3 The FRAS algorithm.

1: for $s=1$ to S do   2:    New orders arrival.   3:    New order s arrive at the time $A_s$ and trigger the rescheduling.   4:    Update the set $O_s^{RNJ}$.   5:    while the termination condition is not fulfilled do   6:       Generate D initial feasible solution of order s with Algorithm 2.   7:       $\{d_1,d_2,\dots ,d_D\}\leftarrow \mathrm{FCH}\left(\right)$.   8:       Select the best solution from $D_{FCH}$.   9:       $d^{*}\leftarrow {\{d_1,\dots ,d_D\}}_{min \mathrm{makespan}}$. 10:       Improve the solution ${\mathrm{solution}}_s$ with Algorithm 3. 11:       $d_{best}\leftarrow \mathrm{ITS}\left(d^{*}\right)$. 12:       Update the best solution $d_{\mathrm{global}}^s$. 13:       $d_{\mathrm{global}}^s\leftarrow {\{d_{\mathrm{global}}^s,d_{best}\}}_{min \mathrm{makespan}}$. 14:    end while 15:    Execute the solution $d_{\mathrm{global}}^s$ in the dynamic scheduling system. 16: end for

5. Experiments and Results

In this section, various experiments are performed to compare the efficiency and effectiveness of the FRAS algorithm. First, dynamic cases are designed to verify the performance of the FRAS algorithm. Second, the FRAS algorithm is applied to the real-world manufacturing plant case study. In practical dynamic environments, achieving satisfactory solutions quickly is crucial. Therefore, the termination condition is established as a CPU time limit of $n_s\times M\times t$ milliseconds. Here, $n_s$ represents the total quantity of jobs pending rescheduling at point s, M represents the count of machines, and t stands for a pre-defined constant (assigned the value of 200 in the experimental setups). All algorithms undergo 30 independent executions on each case, using a PC equipped with an Intel(R) Core(TM) i5-9300 CPU @ 2.40 GHz and 8 GB RAM, and implemented in Python 3.6. Furthermore, the MDFJSP instances ($MD01-MD12$) were generated based on real-world problem scenarios.

Table 3. Parameter settings for instances.

Parameter	Value
Total number of machines (M)	randi [10, 20]
Total number of job types (R)	randi [5, 10]
Total number of operations of job type r ($J_r$)	randi [5, 10]
Number of available machines per operation	randi [1, M]
Processing time of an operation ($t_{rjm}$)	randi [1, 20]
Total number of new orders (S)	randi [1, 5]
Total number of job type r in new order s ($N_{sr}$)	randi [10, 20]
Mean interarrival time of new jobs ($\lambda$)	randi [200, 800]

presents the generation parameters for instances. In Table 3, ‘randi’ denotes the uniform distribution of integer numbers.

5.1. Parameter Settings

Parameter selection plays a crucial role in algorithm performance. Three parameters affect the efficiency of the proposed FRAS algorithm. In this section, we calibrate the algorithm parameters with the Taguchi method for the design of experiments (DOE) [57]. The DOE is an effective and efficient investigative method widely used to evaluate the effect of multiple factors on different algorithms. The three parameters {D, ${iter}_{stop}$, b} define the FRAS. D is the number of generated initial feasible solutions with the FCH method for each iteration of the FRAS algorithm, ${iter}_{stop}$ is the permitted maximum iteration number with no improvement of ITS, and b is the $\alpha$ parameter, which used to balance the stochasticity and covetousness of the proposed algorithm. Ten randomly generated instances are selected to identify the effect of the three parameters. The parameter D has four possible values: {10,20,40,80}, the parameter ${iter}_{stop}$ can be {10,20,30,40}, and the parameter b can be {0.1,0.2,0.3,0.4}. As shown in

Table 4. Orthogonal array and average response values.

Combination	Parameters			${\mathit{C}}_{\mathit{avg}}$
	${\mathit{\text{iter}}}_{\mathbf{\text{stop}}}$	$\mathit{D}$	$\mathit{b}$
1	10	10	0.1	2010
2	10	20	0.2	2030.7
3	10	40	0.3	2017.7
4	10	80	0.4	2014
5	20	10	0.2	2025
6	20	20	0.1	2034
7	20	40	0.4	2016.7
8	20	80	0.3	2025.3
9	30	10	0.3	2032.3
10	30	20	0.4	2035.3
11	30	40	0.1	2021
12	30	80	0.2	2017.3
13	40	10	0.4	2024.7
14	40	20	0.3	2000.7
15	40	40	0.2	2006.3
16	40	80	0.1	2024.3

, the parameter combinations are represented with the orthogonal array $L_{16}$. The average makespans $C_{avg}$ of 10 instances, obtained through 30 independent runs of the FRAS, are used as the response values in our analysis. Figure 4 illustrates the trend in factor levels. Figure 4 shows that the FRAS algorithm with control parameters of ${iter}_{stop}=40$, $D=40$, and $b=0.3$, performs better.

5.2. Validation of Proposed Methods

We conduct a set of experiments to assess the effectiveness of the proposed FCH and ITS methods in the FRAS framework for solving instances of the MDFJSP.

Table 5. Comparison of the FRAS algorithm and its variant algorithms on generated instances.

Instance	M	R	S	FRAS_RANDOM			FRAS_TS			FRAS
				$\mathit{Best}$	$\mathit{Avg}$	$\mathit{RPD}$	$\mathit{Best}$	$\mathit{Avg}$	$\mathit{RPD}$	$\mathit{Best}$	$\mathit{Avg}$	$\mathit{RPD}$
MD01	10	5	1	639	732.6	0.86	398	403.6	0.02	394	400.4	0.02
MD02	10	5	3	2814	2951.6	1.05	1457	1468.4	0.02	1440	1457.2	0.01
MD03	10	5	5	3489	3683.8	0.76	2101	2113.6	0.01	2089	2092.8	0.00
MD04	10	10	1	1180	1277	1.30	570	575	0.04	555	556.4	0.00
MD05	10	10	3	4721	5103	1.87	1789	1806	0.02	1778	1791.8	0.01
MD06	10	10	5	9370	9569.6	2.07	3127	3137.2	0.00	3122	3148.2	0.01
MD07	20	5	1	452	492.8	0.30	380	380	0.00	380	380	0.00
MD08	20	5	3	3794	3841.2	0.09	3545	3548.4	0.00	3540	3541.6	0.00
MD09	20	5	5	2347	2419.2	0.17	2078	2078	0.00	2075	2075	0.00
MD10	20	10	1	775	929.4	1.53	395	401.4	0.09	367	373.6	0.02
MD11	20	10	3	2577	2727.8	0.37	1992	1993.6	0.00	1986	1988.8	0.00
MD12	20	10	5	3539	3667.6	0.34	2768	2773.2	0.01	2737	2737	0.00
#better				12			11
#even				0			1
#worse				0			0

summarizes the experimental results. Two variants of the FRAS algorithm are considered: $FRAS\_RANDOM$, which is a variant obtained by replacing the FCH with a random initialization method in the FRAS framework, and $FRAS\_TS$, which is a variant obtained by replacing the ITS with a classical tabu search (TS) procedure in the FRAS algorithm. The performance of these variants is compared and analyzed to assess the impact of the FCH and ITS methods in the FRAS framework.

Table 5 presents data on the best and average makespan for each algorithm in the “$Best$” and “$Avg$” columns, respectively. The rows labeled “#best”, “#even”, and “#worse” indicate the number of cases where the FRAS algorithm outperforms, equals, or lags behind the reference methods. The “$RPD$” column indicates the average relative percentage deviation, calculated using Equation (22). Smaller $RPD$ values signify superior algorithm performance.

$$RPD=\frac{C_{avg}-C_{best}}{C_{best}}\times 100\%$$

(22)

Table 5 demonstrates that the FRAS algorithm achieves the best and average makespan among all 12 instances. It outperforms FRAS_TS in 11 out of 12 instances, with FRAS_TS only achieving the best makespan for MD07. Additionally, the FRAS algorithm outperforms FRAS_RANDOM in all 12 instances. These results prove the effectiveness of the proposed FCH and ITS methods. Comparing FRAS_TS and FRAS_RANDOM, it is observed that FRAS_TS generally outperforms FRAS_RANDOM in most instances. This suggests that the FCH method has a more significant impact on improving the FRAS’s performance compared to the ITS method. Moreover, the FRAS algorithm exhibits a smaller $RPD$ value and displays less fluctuation in the results, indicating that the proposed methods enhance the stability and robustness of the FRAS algorithm.

5.3. Comparison with Existing Algorithms

In this section, the FRAS algorithm is compared with the self-learning genetic algorithm (SLGA) [58], two-stage genetic algorithm (2SGA) [59], and greedy randomized adaptive search (GRAS) algorithm [38,60]. These three algorithms are utilized for solving combinatorial optimization problems. The SLGA combines Q-learning reinforcement learning methods, leading to improved performance compared to the classical genetic algorithm. The GRAS includes a successful greedy initialization method and effectively addresses FJSPs in both static and dynamic environments. The 2SGA combines fast neighborhood estimation, tabu search, and path relinking operators to successfully address FJSPs. These algorithmic approaches have demonstrated their effectiveness and efficiency in tackling complex optimization challenges in various domains. These algorithms are activated to generate a new schedule when rescheduling is triggered. The parameter settings for all comparative algorithms are selected from their corresponding literature. The respective literature has established these parameters’ values through experimental determination.

Table 6. Comparison of the FRAS and reference algorithms.

Instance	SLGA			2SGA			GRAS			FRAS
	$\mathit{B}\mathit{e}\mathit{s}\mathit{t}$	$\mathit{A}\mathit{v}\mathit{g}$	$\mathit{R}\mathit{P}\mathit{D}$	$\mathit{B}\mathit{e}\mathit{s}\mathit{t}$	$\mathit{A}\mathit{v}\mathit{g}$	$\mathit{R}\mathit{P}\mathit{D}$	$\mathit{B}\mathit{e}\mathit{s}\mathit{t}$	$\mathit{A}\mathit{v}\mathit{g}$	$\mathit{R}\mathit{P}\mathit{D}$	$\mathit{B}\mathit{e}\mathit{s}\mathit{t}$	$\mathit{A}\mathit{v}\mathit{g}$	$\mathit{R}\mathit{P}\mathit{D}$
MD01	648	660.4	0.68	414	419.2	0.06	479	482.4	0.22	394	400.4	0.02
MD02	2230	2282.8	0.59	1503	1511.4	0.05	1739	1754.2	0.22	1440	1457.2	0.01
MD03	2928	2989.8	0.43	2131	2147.2	0.03	2255	2281	0.09	2089	2092.8	0.00
MD04	1051	1086	0.96	619	625.4	0.13	674	684.6	0.23	555	556.4	0.00
MD05	4461	4517.2	1.54	2151	2163.8	0.22	2328	2344.2	0.32	1778	1791.8	0.01
MD06	9189	9333.2	1.99	3916	3935.4	0.26	4360	4392.2	0.41	3122	3148.2	0.01
MD07	420	436	0.15	380	380	0.00	393	396.2	0.04	380	380	0.00
MD08	3795	3815	0.08	3543	3543.8	0.00	3560	3565.8	0.01	3540	3541.6	0.00
MD09	2155	2168.2	0.04	2075	2075.6	0.00	2231	2255	0.09	2075	2075	0.00
MD10	756	792.4	1.16	383	387	0.05	531	541.4	0.48	367	373.6	0.02
MD11	2405	2419	0.22	2002	2011.2	0.01	2098	2106.4	0.06	1986	1988.8	0.00
MD12	3135	3219.4	0.18	2754	2758	0.01	2929	2936.2	0.07	2737	2737	0.00
#better	12			10			12
#even	0			2			0
#worse	0			0			0

lists the result.

Furthermore, the total computation time (TCPU) of each algorithm in every run is monitored. The TCPU represents the cumulative time expended by the algorithms across all rescheduling points. It encompasses the time taken to produce the optimal new scheduling scheme at each rescheduling point, known as the response time. Additionally, the total response time (TR) for all orders in each run is documented.

Table 7. Comparison of the mean TCPU time and the mean TR time for the FRAS and reference algorithms.

Instance	SLGA		2SGA		GRAS		FRAS
	TCPU (s)	TR (s)	TCPU (s)	TR (s)	TCPU (s)	TR (s)	CPU (s)	TR (s)
MD01	810.91	158.34	817.53	128.01	801.36	104.01	811.41	77.13
MD02	2692.95	515.80	2627.61	405.75	2522.59	336.10	2593.53	204.81
MD03	4617.25	873.66	4210.52	638.91	4048.66	516.81	4175.16	332.65
MD04	1486.13	286.94	1479.06	246.47	1462.64	128.97	1472.91	218.72
MD05	7037.06	1312.37	6870.16	1208.66	6454.06	589.96	6615.44	584.89
MD06	17,062.52	2928.87	15,696.34	2623.23	13,776.69	2038.57	14,340.09	898.58
MD07	1690.17	280.26	1688.42	10.19	1680.81	224.95	1685.28	3.22
MD08	4471.08	843.80	4469.41	554.09	4425.31	374.18	4436.13	260.98
MD09	8368.03	1497.52	8192.67	65.39	8194.89	1016.40	8128.34	21.76
MD10	3156.47	614.29	3154.64	291.18	3121.53	400.18	3132.09	344.46
MD11	10,460.31	2011.12	9734.64	1338.01	9601.25	1256.72	9600.47	852.91
MD12	15,184.58	2880.93	14,310.42	905.46	14,043.11	1906.02	14,065.84	1379.80

summarizes the mean TCPU and the mean TR times.

Table 7 demonstrates that the FRAS algorithm consistently achieves the optimal solution in all 12 instances with minimal time consumption. In Figure 5b, the FRAS algorithm demonstrates the smallest $RPD$ value and fluctuations, indicating enhanced stability and robustness. The mean TCPU of all algorithms is depicted in Figure 5c, revealing that the four algorithms incur comparable TCPU times. Nevertheless, as shown in Figure 5d, the mean TR of the FRAS algorithm significantly outperforms the reference algorithms, making the FRAS algorithm more suitable for practical production applications, particularly in scenarios with frequent dynamic events. Moreover, the computational efficiency of the FRAS algorithm is pivotal, particularly when scaling to larger, more complex problem instances involving an increase in machines (M), job types (R), and orders (S). This growth is accompanied by an escalation in computational demand, as measured by TCPU and TR, due to the expanding and increasingly intricate solution space. The algorithm’s solution through this space necessitates more computational resources and time to secure optimal or near-optimal solutions. The influx of new orders intensifies the scheduling complexity, prompting more frequent rescheduling and a higher number of jobs to be reallocated at each rescheduling juncture. This dynamic facet of the problem amplifies the computational burden, necessitating continuous adaptation and reevaluation by the algorithm in response to evolving conditions.

It is important to note that response time is essential when dealing with scheduling problems in actual manufacturing, especially when dynamic events are involved. Figure 6 presents a mean reaction time comparison for the four algorithms across all rescheduled points in four representative cases. It illustrates that the FRAS algorithm consistently exhibits shorter response times than the reference algorithms for the majority of rescheduled issues. In addition, the mean response time of the FRAS algorithm has more minor fluctuations throughout all the orders. This is owing to the addition of the FCH methods to the FRAS algorithm. The FCH constructs D solutions, and chooses the best solution as the initial solution in each iteration of the FRAS algorithm. This ensures both high quality and diversity in initial solutions. Furthermore, the FRAS algorithm maintains a well-balanced approach between exploitation and exploration capabilities through the selection of appropriate parameters ${\mathit{iter}}_{\mathrm{stop}}$ and b. To statistically assess FRAS’s performance against the reference algorithms, the Wilcoxon test [61] is employed. Furthermore, we perform a sensitivity analysis to assess the impact of the time interval for new order arrivals on the algorithm’s performance. Due to space limitations, a more detailed description is provided in the Appendix D.

5.4. Industrial Application

To further validate the effectiveness of the FRAS algorithm, we conducted a series of practical case studies from a real-world motorcycle part manufacturing factory. The study utilizes process information obtained from a motorcycle part manufacturing factory (details in Appendix E). The manufacturing system comprises 20 machine tools, including various CNC machines, used to process 3 different types of motorcycle parts with flexible process routes as shown in Figure 7. The factory’s production data revealed the processing of hundreds of jobs daily, with orders containing multiple jobs of each part type arriving randomly. This scenario exhibits large-scale, multiplicity, and dynamic production characteristics. Five manufacturing cases (Data01–Data05) are selected based on enterprise orders, with additional information provided in Appendix E.

For instance, Data01’s initial schedule is created for orders 1-1, consisting of 51 new parts across three types, arriving at time 0 (stage 1). Subsequently, order 1-2, comprising 65 new parts and arriving at time 537, triggers the transition to the next stage (stage 2). The FRAS algorithm then generates a new schedule after orders 1-2 arrive. Figure 8 illustrates both the initial and rescheduled schemes for Data01.

Table 8. Comparison of the FRAS algorithm and reference algorithms on manufacturing cases.

Example	SLGA		2SGA		GRAS		FRAS
	$\mathit{B}\mathit{e}\mathit{s}\mathit{t}\mathbf{\left(}\mathit{A}\mathit{v}\mathit{g}\mathbf{\right)}$	TR (s)	$\mathit{B}\mathit{e}\mathit{s}\mathit{t}\mathbf{\left(}\mathit{A}\mathit{v}\mathit{g}\mathbf{\right)}$	TR (s)	$\mathit{B}\mathit{e}\mathit{s}\mathit{t}\mathbf{\left(}\mathit{A}\mathit{v}\mathit{g}\mathbf{\right)}$	TR (s)	$\mathit{B}\mathit{e}\mathit{s}\mathit{t}\mathbf{\left(}\mathit{A}\mathit{v}\mathit{g}\mathbf{\right)}$	TR (s)
Data01	3501 (3529)	558.6	2851 (2960)	548.5	2108 (2124)	250.7	1933 (1959)	39.5
Data02	3828 (3856)	718.6	3483 (3524)	598.6	3416 (3422)	412.2	3327 (3328)	136.9
Data03	6107 (6168)	1072.8	5785 (5839)	1002.5	5493 (5499)	570.7	5376 (5378)	199.4
Data04	8358 (8443)	1651.5	7566 (7572)	1533.6	6632 (6641)	736.5	6431 (6433)	428.7
Data05	10,698 (10,785)	1803.5	9369 (9532)	1748.2	6801 (6806)	647.4	6502 (6504)	273.2

demonstrates that the FRAS algorithm consistently achieves optimal and average makespan results across all cases. More importantly, the FRAS algorithm exhibits significantly reduced mean total response times (TR) compared to the GRAS by from $40\%$ to $90\%$, surpassing the other three reference algorithms by more than $70\%$. These results emphasize the strong suitability of the FRAS algorithm for tackling the MDFJSP. Additionally, the FRAS algorithm consistently outperforms the reference algorithms regarding mean TR time and completion time. This indicates that the FRAS algorithm processes all parts more efficiently and can swiftly generate new rescheduling schemes in response to dynamic events. The FRAS algorithm shows significant promise for effectively addressing practical production challenges characterized by multiplicity and dynamic flexibility in shop scheduling.

Furthermore, the FRAS algorithm’s practical utility shines through its capacity to deliver significant advantages across a spectrum of manufacturing contexts. In high-mix, low-volume sectors, such as aerospace and automotive parts production, where customization and product diversity are paramount, the algorithm’s proficiency in orchestrating various job types enhances the scheduling efficiency, shortens lead times, and elevates customer satisfaction. In just-in-time production environments, like electronics and consumer goods, marked by elevated inventory costs and variable market needs, the FRAS algorithm’s dynamic rescheduling capabilities ensure the seamless synchronization with real-time orders, minimizing stockpiles and waste. Its rescheduling agility is equally crucial in emergency response scenarios, where it facilitates rapid realignment in the face of unexpected disruptions, such as production disturbances, aiding in the swift restoration of operations and the mitigation of losses. Furthermore, for contract manufacturing enterprises where agility and rapid response are vital, the FRAS algorithm offers a competitive edge by enabling nimble scheduling adjustments to accommodate fluctuating client requirements. In each of these settings, the FRAS algorithm’s ability to navigate complexity and adapt to changing conditions not only substantiates its theoretical underpinnings but also yields tangible benefits, making it a compelling tool for elevating operational efficiency and resilience in the manufacturing landscape.

6. Conclusions and Perspective

This article investigates the multiplicity dynamic flexible job shop scheduling problem (MDFJSP) with new order arrivals. A novel fluid randomized adaptive search (FRAS) algorithm is proposed to minimize makespan. The proposed FRAS algorithm comprises two phases. In the first phase, a fluid construction heuristic (FCH) incorporating an online fluid dynamic tracking policy is presented to generate high-quality initial solutions. In the second phase, we employ an improved tabu search to enhance the search efficiency in the solution space. The efficiency of the FRAS algorithm is validated by a comparison with its variants $FRAS\_TS$ and $FRAS\_RANDOM$. Further, the performance of the FRAS algorithm is compared with the self-learning genetic algorithm, two-stage genetic algorithm, and greedy randomized adaptive search algorithm. The results indicate that the FRAS algorithm outperformed the other algorithms in terms of effectiveness and superiority for solving the MDFJSP. Statistical analysis using the Wilcoxon test further validates FRAS’s outperformance over the reference algorithms. However, the FRAS algorithm exhibits a prolonged computational time when addressing large-scale problems, rendering it unsuitable for the efficient response requirements in large-scale optimization problems.

In the future, researchers could explore multi-objective approaches for MDFJSPs. Furthermore, expanding the problem scope to incorporate machine breakdowns and changes in due dates would provide valuable insights for addressing real-world complexities.