An Effective Hybrid Local Search Method for Flexible Job-Shop Scheduling Problem in Smart Manufacturing Systems

Abstract

The Flexible Job-shop Scheduling Problem (FJSP) plays an important role in production and processing in Smart Manufacturing Systems. Unlike the traditional Job-shop Scheduling Problem (JSP), the additional flexibility in machine selection enlarges the search space and increases scheduling difficulty, particularly for large-scale instances. Existing algorithms improve either convergence speed or solution quality, but maintaining both remains difficult as problem size grows. This paper presents a Hybrid Local Search Algorithm (HLS-FJSP), integrating Greedy Search, Genetic Algorithm, and Tabu Search into a two-phase optimization framework. Control parameters and a process monitoring mechanism are used to adjust the search behavior during different optimization stages. Computational experiments on benchmark instances show that the proposed method obtains competitive makespan results compared with several existing algorithms. The results also show stable improvement capability when used for further optimization of existing schedules.

1. Introduction

Due to the advancement of Industry 4.0 technologies, the production systems have become more flexible and intelligent, thus producing difficulties in production scheduling and resource allocation [1,2,3]. Different from the traditional JSP, FJSP permits one operation to be performed on various machines. In JSP, each operation is allocated to a specific machine, whereas several machines can be used for the same operation in FJSP [4]. Therefore, FJSP is more appropriate for real production systems [5]. FJSP has been widely applied in studies of machine utilization and production efficiency improvement [6].

In smart manufacturing environments, such as electronics production and automotive assembly lines, production systems often face unexpected changes [7,8]. Common disruptions include urgent order arrivals, material delays, and machine failures. The problem becomes more difficult when production scheduling must be coordinated with material transportation and logistics operations [9]. In such situations, rescheduling must be performed within a short time to reduce production delays and machine idle time [10]. In recent years, manufacturers have increasingly adopted high-mix, low-volume production modes enabled by Industry 4.0 technologies [11]. As a result, scheduling problems have become larger and more computationally demanding. In multi-plant manufacturing systems, additional coordination between production tasks and cross-plant material transportation further increases scheduling difficulty [12]. Recent research has therefore started to investigate integrated production and transportation scheduling with sustainability objectives [13], as well as real-time scheduling in production-logistics collaborative systems [9].

As production systems increase in size, the Flexible Job-shop Scheduling Problem becomes more challenging to solve within limited computation time. Because each operation may be processed on multiple machines, the number of feasible schedules grows rapidly with the problem scale. In real manufacturing environments, scheduling usually involves a large number of operations and machines, which further increases the complexity of production planning. Therefore, scheduling methods with a reasonable computation cost are necessary for obtaining good solutions in large-scale production systems.

Existing approaches to the FJSP can be broadly divided into exact, heuristic, and metaheuristic methods. Exact methods like branch-and-bound and dynamic programming are able to find optimal solutions for small-scale problems, but become computationally impractical as the instance size grows [14]. Heuristic methods, including dispatching rules [15] and local search methods [16], typically generate schedules very quickly, though the solution quality may fall short of what is desired [17]. Metaheuristic methods, such as Genetic Algorithm [18] and Particle Swarm Optimization [19], have also been widely used in FJSP. These methods can search a larger solution space, but their performance often depends on parameter settings. In large-scale scheduling problems, these methods may converge prematurely or require considerable computation time [20]. As a result, many studies have explored hybrid metaheuristic methods that combine different search strategies [21,22,23,24,25]. Although hybrid approaches generally obtain better solutions, most of them still follow predefined search procedures, which reduces their flexibility under dynamic production conditions. Recently, Lorenzi et al. [26] proposed HCPGA for JSP by integrating constraint programming with a genetic algorithm to reduce computation time and memory usage.

In recent years, data-driven approaches such as Deep Reinforcement Learning (DRL) have been widely studied for FJSP [27,28,29,30]. By interacting with the scheduling environment during training, DRL methods can learn scheduling policies and generate decisions within a short time. However, the decision-making process of DRL models is difficult to interpret, and the training process usually requires substantial computational resources and training data. In addition, their scheduling results may still be worse than those obtained by effective local search methods.

Considering the limitations of static metaheuristics and learning-based approaches, we propose a two-phase optimization method called HLS-FJSP. The method consists of an initialization phase and a local search phase. Different methods can be used to generate initial solutions, including dispatching rules, random initialization, DRL-based methods, and hybrid approaches such as HCPGA. The generated solutions are then improved through local search using greedy operations and random perturbations. In this way, HLS-FJSP serves not only as a standalone method but also as a general further optimization framework for improving solutions from different existing methods.

The main contributions of this study are summarized as follows:

• We propose a two-phase optimization method, HLS-FJSP, for FJSP. The method consists of an initialization phase and a local search phase. It can optimize machine assignment and operation sequencing simultaneously, and can also serve as a general further optimization tool to improve solutions generated by other scheduling methods.
• We design a decision-making mechanism augmented with an optimization process monitor. The parameters $\alpha$ and $\beta$ are used to switch among greedy search, genetic algorithm, and tabu search. Meanwhile, the repetition count t of the current best solution is recorded to perceive local optima. This mechanism helps maintain solution diversity and improves search performance.
• Experiments on several benchmark datasets show that HLS-FJSP achieves better scheduling results than traditional dispatching rules and metaheuristic methods such as NSGA-II. Ablation experiments are also conducted to analyze the influence of different components in the proposed method. In addition, further optimization experiments based on DRL methods and HCPGA show that HLS-FJSP can further improve the initial solutions generated by these methods.

The rest of this paper is organized as follows. Section 2 briefly reviews the existing methods for the FJSP. In Section 3, we introduce and describe the mathematical model of the FJSP. In Section 4, we introduce the HLS-FJSP algorithm and describe the core algorithmic techniques in detail. In Section 5, we design and conduct extensive experiments to evaluate the performance of HLS-FJSP. Finally, conclusions and prospects are exposed in Section 6.

2. Related Work

Since FJSP is difficult to solve, a wide range of optimization methods have been developed. Existing methods mainly include exact algorithms, heuristic algorithms, and metaheuristic algorithms.

Exact algorithms were among the earliest methods used for FJSP. Brucker and Schlie first presented a mathematical formulation of the problem and proposed a polynomial graphical algorithm for the two-job case [31]. Subsequent studies developed different mathematical programming models for FJSP. For example, Torabi et al. proposed a mixed-integer nonlinear programming model for multi-product lot scheduling in flexible manufacturing systems [32], while Gomes et al. developed an integer linear programming model solved by commercial MILP solvers [33]. Although exact algorithms can obtain optimal solutions, they are difficult to apply to large-scale FJSPs because their computation time increases rapidly as the problem size grows. Pezzella et al. reported that the performance of exact methods decreases significantly when the number of operations exceeds 200 [18]. As a result, many studies have focused on heuristic and metaheuristic methods because they can obtain good solutions within a shorter time.

Heuristic methods have also been widely used for FJSP because they are easier to implement and require less computation time than exact algorithms. Dispatching rules are commonly used to generate scheduling decisions quickly. Paulli applied dispatching rules to solve the machine selection subproblem and used tabu search for operation sequencing [15]. Tay and Ho used genetic programming to generate rule-based scheduling methods for multi-objective FJSPs [34]. Baykasoğlu and Özbakır studied the performance of dispatching rules under different flexibility levels [35], while Ziaee proposed a heuristic method designed for FJSP [36]. Although heuristic methods are simple and can be applied to large problems, their scheduling results are often unsatisfactory, especially for large and complex instances. As a result, many studies have focused on metaheuristic methods to obtain better scheduling results.

Metaheuristic methods have been widely used for FJSP, because they can be applied to large-scale scheduling problems [37,38,39]. Some recent studies have also considered energy-efficient scheduling in distributed systems [40] and advanced scheduling methods for manufacturing systems [41]. Metaheuristic methods for FJSP can typically be split into evolutionary algorithms, swarm intelligence methods, and local search methods. Evolutionary algorithms, such as Genetic Algorithms and Evolution Strategies, can explore different candidate schedules and have been widely studied in FJSP research [18,42,43,44,45,46]. Many studies have changed encoding strategies and combined different search methods to obtain more efficient schedules. Their local search performance is sometimes limited. Swarm intelligence methods, including Particle Swarm Optimization and Ant Colony Optimization, update solutions through cooperation among individuals [19,47,48,49]. Local search methods, such as Tabu Search and Simulated Annealing, can improve the current schedules efficiently, but they may converge to poor local solutions because they search based on a single solution [16,17,50,51]. Each method has its own strengths and limitations in FJSP [52,53].

Hybrid metaheuristic methods have also been studied for FJSP by combining different search strategies. Lin and Gen reviewed hybrid evolutionary optimization methods with learning strategies for production scheduling [54]. Zribi et al. combined different algorithms for machine selection and operation sequencing [21]. Several studies also combined evolutionary algorithms with local search or swarm intelligence methods for multi-objective and constrained FJSPs [22,23,24,25]. Zhang et al. proposed a hybrid multi-objective method for real-time flexible production scheduling in dynamic manufacturing environments [10]. These hybrid methods often obtain better scheduling results by combining different optimization methods. However, most existing hybrid methods still use fixed hybrid structures. The search process is usually controlled by fixed decomposition rules [21], fixed iteration thresholds [24], or periodic search strategies [22]. As a result, these methods may not perform well under different production conditions, and their adaptability in practical production systems is still limited. Recent studies have also considered other hybrid methods. For example, Lorenzi et al. [26] combined a Constraint Programming solver with a Genetic Algorithm for JSP. Although this method reduces the computation time and memory usage of exact methods, it still requires relatively long computation time for some problem instances.

In recent years, deep reinforcement learning (DRL) has been increasingly studied for combinatorial optimization problems. By formulating scheduling as a Markov Decision Process (MDP), DRL methods can learn scheduling strategies through interactions with the environment. After training, DRL models can generate scheduling decisions directly and produce schedules within a short time. However, current DRL-based scheduling methods still have some limitations in practical applications. Most models are designed for cases where the problem size does not change much and where a large amount of training data is available. In addition, DRL methods usually require long offline training time, and their decision process is difficult to interpret. Existing hybrid metaheuristic methods do not require offline training, but many of them still use fixed search structures, such as fixed execution sequences or predefined iteration thresholds. As a result, these methods cannot adjust their search strategies dynamically during optimization.

To address these issues, we propose a two-phase optimization method named HLS-FJSP. The method introduces a decision-making mechanism together with an optimization process monitor, allowing the algorithm to switch search strategies according to the current search state. HLS-FJSP adopts a two-phase structure consisting of initialization and local search, and can be used to refine schedules generated by other methods. Initial schedules produced by DRL models or dispatching rules are further optimized through local search. This structure reduces computational cost while maintaining stable search behavior and avoiding the long training stage required by DRL methods.

3. Problem Formulation

The Flexible Job-shop Scheduling Problem (FJSP) is an extension of the classical Job-shop Scheduling Problem (JSP). In FJSP, an operation can be processed by different machines, which is more consistent with practical production conditions in manufacturing systems. The FJSP considered in this paper is defined as follows. There are n jobs $J=\{J_1,J_2,\dots ,J_n\}$ and m machines $M=\{M_1,M_2,\dots ,M_m\}$. Each job $J_i$ contains a sequence of $n_i$ operations, denoted by $O_i=\{O_{i1},O_{i2},\dots ,O_{i{n}_i}\}$. These operations are processed according to a fixed operation order. Each operation $O_{ij}$ ($i=1,2,\dots ,n$, $j=1,2,\dots ,n_i$) can be assigned to a set of available machines $M_{ij}\subseteq M$. The processing time of operation $O_{ij}$ on machine $M_k\in M_{ij}$ is represented by $t_{ijk}$.

To complete a job $J_i$, all its operations $O_{ij}$ must be assigned to and processed by machines with the required capabilities. There are some constraints for the assignments of the operations. More details are as follows:

(1)

All jobs are independent; preemption is not allowed, and each machine can process only one operation at a time.

(2)

The precedence constraints among operations within each job must be strictly followed.

(3)

All jobs and machines become available simultaneously at time zero.

(4)

Each operation has at least one eligible machine that can perform it.

(5)

The processing time of an operation on a given machine is independent of the processing sequence.

(6)

Transportation times between operations are negligible and thus not considered.

In this paper, the scheduling objective is to minimize the maximal completion time of all the operations, i.e., makespan. The objective function can be represented by

$$Min.C_{max}=Min\left\{Max(s_{i{n}_{i}k}+t_{i{n}_{i}k})\right\}.$$

(1)

where $C_{max}$ is the maximum completion time of all job $J_i$, $s_{i{n}_{i}k}$ represents the start time of the last operation $O_{i{n}_i}$ of job $J_i$ in machine $M_k$.

4. Proposed Algorithm

This paper proposes a hybrid local search algorithm, HLS-FJSP, for the Flexible Job-shop Scheduling Problem. The algorithm contains two phases: initialization and local search. Initial solutions are generated first and then improved through local search. The overall procedure of HLS-FJSP is shown in Figure 1.

In Figure 1, S represents the current candidate solution and $S^{*}$ is the best solution obtained during the search. $rand$ is a uniformly generated random number in the interval $[0,1)$. The parameter $\alpha$ controls the selection between greedy search and random search, and $\beta$ controls the selection between the genetic algorithm and tabu search during the random search stage. The variable t records the consecutive repetition count of the current best solution, while r represents the maximum repetition threshold. The condition $S<S^{*}$ indicates that the candidate solution achieves a smaller makespan than the current best solution.

The initialization phase uses a heuristic initialization to generate feasible initial solutions. All generated schedules satisfy the problem constraints and are directly used in the local search phase. This helps avoid exploring infeasible schedules in large search spaces. The initialization phase also helps to preserve diversity in early iterations. The local search combines greedy search, genetic algorithm, and tabu search. Greedy search uses a scoring function and neighborhood search to improve machine selection and operation sequencing. Genetic algorithm generates new solutions through crossover and mutation, while tabu search uses a tabu list to avoid revisiting recent solutions. The algorithm switches among the strategies according to the current search state.

4.1. The Problem Setting

In the FJSP, scheduling information such as job processing order, machine assignment, processing time, and machine load must be stored during optimization. These factors increase scheduling complexity. In flexible manufacturing environments, production demand changes and new orders require frequent schedule updates. A pending-order list is introduced to record jobs waiting for processing. When new jobs arrive, scheduling information is updated through the pending-order list without changing the current schedule. Several data structures are used to store the scheduling solution, including the job sequence, operation list, processing adjacency matrix, maximum completion time, and the start time of each operation on each machine.

4.2. Initialization Phase

Our method consists of two main phases. The initialization phase generates feasible initial schedules, which affects the efficiency of subsequent local search. An initial schedule is generated according to current machine loads. Guided by the pending-order list, operations are assigned to candidate machines in sequence. To reduce machine load differences, operations are preferentially assigned to machines with smaller workloads. After all operations are assigned, a processing adjacency matrix is constructed to check whether the schedule satisfies all constraints. The makespan of the current schedule is then calculated, and the resulting schedule is passed to the local search phase.

4.3. Local Search Phase

In the local search phase, the initial schedule is further improved to obtain better scheduling results. Two local search methods are used: (1) greedy search based on a scoring function and neighborhood search, and (2) random search using genetic algorithm and tabu search. Control parameters are introduced to determine which search method is selected during optimization. The details of these parameters are described in Section 4.5. During optimization, HLS-FJSP switches between the two search methods to generate new feasible schedules. If a newly generated solution has a better objective value (e.g., makespan) than the current best solution, the current best solution is updated. The search process continues until the stopping conditions are satisfied, including the maximum number of iterations, computational time limits, or repeated occurrence of the same best solution. Unlike methods that combine tabu search directly into the genetic algorithm, the proposed method uses GA and TS independently. This provides more flexible search control, since the random search method is selected according to the current search state. The detailed procedure is shown in Algorithm 1.

Algorithm 1 Local Search Phase of HLS-FJSP

Input:  S: the input solution waiting for optimization; $\delta$: the maximum iteration count; $pn$: the population number for Genetic Algorithm; L: tabu list length; r: the maximum repeat count of solutions; $\alpha$: parameter for search mode; $\beta$: parameter for random search mode Output:  $S^{*}$: Best optimized solution; 1: $S^{*}\leftarrow S$ 2: $S_{pre}\leftarrow S$ 3: $t\leftarrow 0$ 4: while no termination criterion is met do 5:      $rand\leftarrow \mathrm{generate}\mathrm{a}\mathrm{random}\mathrm{value}$ 6:      if $rand<\alpha$ then 7:           $rand\leftarrow \mathrm{generate}\mathrm{a}\mathrm{random}\mathrm{value}$ 8:           if $t<r/2$ or $rand<\beta$ then 9:                 $\overline{S}\leftarrow \mathrm{Genetic}\text{\_}\mathrm{Algorithm}\left(S_{pre}\right)$ 10:          else 11:                $\overline{S}\leftarrow \mathrm{Tabu}\text{\_}\mathrm{Search}\left(S_{pre}\right)$ 12:          end if 13:      else 14:           $\overline{S}\leftarrow \mathrm{Greedy}\text{\_}\mathrm{Search}\left(S_{pre}\right)$ 15:           if $\mathrm{Cost}\left(\overline{S}\right)<\mathrm{Cost}\left(S^{*}\right)$ then 16:                 $S^{*}\leftarrow \overline{S}$ 17:                 $S_{pre}\leftarrow \overline{S}$ 18:            else 19:                 $rand\leftarrow \mathrm{generate}\mathrm{a}\mathrm{random}\mathrm{value}$ 20:                 if $t<r/2$ or $rand<\beta$ then 21:                     $\overline{S}\leftarrow \mathrm{Genetic}\text{\_}\mathrm{Algorithm}\left(S_{pre}\right)$ 22:                 else 23:                     $\overline{S}\leftarrow \mathrm{Tabu}\text{\_}\mathrm{Search}\left(S_{pre}\right)$ 24:                 end if 25:            end if 26:      end if 27:      if $\mathrm{Cost}\left(\overline{S}\right)<\mathrm{Cost}\left(S^{*}\right)$ then 28:            $S^{*}\leftarrow \overline{S}$ 29:            $S_{pre}\leftarrow \overline{S}$ 30:      end if 31:      if $\mathrm{Cost}\left(S^{*}\right)<=\mathrm{Cost}\left(S_{pre}\right)$ then 32:            if $\mathrm{Cost}\left(S^{*}\right)<\mathrm{Cost}\left(S_{pre}\right)$ then 33:                 $t\leftarrow 1$ 34:            else 35:                 $t\leftarrow t+1$ 36:            end if 37:      end if 38:      $S_{pre}\leftarrow S^{*}$ 39: end while 40: return $S^{*}$

4.3.1. Greedy Search

The greedy search mode uses a scoring function to generate an operation list [55,56]. The order of operations in the list indicates the importance of each operation in the current schedule. According to the selected operation, neighboring solutions are generated for machine assignment and operation sequencing. The algorithm then returns the best neighboring solution. Algorithm 2 shows the detailed procedure of the greedy search in HLS-FJSP.

Algorithm 2 Greedy Search of HLS-FJSP

Input: $S^{\prime }$: the input solution waiting for optimization $\delta$: the maximum iteration count Output: $S^{*}$: the best solution output by Greedy Search 1: $\widehat{F}\leftarrow \varnothing$ 2: $p_1\leftarrow \mathrm{Score}\text{\_}\mathrm{For}\text{\_}\mathrm{Move}\left(S^{\prime }\right)$ 3: $p_2\leftarrow \mathrm{Score}\text{\_}\mathrm{For}\text{\_}\mathrm{Exchange}\left(S^{\prime }\right)$ 4: while $\mathrm{size}\mathrm{of}\widehat{F}<\delta$ do 5:       $\widehat{F}\leftarrow \mathrm{Move}\text{\_}\mathrm{Neighbor}\text{\_}\mathrm{Search}(S^{\prime },p_1)$ 6:       $\widehat{F}\leftarrow \mathrm{Exchange}\text{\_}\mathrm{Neighbor}\text{\_}\mathrm{Search}(S^{\prime },p_2)$ 7: end while 8: $S^{*}\leftarrow \mathrm{best}\mathrm{solution}\mathrm{in}\widehat{F}$ 9: return $S^{*}$

Scoring Function: The scoring function is used to rank operations during search for machine assignment and operation sequencing. As shown in Lines 2–3 of Algorithm 2, two ordered operation lists are generated: $p_1$ for machine assignment and $p_2$ for operation sequencing. For machine assignment, the priority of an operation is determined by the difference between the processing time on its current machine and the minimum processing time among all candidate machines. Operations with larger differences are given higher priority, generating the list $p_1$. For operation sequencing, operations with smaller indices in the same job are given higher priority, followed by their current positions on machines. This sorting rule generates $p_2$ and gives priority to earlier operations to reduce delays in later operations.

Greedy neighborhood search: Guided by the scoring function, the greedy neighborhood search searches neighboring schedules by modifying machine assignment and operation sequencing, as shown in Lines 5–6 of Algorithm 2. For machine assignment, an operation in $p_1$ is moved to the candidate machine with the shortest processing time, and feasible insertion positions are searched. For operation sequencing, an operation in $p_2$ is exchanged with its previous operation on the machine. Each neighboring solution is checked for feasibility to avoid deadlocks or constraint violations. If a neighboring solution is infeasible, the modification is canceled, and the next operation is considered. The search continues until all operations are processed or the predefined maximum number of feasible neighboring solutions is reached.

4.3.2. Genetic Algorithm

The proposed HLS-FJSP uses a genetic algorithm (GA) [44,57] to update feasible schedules through crossover and mutation. Each solution is represented by a chromosome. The initial population is generated using global, local, and random initialization methods. In each iteration, new individuals are generated by crossover and mutation, then decoded and evaluated according to objective value (e.g., makespan). Individuals with better objective value are retained in the population. The process continues until the maximum number of iterations is reached. Algorithm 3 shows the main procedure of the genetic algorithm, including chromosome representation, population initialization, and genetic operations.

Encoding and decoding: In the genetic algorithm, each solution is represented by a chromosome containing machine assignment and operation sequencing information. The FJSP includes two related subproblems: machine assignment and operation sequencing. For these two subproblems, HLS-FJSP uses a segmented encoding method in which the two parts are represented separately.

Algorithm 3 Genetic Algorithm of HLS-FJSP

Input: $S^{\prime }$: the input solution $\delta$: the maximum iteration count $pn$: the population size Output: $S^{*}$: the best solution output by Genetic Algorithm 1: $\widehat{P}\leftarrow \varnothing$ 2: $ms,os\leftarrow \mathrm{Encode}\text{\_}\mathrm{Schedule}\left(S^{\prime }\right)$          ▹ encoded sequences 3: $\widehat{P}\leftarrow \mathrm{Global}\text{\_}\mathrm{Initialize}(ms,os,pn)$ 4: $\widehat{P}\leftarrow \mathrm{Local}\text{\_}\mathrm{Initialize}(ms,os,pn)$ 5: $\widehat{P}\leftarrow \mathrm{Random}\text{\_}\mathrm{Initialize}(ms,os,pn)$ 6: $k\leftarrow 0$ 7: $\widehat{C}\leftarrow \varnothing$ 8: while $k<\delta$ do 9:       $\widehat{C}\leftarrow \mathrm{Cross}\text{\_}\mathrm{Operator}\left(\widehat{P}\right)$ 10:     $\widehat{C}\leftarrow \mathrm{Variation}\text{\_}\mathrm{Operator}\left(\widehat{P}\right)$ 11:     $\widehat{P}\leftarrow \mathrm{Selection}(\widehat{C},pn)$ 12:     $k\leftarrow k+1$ 13: end while 14: $ms,os\leftarrow \mathrm{best}\mathrm{solution}\mathrm{in}\widehat{C}$ 15: $S^{*}\leftarrow \mathrm{Decode}\text{\_}\mathrm{Schedule}(ms,os)$          ▹ decoded sequences 16: return $S^{*}$

• Machine Selection Encoding: This part of the chromosome has a length equal to the total number of operations. Each gene is represented by an integer arranged according to the order of jobs and operations. The value of each gene indicates the selected machine among the candidate machines for the corresponding operation.
• Operation Sequencing Encoding: The second part of the chromosome also has a length equal to the total number of operations and is used for operation sequencing. Each gene represents a job number, and the order of these job numbers determines the processing sequence of operations from different jobs.

An example is shown in Figure 2. For a given scheduling instance, the chromosome may be represented as $\{2,1,3,4,2\}$ for machine assignment and $\{1,2,1,1,2\}$ for operation sequencing.

During decoding, the algorithm first generates a machine assignment matrix from the machine selection segment of the chromosome. Then, operations are assigned to machines according to the sequencing segment to generate the schedule.

Population initialization: The initial population affects the search process of the genetic algorithm. HLS-FJSP uses three initialization methods: global generation, local generation, and random generation. These methods are used in a predefined ratio according to the population size $pn$ to generate the initial population $\widehat{P}$ (Lines 3–5 in Algorithm 3).

In the global generation method, a cumulative machine load array is maintained. For each randomly selected job, its operations are assigned to the machine that gives the smallest accumulated processing time, and the machine load array is updated after each assignment. This method reduces differences in machine loads among jobs.

In the local generation method, each job is processed separately. For each job, machines are selected according to the minimum processing time, and the machine load array is reset before the next job is processed.

In the random generation method, both the machine assignment segment and the operation-sequencing segment of the chromosome are generated randomly to generate different initial solutions.

Crossover Operation: The crossover operation is used to generate new individuals. HLS-FJSP uses two crossover methods for the two chromosome segments. Uniform crossover is applied to the machine assignment segment so that machine assignments from both parents can be retained. Precedence operation crossover (POX) is applied to the operation-sequencing segment. In POX, part of the job order is kept unchanged, and the remaining positions are filled with operations from the other parent. This crossover method keeps the generated chromosomes feasible. An example is shown in Figure 3.

Mutation operation: The mutation operation generates new individuals by modifying several genes in the chromosome. For the machine assignment segment, several positions are selected randomly, and the corresponding genes are replaced with randomly selected candidate machines. For the operation sequencing segment, the operation order is randomly changed.

Selection operation: The number of offspring $\widehat{C}$ generated after crossover and mutation is usually larger than the population size $pn$. During selection, the machine assignment segment and operation sequencing segment are decoded in order, and the makespan of each offspring is calculated. The best $pn$ individuals are retained as the population of the next generation. The process continues until the maximum number of iterations is reached.

4.3.3. Tabu Search

Tabu search is used to search neighboring schedules and avoid repeated search using a tabu list [16,58]. Since the makespan is mainly determined by the critical path in the disjunctive graph, the search focuses on operations on the critical path. Neighborhood search operators are applied to generate neighboring solutions, and the best neighboring solution is selected. If the selected solution has a better makespan than the current solution, it replaces the current solution and updates the best solution found so far. Otherwise, the best non-tabu solution is selected as the current solution. The previous best solution is added to the tabu list to avoid revisiting recently explored solutions. The search continues until the maximum number of iterations is reached. Algorithm 4 shows the detailed procedure of tabu search in HLS-FJSP.

Algorithm 4 Tabu Search of HLS-FJSP

Input: $S^{\prime }$: the input solution $\delta$: the maximum iteration count L: tabu list length Output: $S^{*}$: optimized schedule 1: $\widehat{F}\leftarrow \varnothing$ 2: $TabuList\leftarrow \varnothing$ 3: $S_{best}\leftarrow S^{\prime }$ 4: $S_{start}\leftarrow S^{\prime }$ 5: for $k\leftarrow 1$ to $\delta$ do 6:       $\widehat{F}\leftarrow \mathrm{Exchange}\text{\_}\mathrm{Tabu}\text{\_}\mathrm{Search}\left(S_{start}\right)$ 7:       $\widehat{F}\leftarrow \mathrm{Move}\text{\_}\mathrm{Tabu}\text{\_}\mathrm{Search}\left(S_{start}\right)$ 8:       $S_{cand}\leftarrow \mathrm{best}\mathrm{solution}\mathrm{in}\widehat{F}$ 9:       if $S_{cand}<S_{best}$ then 10:            $S_{best}\leftarrow S_{cand}$ 11:       else 12:            $S_{best}\leftarrow \mathrm{best}\mathrm{non-tabu}\mathrm{solution}\mathrm{in}\widehat{F}$ 13:       end if 14:       $\mathrm{Add}\text{\_}\mathrm{To}\text{\_}\mathrm{Tabu}\text{\_}\mathrm{List}(TabuList,L,S_{best})$ 15:       $S_{start}\leftarrow S_{best}$ 16: end for 17: $S^{*}\leftarrow S_{best}$ 18: return $S^{*}$

Tabu list encoding: Operations that change the schedule involve both machine assignment and operation sequencing. Encoding these operations directly is difficult, while separating them into multiple sub-operations would greatly increase the size of the tabu list. Therefore, HLS-FJSP uses direct solution encoding, where feasible solutions are converted into strings and stored in the tabu list to avoid revisiting the same solutions. When the tabu list is not full, the new solution string is added directly. Otherwise, the earliest stored solution is removed before the new solution is added (Algorithm 4, Line 14).

Neighborhood search: Tabu neighborhood search is used to search neighboring solutions based on operations on the critical path. In the FJSP, the critical path in the disjunctive graph corresponds to the makespan of the schedule. As shown in Figure 4, black edges represent the operation order within the same job, while colored edges represent the processing order on the same machine. These edges represent different precedence relations. The disjunctive graph forms a directed acyclic graph (DAG), and its longest path is regarded as the critical path. An example of a critical path is $\{0,1,8,9,3,10\}$. For the machine selection subproblem, unlike the greedy search method, an operation is tested on other feasible machines one by one and inserted into the earliest feasible idle time slot of the target machine. For the operation-sequencing subproblem, unlike the N1 neighborhood used in greedy search, the algorithm searches for an earlier processing position of the operation on the current machine and adds the feasible solution to the candidate set $\widehat{F}$. The tabu neighborhood search procedure is shown in Lines 6–7 of Algorithm 4.

4.4. Search Mode Decision

In existing studies on the Flexible Job-shop Scheduling Problem (FJSP), combining multiple search algorithms has been widely used to improve solution quality. However, one problem still exists in many hybrid methods: the search strategy is usually determined by fixed rules. Most methods use predefined execution orders, fixed iteration thresholds, or periodic switching between algorithms. As a result, the search may stay around the same solutions for many iterations, making further improvement difficult.

To this end, HLS-FJSP introduces a decision-making mechanism that switches between search strategies based on the current search state. Specifically, unlike traditional hybrid methods that follow a rigid execution sequence for Greedy Search, Genetic Algorithm (GA), and Tabu Search (TS), HLS-FJSP incorporates two key components: a process monitoring mechanism and a set of control parameters. A maximum stagnation threshold r is defined for the best-known solution, and the consecutive repetition count t is recorded in real time during the search. The value of t serves as a feedback indicator of search stagnation. Based on t, the control parameters $\alpha$ and $\beta$ are leveraged to adjust the search mode accordingly. This state-driven transition mechanism coordinates global exploration and local exploitation more effectively than static hybrid frameworks.

To mitigate redundant search in stagnant regions, HLS-FJSP employs a control parameter $\alpha$ to govern the selection of the search mode. The procedure of this search mode decision mechanism is outlined in Algorithm 1. Before each iteration, a random number $rand\in [0,1)$ is generated and compared with $\alpha$. If $rand<\alpha$, a stochastic search mode is selected; otherwise, a greedy search mode is executed. In the greedy search mode, the algorithm performs local exploitation in the neighborhood of the current solution to identify immediate improvements. If no improved solution is obtained, the algorithm switches to the stochastic search stage in subsequent steps to explore other promising regions of the solution space.

During the stochastic search stage, the search operator is determined by the feedback parameters t and r. Here, t represents the consecutive iterations during which the best solution remains unchanged, and r denotes the maximum stagnation threshold. If a new best solution is identified, t is reset to 1; otherwise, t is incremented by 1. If $t<r/2$, representing a moderate stagnation state, the genetic algorithm (GA) is selected to explore a broader candidate solution space. Conversely, if $t\ge r/2$, indicating a deeper stagnation state, the control parameter $\beta$ is introduced as a selection probability to balance global exploration and intensive exploitation. Specifically, a random number $rand\in [0,1)$ is generated and compared with $\beta$. If $rand<\beta$, the GA is selected to maintain population diversity; otherwise, tabu search (TS) is invoked to perform rigorous local search around the current stagnant solution.

4.5. Complexity Analysis

To evaluate the computational efficiency of the proposed HLS-FJSP algorithm, we present a theoretical analysis of its time complexity. The local search phase of the proposed HLS-FJSP is implemented through multiple iterations, and the maximum number of iterations, maximum time limit, and maximum repetition number of the optimal solution can be pre-set before running. HLS-FJSP is designed as an anytime algorithm. The algorithm can be stopped at any time and return the current result. In this case, the total running time depends on the stopping criterion, rather than a fixed theoretical bound. Therefore, we focus on analyzing the complexity of a complete iteration. Let n be the number of jobs, m the number of machines, and v the total number of operations.

Time Complexity:

The time complexity of HLS-FJSP is primarily determined by its three core components operating within the iterative local search phase. Let n be the number of jobs, m the number of machines, and v the total number of operations.

• Greedy Search: The greedy neighborhood search involves evaluating moves for operations on the critical path. The scoring function and neighborhood evaluation for a single iteration can be accomplished in $O\left(v\log v\right)$ time due to sorting operations. In the worst case, this needs to be performed for all operations, leading to a complexity of $O\left(v^2\log v\right)$.
• Genetic Algorithm (GA): The complexity of one GA generation is dominated by the fitness evaluation of the population. Given a population size $pn$, and the decoding of a chromosome taking $O\left(v\right)$ time, the per-generation complexity is $O(pn·v)$.
• Tabu Search (TS): The TS complexity per iteration is governed by the neighborhood size and the tabu list check. Evaluating a neighborhood move for a critical operation is $O\left(1\right)$, and checking against the tabu list of length L is $O\left(L\right)$. For evaluating N neighbors, the per-iteration complexity is $O(N·L)$.

The time complexity of each major iteration in HLS-FJSP is determined by the three search components and the control parameters $\alpha$ and $\beta$. In practice, Greedy Search is used more frequently, which reduces the average running time. The time complexity of one major iteration is $O(v^2\log o+pn·v+N·L)$. Three stopping conditions are used in HLS-FJSP: the maximum number of iterations is 1200, the maximum running time is 6000 s, and the repetition threshold of the best solution is r. Let K denote the maximum number of iterations allowed under these conditions, i.e., $K=\min (1200,\mathrm{iterations}\mathrm{feasible}\mathrm{within}6000\mathrm{s},\mathrm{iterations}\mathrm{until}t>r)$. The overall worst-case time complexity of HLS-FJSP is therefore $O\left(K·(v^2\log v+pn·v+N·L)\right)$. The above analysis shows that HLS-FJSP can handle medium and large-scale FJSP instances within an acceptable computation time, which is suitable for scheduling problems in smart manufacturing environments.

5. Experiment Results and Discussion

In this section, we show our experiment results. To evaluate the effectiveness and performance of the proposed HLS-FJSP, we performed it on a series of publicly available FJSP benchmarks.

5.1. Experimental Preparation

To evaluate the performance of HLS-FJSP, experiments are conducted on four widely used FJSP benchmark suites: Brandimarte (10 instances), Barnes (21 instances), Dauzère (18 instances), and Hurink (30 instances from the vdata subset). The baseline dispatching rules are selected based on the comparative study by Doh et al. [59], which evaluated 36 combinations of job sequencing and machine assignment rules. Following their findings, three job sequencing rules—First-In-First-Out (FIFO), Most Operations Remaining (MOPNR), and Most Work Remaining (MWKR)—and two machine assignment rules—Shortest Processing Time (SPT) and Earliest End Time (EET)—are adopted. These rules are paired to form six dispatching heuristics (FIFO+EET, FIFO+SPT, MOPNR+EET, MOPNR+SPT, MWKR+EET, and MWKR+SPT) as the baseline methods. Since all six dispatching rules are deterministic methods, repeated runs produce identical scheduling results. Standard deviation values are not reported for these baseline methods in the experimental tables. Additionally, to evaluate its local refinement capability, HLS-FJSP is integrated with recent hybrid metaheuristics (e.g., HCPGA [26]) and reinforcement learning method [28]. In this hybrid setup, the schedules produced by these selected methods serve as initial solutions, from which HLS-FJSP searches for further optimization. Finally, we conduct comprehensive ablation studies and hyperparameter sensitivity analyses to assess the contributions of different algorithmic components and the influence of critical parameters.

Experimental Environment: The proposed HLS-FJSP and all baselines are implemented in C++20 and compiled using GCC 13.1.0 with a computing machine that is equipped with an Intel(R) Xeon(R) Gold 6130 CPU @ 2.10 GHz CPU and 1 TB memory. The operating system installed on that machine is Ubuntu 20.04.4 LTS. The source code of HLS-FJSP is available at https://github.com/chuan-luo-group/HLS_FJSP (accessed on 10 May 2026).

Performance Metrics: To evaluate the quality of the obtained scheduling solutions, we adopt the Percentage Deviation (PD), which quantifies the relative deviation of the obtained makespan ($C_{\max }$) from the best-known upper bound (UB), as defined in Equation (2). The makespan ($C_{\max }$) refers to the total time required to complete all scheduled jobs, and serves as a key objective in minimizing overall production time in FJSP. The UB corresponds to the makespan achieved by a benchmark method, following the approach in Behnke and Geiger [60]. A lower PD value indicates a better solution, with PD = 0% denoting that the algorithm matches the benchmark performance exactly.

$$PD={\displaystyle \frac{C_{max}-UB}{UB}}\times 100\%$$

(2)

where $C_{max}$ is the makespan and $UB$ refers to the best-known upper bound (makespan) for each instance, as reported by Behnke and Geiger (2012) [60].

Experimental Preliminaries: The proposed HLS-FJSP algorithm involves several key parameters, namely the search-mode control parameter $\alpha$, the random-search mode parameter $\beta$, the maximum iteration count $\delta$, the maximum repeat count of solutions r, the population size for the genetic algorithm $pn$, and the tabu list length (L). Based on preliminary tuning, the parameters are set as follows: $\alpha =0.5$, $\beta =0.5$, $r=100$, $\delta =30$, $pn=20$, $L=25$. These values are chosen to strike a balanced trade-off between exploration and exploitation. Specifically, $\alpha$ and $\beta$ are both set to 0.5 to enable a balanced and coordinated selection among greedy search, genetic algorithm, and tabu search. The repeat threshold $r=100$ is used to detect stagnation and trigger a strategy switch. The iteration limit $\delta =30$ together with a population size $pn=20$ ensures convergence while maintaining computational efficiency, and the tabu list length $L=25$ is sufficient to avoid short-term cycling without incurring excessive memory overhead. For each benchmark instance, the algorithm is run independently 10 times, and the average makespan and average runtime are reported. A standard deviation of 0.0 means that the same makespan was obtained in all runs. We set the maximum number of iterations to 1200 and the maximum time limit to 6000 s to ensure that a feasible solution can be obtained within an acceptable time frame under various experimental environments. In all experiments, the actual runtime never reached the time limit, and the actual number of iterations never reached the iteration limit.

5.2. Comparisons Against Dispatching Rules

5.2.1. Experiment 1

Our first group of experiments is conducted on the Brandimarte benchmark instances, which contains 10 generalized FJSP instances. The results are reported in

Table 1. HLS-FJSP’s results on Brandimarte instances.

Instance	Size	UB	FIFO+EET		FIFO+SPT		MOPNR+EET		MOPNR+SPT		MWKR+EET		MWKR+SPT		OURS
			Cmax	PD	Cmax	PD	Cmax	PD	Cmax	PD	Cmax	PD	Cmax	PD	Cmax	PD	Time
mk01	10 × 6	39	53	35.90%	68	74.36%	57	46.15%	64	64.10%	50	28.21%	65	66.67%	42.0 ± 0.0	7.69%	179.2 ± 13.3
mk02	10 × 6	26	39	50.00%	41	57.69%	41	57.69%	40	53.85%	40	53.85%	41	57.69%	32.3 ± 0.9	24.23%	422.7 ± 106.2
mk03	15 × 8	204	232	13.73%	338	65.69%	265	29.90%	330	61.76%	248	21.57%	330	61.76%	204.2 ± 0.6	0.10%	861.0 ± 162.7
mk04	15 × 8	60	96	60.00%	146	143.33%	96	60.00%	146	143.33%	113	88.33%	146	143.33%	72.8 ± 1.2	21.33%	420.1 ± 96.2
mk05	15 × 4	172	187	8.72%	289	68.02%	192	11.63%	289	68.02%	196	13.95%	289	68.02%	188.7 ± 3.7	9.71%	676.4 ± 173.7
mk06	15 × 10	58	108	86.21%	115	98.28%	115	98.28%	108	86.21%	111	91.38%	113	94.83%	85.9 ± 2.6	48.10%	1199.9 ± 67.4
mk07	5 × 20	139	212	52.52%	219	57.55%	217	56.12%	221	58.99%	215	54.68%	233	67.63%	159.0 ± 3.8	14.39%	748.4 ± 125.0
mk08	10 × 20	523	587	12.24%	608	16.25%	609	16.44%	639	22.18%	592	13.19%	609	16.44%	538.0 ± 6.4	2.87%	1175.6 ± 182.9
mk09	10 × 20	307	439	43.00%	510	66.12%	407	32.57%	505	64.50%	406	32.25%	505	64.50%	397.1 ± 8.2	29.35%	1435.7 ± 252.7
mk10	15 × 20	197	303	53.81%	404	105.08%	311	57.87%	438	122.34%	291	47.72%	453	129.95%	290.5 ± 5.8	47.46%	1812.2 ± 237.7

Note: “UB” is the best-known upper bound (makespan) for each instance from Behnke and Geiger (2012) [60]; “OURS” represents the proposed HLS-FJSP method.

and Figure 5.

HLS-FJSP obtains lower PD values than the six dispatching-rule baselines on most instances. Among the 10 instances, the PD values of Mk01, Mk03, Mk05, and Mk08 are below 10%. In particular, for Mk03, HLS-FJSP achieves a makespan of 204.2, which is close to the reported upper bound of 204. The average PD of HLS-FJSP is 20.52%, while the best baseline method, FIFO+EET, obtains an average PD of 41.61%. On Mk04, the PD of HLS-FJSP is 21.33%, whereas FIFO+EET and MOPNR+EET both obtain 60.00%. For larger instances, HLS-FJSP still shows lower PD values than the dispatching rules. On Mk06, the PD of HLS-FJSP is 48.10%, compared with 86.21–98.28% for the baseline methods. On Mk10, HLS-FJSP achieves a PD of 47.46%, which is lower than all six baselines. In some instances, dispatching rules produce very large deviations. For example, FIFO+SPT obtains a PD of 143.33% on Mk04, while HLS-FJSP keeps the PD at 21.33%. The results also show that the increase in PD of HLS-FJSP is relatively moderate as the problem scale becomes larger. From Mk01 to Mk10, the PD increases from 7.69% to 47.46%, while the PD of MWKR+SPT increases from 66.67% to 129.95%.

5.2.2. Experiment 2

The second set of experiments is conducted on the Barnes benchmark instances, which include 21 problem instances for the FJSP. The results are reported in

Table 2. HLS-FJSP’s results on Barnes instances.

Instance	Size	UB	FIFO+EET		FIFO+SPT		MOPNR+EET		MOPNR+SPT		MWKR+EET		MWKR+SPT		OURS
			Cmax	PD	Cmax	PD	Cmax	PD	Cmax	PD	Cmax	PD	Cmax	PD	Cmax	PD	Time
mt10c1	10×11	927	1520	63.97%	1520	63.97%	1319	42.29%	1319	42.29%	1239	33.66%	1289	39.05%	1115.3 ± 20.0	20.31%	918.9 ± 243.7
mt10cc	10 × 12	910	1359	49.34%	1520	67.03%	1245	36.81%	1319	44.95%	1121	23.19%	1289	41.65%	1074.2 ± 10.0	18.04%	1016.2 ± 286.8
mt10x	10 × 11	918	1305	42.16%	1520	65.58%	1275	38.89%	1319	43.68%	1253	36.49%	1289	40.41%	1104.5 ± 19.6	20.32%	1084.9 ± 269.0
mt10xx	10 × 12	918	1305	42.16%	1305	42.16%	1275	38.89%	1275	38.89%	1253	36.49%	1253	36.49%	1107.4 ± 18.2	20.63%	1048.3 ± 304.4
mt10xxx	10 × 13	918	1305	42.16%	1305	42.16%	1275	38.89%	1275	38.89%	1253	36.49%	1253	36.49%	1117.5 ± 15.1	21.73%	949.1 ± 228.7
mt10xy	10 × 12	905	1305	44.20%	1520	67.96%	1241	37.13%	1319	45.75%	1201	32.71%	1289	42.43%	1099.7 ± 17.8	21.51%	869.6 ± 230.8
mt10xyz	10 × 13	847	1159	36.84%	1520	79.46%	1226	44.75%	1319	55.73%	1111	31.17%	1289	52.18%	1015.3 ± 18.1	19.87%	1027.8 ± 216.9
setb4c9	15 × 11	914	1677	83.48%	1677	83.48%	1245	36.21%	1245	36.21%	1601	75.16%	1693	85.23%	1194.6 ± 9.6	30.70%	1552.6 ± 281.2
setb4cc	15 × 12	909	1613	77.45%	1677	84.49%	1245	36.96%	1245	36.96%	1544	69.86%	1693	86.25%	1163.9 ± 17.7	28.04%	1462.7 ± 274.2
setb4x	15 × 11	925	1677	81.30%	1677	81.30%	1245	34.59%	1245	34.59%	1664	79.89%	1693	83.03%	1192.9 ± 25.8	28.96%	1505.6 ± 330.7
setb4xx	15 × 12	925	1677	81.30%	1677	81.30%	1245	34.59%	1245	34.59%	1664	79.89%	1664	79.89%	1190.6 ± 14.8	28.71%	1504.1 ± 299.4
setb4xxx	15 × 13	925	1677	81.30%	1677	81.30%	1245	34.59%	1245	34.59%	1664	79.89%	1664	79.89%	1189.2 ± 20.3	28.56%	1342.5 ± 177.8
setb4xy	15 × 12	916	1526	66.59%	1677	83.08%	1225	33.73%	1245	35.92%	1664	81.66%	1693	84.83%	1160.1 ± 23.7	26.65%	1426.5 ± 284.0
setb4xyz	15 × 13	905	1395	54.14%	1677	85.30%	1225	35.36%	1245	37.57%	1664	83.87%	1693	87.07%	1130.0 ± 29.9	24.86%	1396.7 ± 292.4
seti5c12	15 × 16	1174	1822	55.20%	1822	55.20%	1686	43.61%	1728	47.19%	1953	66.35%	1977	68.40%	1613.3 ± 24.0	37.42%	1950.7 ± 165.3
seti5cc	15 × 17	1136	1801	58.54%	1822	60.39%	1623	42.87%	1728	52.11%	1767	55.55%	1977	74.03%	1552.7 ± 36.4	36.68%	2056.9 ± 251.7
seti5x	15 × 16	1201	1801	49.96%	1822	51.71%	1728	43.88%	1728	43.88%	1791	49.13%	1977	64.61%	1624.7 ± 21.1	35.28%	1923.8 ± 184.5
seti5xx	15 × 17	1199	1801	50.21%	1801	50.21%	1728	44.12%	1728	44.12%	1755	46.37%	1791	49.37%	1605.8 ± 27.6	33.93%	1965.9 ± 277.7
seti5xxx	15 × 18	1197	1801	50.46%	1801	50.46%	1728	44.36%	1728	44.36%	1755	46.62%	1755	46.62%	1600.9 ± 32.3	33.74%	1866.1 ± 161.4
seti5xy	15 × 17	1136	1801	58.54%	1822	60.39%	1623	42.87%	1728	52.11%	1767	55.55%	1977	74.03%	1563.6 ± 24.2	37.64%	2045.6 ± 233.2
seti5xyz	15 × 18	1125	1801	60.09%	1822	61.96%	1557	38.40%	1728	53.60%	1767	57.07%	1977	75.73%	1549.7 ± 31.5	37.75%	1998.8 ± 244.0

Note: “UB” is the best-known upper bound (makespan) for each instance from Behnke and Geiger (2012) [60]; “OURS” represents the proposed HLS-FJSP method.

and Figure 6.

HLS-FJSP obtains lower PD values than the six dispatching-rule baselines on most instances. On average, it achieves a PD of 28.16%, compared with 39.23% for the best baseline, MOPNR+EET. On instance setb4cc, HLS-FJSP attains a PD of 28.04%, while MOPNR+EET and MOPNR+SPT both reach 36.96%. The PD of HLS-FJSP increases moderately with problem size. On the small-scale instance mt10c1, the PD is 20.31%, rising to 37.75% for the larger instance seti5xyz (18 jobs and 15 machines). By contrast, MWKR+SPT rises from 39.05% to 75.73% across the same instances. Within the seti5 family, HLS-FJSP’s PD increases by only 0.33 points (from 37.42% to 37.75%) as the job count increases from 16 to 18, whereas MWKR+SPT increases by 7.33 points (from 68.40% to 75.73%). HLS-FJSP attains the lowest PD among the six baselines on all 21 instances. For instance setb4c9, HLS-FJSP reaches a PD of 30.70%, compared with 36.21% for the best baseline MOPNR+EET and 85.23% for MWKR+SPT.

5.2.3. Experiment 3

The third set of experiments is conducted on the Dauzère benchmark instances, which are more difficult generalized FJSP instances. The results are reported in

Table 3. HLS-FJSP’s results on Dauzère instances.

Instance	Size	UB	FIFO+EET		FIFO+SPT		MOPNR+EET		MOPNR+SPT		MWKR+EET		MWKR+SPT		OURS
			Cmax	PD	Cmax	PD	Cmax	PD	Cmax	PD	Cmax	PD	Cmax	PD	Cmax	PD	Time
01a	10 × 5	2518	3586	42.41%	3763	49.44%	3633	44.28%	3606	43.21%	3505	39.20%	3470	37.81%	3162.7 ± 50.4	25.60%	1417.2 ± 448.1
02a	10 × 5	2231	3321	48.86%	3560	59.57%	3024	35.54%	3745	67.86%	2941	31.82%	3975	78.17%	2903.2 ± 103.7	30.13%	1582.1 ± 244.4
03a	10 × 5	2229	2572	15.39%	3163	41.90%	2494	11.89%	3439	54.28%	2573	15.43%	3153	41.45%	2776.9 ± 101.2	24.58%	2051.3 ± 246.0
04a	10 × 5	2503	3393	35.56%	3423	36.76%	3591	43.47%	3685	47.22%	3404	36.00%	3318	32.56%	3157.6 ± 28.8	26.15%	1367.9 ± 408.7
05a	10 × 5	2216	3012	35.92%	3377	52.39%	3063	38.22%	3571	61.15%	2900	30.87%	3223	45.44%	2820.6 ± 47.5	27.28%	1815.9 ± 220.7
06a	10 × 5	2196	2522	14.85%	3561	62.16%	2541	15.71%	3546	61.48%	2574	17.21%	3520	60.29%	2712.6 ± 93.9	23.52%	2066.5 ± 336.6
07a	15 × 8	2283	3618	58.48%	3944	72.76%	3348	46.65%	3357	47.04%	3719	62.90%	3916	71.53%	3298.7 ± 71.4	44.49%	2121.3 ± 265.1
08a	15 × 8	2069	2808	35.72%	3289	58.97%	2747	32.77%	3144	51.96%	3121	50.85%	3657	76.75%	2994.3 ± 64.9	44.72%	3354.2 ± 425.3
09a	15 × 8	2066	2351	13.79%	2842	37.56%	2367	14.57%	2927	41.67%	2460	19.07%	3042	47.24%	2801.4 ± 180.4	35.60%	4420.2 ± 404.5
10a	15 × 8	2291	3596	56.96%	3778	64.91%	3329	45.31%	3394	48.14%	3500	52.77%	3780	64.99%	3330.9 ± 42.6	45.39%	2374.6 ± 598.0
11a	15 × 8	2063	2799	35.68%	3510	70.14%	2545	23.36%	3497	69.51%	2890	40.09%	3544	71.79%	2975.4 ± 81.2	44.23%	3263.6 ± 313.5
12a	15 × 8	2030	2365	16.50%	3567	75.71%	2399	18.18%	3021	48.82%	2373	16.90%	3403	67.64%	2692.0 ± 88.4	32.61%	4593.3 ± 613.5
13a	20 × 10	2257	3376	49.58%	3710	64.38%	3450	52.86%	3596	59.33%	3582	58.71%	3720	64.82%	3484.9 ± 44.6	54.40%	3338.0 ± 856.9
14a	20 × 10	2167	2622	21.00%	3303	52.42%	2781	28.33%	3371	55.56%	2750	26.90%	3382	56.07%	3216.8 ± 109.0	48.44%	5394.7 ± 396.1
15a	20 × 10	2165	2339	8.04%	2775	28.18%	2425	12.01%	2745	26.79%	2375	9.70%	2719	25.59%	2894.7 ± 137.5	33.70%	6023.1 ± 25.0
16a	20 × 10	2255	3366	49.27%	3680	63.19%	3441	52.59%	3424	51.84%	3656	62.13%	3660	62.31%	3421.1 ± 64.0	51.71%	3477.8 ± 615.3
17a	20 × 10	2140	2587	20.89%	3804	77.76%	2782	30.00%	3990	86.45%	2658	24.21%	4056	89.53%	3086.0 ± 101.5	44.21%	5484.3 ± 656.7
18a	20 × 10	2127	2326	9.36%	3535	66.20%	2432	14.34%	3370	58.44%	2465	15.89%	3443	61.87%	2876.4 ± 126.1	35.23%	6012.4 ± 10.9

Note: “UB” is the best-known upper bound (makespan) for each instance from Behnke and Geiger (2012) [60]; “OURS” represents the proposed HLS-FJSP method.

and Figure 7.

HLS-FJSP achieves an average PD of 37.33% over the 18 instances. The average PDs of MOPNR+EET and FIFO+EET are 31.12% and 31.57%, respectively, while FIFO+SPT, MOPNR+SPT, and MWKR+SPT have average PD values of 57.41%, 54.49%, and 58.66%. HLS-FJSP achieves the best PD values on five instances: 01a, 02a, 04a, 05a, and 07a. HLS-FJSP has a PD standard deviation of 9.71%, which is lower than those of MOPNR+EET (14.02%) and MWKR+SPT (18.61%). In instance 17a, MWKR+SPT and MOPNR+SPT obtain PD values of 89.53% and 86.45%, respectively, while HLS-FJSP obtains 44.21%. On instance 15a, FIFO+EET achieves a PD of 8.04%, whereas HLS-FJSP obtains 33.70%. As the problem scale increases, the average PD of HLS-FJSP increases from 26.21% on instances 01a–06a to 41.17% on instances 07a–12a and 44.62% on instances 13a–18a. By comparison, MWKR+SPT shows larger fluctuations across different instance groups. The PD values of HLS-FJSP remain relatively stable across all instances.

5.2.4. Experiment 4

The fourth set of experiments is conducted on the Hurink benchmark instances. The results are reported in

Table 4. HLS-FJSP’s results on Hurink instances.

Instance	Size	UB	FIFO+EET		FIFO+SPT		MOPNR+EET		MOPNR+SPT		MWKR+EET		MWKR+SPT		OURS
			Cmax	PD	Cmax	PD	Cmax	PD	Cmax	PD	Cmax	PD	Cmax	PD	Cmax	PD	Time
vdata-la01	10 × 5	570	740	29.82%	845	48.25%	638	11.93%	856	50.18%	707	24.04%	756	32.63%	625.1 ± 13.5	9.67%	219.4 ± 64.8
vdata-la02	10 × 5	529	626	18.34%	960	81.47%	650	22.87%	752	42.16%	688	30.06%	756	42.91%	583.0 ± 15.5	10.21%	225.6 ± 90.1
vdata-la03	10 × 5	477	616	29.14%	850	78.20%	577	20.96%	745	56.18%	606	27.04%	772	61.84%	535.5 ± 13.3	12.26%	188.7 ± 56.9
vdata-la04	10 × 5	502	625	24.50%	746	48.61%	601	19.72%	763	51.99%	706	40.64%	810	61.35%	567.1 ± 12.9	12.97%	183.5 ± 77.5
vdata-la05	10 × 5	457	681	49.02%	877	91.90%	568	24.29%	648	41.79%	570	24.73%	815	78.34%	518.7 ± 6.9	13.50%	172.4 ± 58.3
vdata-la06	15 × 5	799	894	11.89%	1347	68.59%	837	4.76%	1089	36.30%	838	4.88%	1047	31.04%	853.4 ± 17.2	6.81%	369.4 ± 81.5
vdata-la07	15 × 5	749	829	10.68%	1033	37.92%	807	7.74%	1071	42.99%	867	15.75%	1028	37.25%	824.9 ± 19.0	10.13%	306.9 ± 83.9
vdata-la08	15 × 5	765	878	14.77%	1085	41.83%	837	9.41%	1035	35.29%	993	29.80%	1285	67.97%	823.7 ± 13.1	7.67%	386.2 ± 106.1
vdata-la09	15 × 5	853	921	7.97%	1213	42.20%	907	6.33%	1149	34.70%	895	4.92%	1054	23.56%	899.9 ± 26.3	5.50%	337.8 ± 73.2
vdata-la10	15 × 5	804	970	20.65%	1128	40.30%	880	9.45%	1089	35.45%	964	19.90%	1130	40.55%	860.7 ± 19.0	7.05%	337.8 ± 60.6
vdata-la11	20 × 5	1071	1149	7.28%	1780	66.20%	1127	5.23%	1615	50.79%	1263	17.93%	1669	55.84%	1128.1 ± 17.0	5.33%	486.7 ± 74.6
vdata-la12	20 × 5	936	1104	17.95%	1321	41.13%	980	4.70%	1250	33.55%	1082	15.60%	1373	46.69%	984.2 ± 18.9	5.15%	493.8 ± 87.2
vdata-la13	20 × 5	1038	1119	7.80%	1386	33.53%	1063	2.41%	1389	33.82%	1150	10.79%	1412	36.03%	1099.8 ± 21.5	5.95%	487.7 ± 79.1
vdata-la14	20 × 5	1070	1265	18.22%	1529	42.90%	1166	8.97%	1431	33.74%	1189	11.12%	1612	50.65%	1118.9 ± 24.4	4.57%	519.4 ± 101.3
vdata-la15	20 × 5	1089	1195	9.73%	1491	36.91%	1130	3.76%	1381	26.81%	1194	9.64%	1537	41.14%	1138.3 ± 28.0	4.53%	513.1 ± 94.63
vdata-la16	10 × 10	717	820	14.37%	945	31.80%	865	20.64%	834	16.32%	902	25.80%	948	32.22%	853.7 ± 51.9	19.07%	650.2 ± 119.6
vdata-la17	10 × 10	646	760	17.65%	793	22.76%	694	7.43%	760	17.65%	726	12.38%	805	24.61%	738.3 ± 44.2	14.29%	566.4 ± 119.7
vdata-la18	10 × 10	663	765	15.38%	814	22.78%	799	20.51%	825	24.43%	801	20.81%	880	32.73%	830.0 ± 51.6	25.19%	594.9 ± 74.3
vdata-la19	10 × 10	617	731	18.48%	849	37.60%	826	33.87%	841	36.30%	746	20.91%	980	58.83%	855.2 ± 30.7	38.61%	607.8 ± 92.3
vdata-la20	10 × 10	756	869	14.95%	981	29.76%	818	8.20%	894	18.25%	805	6.48%	902	19.31%	879.1 ± 62.8	16.28%	637.0 ± 76.1
vdata-la21	15 × 10	806	992	23.08%	1176	45.91%	961	19.23%	1051	30.40%	1000	24.07%	1179	46.28%	1142.2 ± 44.9	41.71%	1007.3 ± 120.3
vdata-la22	15 × 10	739	920	24.49%	1033	39.78%	898	21.52%	1040	40.73%	928	25.58%	1070	44.79%	1006.5 ± 33.3	36.20%	988.3 ± 161.0
vdata-la23	15 × 10	815	986	20.98%	1170	43.56%	954	17.06%	1066	30.80%	971	19.14%	1110	36.20%	1125.7 ± 56.7	38.12%	1015.3 ± 188.3
vdata-la24	15 × 10	777	992	27.67%	1083	39.38%	902	16.09%	1065	37.07%	1004	29.21%	1085	39.64%	1040.9 ± 56.3	33.96%	1000.7 ± 131.6
vdata-la25	15 × 10	756	983	30.03%	1136	50.26%	872	15.34%	987	30.56%	1013	33.99%	1132	49.74%	1058.6 ± 71.1	40.03%	989.2 ± 136.2
vdata-la26	20 × 10	1054	1181	12.05%	1370	29.98%	1119	6.17%	1243	17.93%	1224	16.13%	1425	35.20%	1323.5 ± 73.3	25.57%	1565.7 ± 331.0
vdata-la27	20 × 10	1085	1196	10.23%	1353	24.70%	1163	7.19%	1295	19.35%	1211	11.61%	1371	26.36%	1399.0 ± 45.9	28.94%	1412.8 ± 195.5
vdata-la28	20 × 10	1070	1245	16.36%	1482	38.50%	1173	9.63%	1286	20.19%	1324	23.74%	1493	39.53%	1419.6 ± 61.6	32.67%	1374.4 ± 155.5
vdata-la29	20 × 10	994	1171	17.81%	1384	39.24%	1111	11.77%	1189	19.62%	1244	25.15%	1428	43.66%	1298.4 ± 46.5	30.62%	1431.0 ± 242.5
vdata-la30	20 × 10	1069	1232	15.25%	1381	29.19%	1170	9.45%	1380	29.09%	1312	22.73%	1483	38.73%	1385.3 ± 45.0	29.59%	1491.6 ± 290.9

Note: “UB” is the best-known upper bound (makespan) for each instance from Behnke and Geiger (2012) [60]; “OURS” represents the proposed HLS-FJSP method.

and Figure 8.

HLS-FJSP achieves an average PD of 19.07%, which is lower than those of MWKR+EET (20.15%), MOPNR+SPT (33.15%), FIFO+SPT (44.17%), and MWKR+SPT (42.52%). On the five-machine instances (la01–la15), HLS-FJSP achieves an average PD of 8.09%, compared with 10.84% for MOPNR+EET. Across the 30 instances, the maximum PD of HLS-FJSP is 41.71% on la21. By comparison, FIFO+SPT reaches 91.90% on la05, MWKR+SPT reaches 78.34% on la05, and MOPNR+SPT reaches 56.18% on la03. The standard deviation of the PD values of HLS-FJSP is 12.6%, which is lower than FIFO+SPT (18.9%) and MWKR+SPT (14.1%). On the five-machine instances, the PD values of HLS-FJSP remain relatively stable as the number of jobs increases. For example, the PD is 13.50% on la05 and 4.53% on la15. On the 10-machine instances (la16–la30), the average PD of HLS-FJSP increases to 30.06%. Although this is higher than MOPNR+EET (14.94%) and FIFO+EET (19.94%), it remains lower than the other four baselines.

5.3. Comparisons Against NSGA-II

A comparison between HLS-FJSP and NSGA-II was carried out on the Brandimarte benchmark instances to evaluate the performance of the proposed method. Since no public NSGA-II implementation for FJSP was available, we implemented NSGA-II in Python 3.10. In the experiments, the crossover probability and mutation probability of NSGA-II were set to 0.8 and 0.3, respectively. The population size was 200, and the maximum number of generations was 1200. For the GA component in HLS-FJSP, the same crossover and mutation probabilities were used, while the population size was set to 20. Because HLS-FJSP also includes greedy search and tabu search, the number of iterations in each GA stage was set to 30. The comparison results on the Brandimarte instances are listed in

Table 5. NSGA-II and HLS-FJSP’s results on Brandimarte instances (average of 10 runs).

Instance	Size	UB	NSGA-II			OURS
			Cmax	PD	Time	Cmax	PD	Time
Mk01	10 × 6	39	44.5±1.1	14.10%	256.1 ± 20.5	42.0 ± 0.0	7.69%	179.2 ± 13.3
Mk02	10 × 6	26	35.1 ± 1.2	35.00%	248.6 ± 5.8	32.3 ± 0.9	24.23%	422.7 ± 106.2
Mk03	15 × 8	204	221.0 ± 3.3	8.33%	297.5 ± 30.1	204.2 ± 0.6	0.10%	861.0 ± 162.7
Mk04	15 × 8	60	83.1 ± 1.4	38.50%	269.0 ± 3.8	72.8 ± 1.2	21.33%	420.1 ± 96.2
Mk05	15 × 4	172	201.9 ± 2.6	17.38%	292.3 ± 42.8	188.7 ± 3.7	9.71%	676.4 ± 173.7
Mk06	15 × 10	58	102.1 ± 4.0	76.03%	258.7 ± 1.6	85.9 ± 2.6	48.10%	1199.9 ± 67.4
Mk07	5 × 20	139	171.9 ± 2.3	23.67%	281.9 ± 13.6	159.0 ± 3.8	14.39%	748.4 ± 125.0
Mk08	10 × 20	523	587.8 ± 10.3	12.39%	352.7 ± 17.9	538.0 ± 6.4	2.87%	1175.6 ± 182.9
Mk09	10 × 20	307	458.8 ± 12.8	49.45%	390.5 ± 43.8	397.1 ± 8.2	29.35%	1435.7 ± 252.7
Mk10	15 × 20	197	377.1 ± 8.9	91.42%	369.9 ± 23.2	290.5 ± 5.8	47.46%	1812.2 ± 237.7

Note: “UB” is the best-known upper bound (makespan) for each instance from Behnke and Geiger (2012) [60]; “OURS” represents the proposed HLS-FJSP method.

.

Table 5 shows that HLS-FJSP obtains lower makespan values than NSGA-II on all ten Brandimarte instances. The gap is especially clear on several medium and large-scale instances. On Mk03, the makespan obtained by HLS-FJSP is 204.2, which is very close to the best-known upper bound of 204 (PD = 0.10%), while the PD of NSGA-II is 8.33%. On Mk10, the PD is reduced from 91.42% with NSGA-II to 47.46% with HLS-FJSP. Similar improvements can also be observed on Mk06 and Mk09, where the PD decreases from 76.03% to 48.10% and from 49.45% to 29.35%, respectively. Compared with NSGA-II, the additional local search procedures in HLS-FJSP help further improve the solutions during the search process. In terms of runtime, NSGA-II is generally faster on most instances. However, the runtime difference remains within an acceptable range, and HLS-FJSP is even faster on Mk01 (179.2s compared with 256.1s). Overall, the results indicate that HLS-FJSP can obtain better scheduling results, especially on more difficult instances.

5.4. Further Optimization of HCPGA Solutions

We further compare HLS-FJSP with the hybrid method HCPGA [26] on the Brandimarte benchmark instances. This experiment is designed to evaluate the refinement capability of HLS-FJSP on high-quality initial schedules. In this experiment, we develop an approach dubbed HCPGA+OURS, which operates as follows. First, HCPGA is executed, and then the solution obtained by HCPGA is used as the initial solution for our HLS-FJSP algorithm for further optimization. For each run of HCPGA+OURS, the cutoff time is set to 6000 s; consequently, the running time available to our HLS-FJSP algorithm is 6000 s minus the actual runtime of HCPGA. Additionally, during the execution of HCPGA within HCPGA+OURS, the process of HCPGA terminates if the makespan shows no improvement for 300 consecutive generations, following the literature [26]. The remaining experimental settings are identical to those described in the Section 5.1, and the results are summarized in

Table 6. HCPGA and HLS-FJSP’s results on Brandimarte instances (average of 10 runs).

Instance	Size	UB	HCPGA			HCPGA+OURS
			Cmax	PD	Time	Cmax	PD	Time
Mk01	10 × 6	39	51.3 ± 4.2	31.54%	3.2 ± 3.2	42.0 ± 0.0	7.69%	53.4 ± 5.5
Mk02	10 × 6	26	26.0 ± 0.0	0.00%	1112.5 ± 19.1	26.0 ± 0.0	0.00%	1235.7 ± 31.2
Mk03	15 × 8	204	284.1 ± 25.3	39.26%	93.4 ± 112.7	204.0 ± 0.0	0.00%	389.4 ± 110.3
Mk04	15 × 8	60	90.0 ± 9.4	50.00%	19.2 ± 15.0	71.9 ± 2.2	19.83%	148.9 ± 35.1
Mk05	15 × 4	172	173.0 ± 0.8	0.58%	1128.0 ± 19.0	173.0 ± 0.8	0.58%	1279.6 ± 23.4
Mk06	15 × 10	58	60.3 ± 0.7	3.97%	1139.0 ± 17.2	60.3 ± 0.7	3.97%	1553.8 ± 54.3
Mk07	5 × 20	139	143.1 ± 2.3	2.95%	1126.9 ± 16.7	143.0 ± 2.1	2.88%	1308.0 ± 39.7
Mk08	10 × 20	523	549.1 ± 16.7	4.99%	70.6 ± 113.7	535.6 ± 8.8	2.41%	423.4 ± 127.5
Mk09	10 × 20	307	350.5 ± 16.6	14.17%	634.2 ± 754.6	350.1 ± 16.2	14.04%	1084.9 ± 736.6
Mk10	15 × 20	197	230.3 ± 6.5	16.90%	1167.5 ± 12.5	230.3 ± 6.5	16.90%	1704.7 ± 103.4

Note: “UB” is the best-known upper bound (makespan) for each instance from Behnke and Geiger (2012) [60]; “OURS” represents the proposed HLS-FJSP method; “HCPGA+OURS” denotes the hybrid approach where the schedules obtained by HCPGA are utilized as the initial solutions and further optimized by HLS-FJSP.

.

Table 6 shows the results obtained after applying HLS-FJSP to the schedules generated by HCPGA. On several instances, HLS-FJSP further reduces the makespan. For example, on Mk01, the PD decreases from 31.54% to 7.69%. On Mk03, the makespan is reduced from 284.1 to 204.0, which reaches the best-known upper bound. Improvements can also be observed on Mk04 and Mk08, where the PD decreases from 50.00% to 19.83% and from 4.99% to 2.41%, respectively. However, for four instances (i.e., Mk02, Mk05, Mk06, and Mk10), our algorithm did not further improve the solutions; therefore, it is not surprising that the solutions returned by HCPGA and HCPGA+OURS remain identical.

5.5. Further Optimization of DRL-S Solutions

We also compare HLS-FJSP with the DRL-based scheduling method DRL-S [28] on the Brandimarte benchmark instances. This experiment is designed to evaluate the refinement capability of our proposed method. In this experiment, we develop an approach dubbed DRL-S+OURS, which operates as follows. First, following the literature [28], DRL-S+OURS activates DRL-S to sample 100 candidate solutions. The solution with the minimum makespan is then selected as the initial solution for our HLS-FJSP algorithm for further optimization. For each run of DRL-S+OURS, the cutoff time is set to 6000 s; thus, the running time available to our HLS-FJSP algorithm is 6000 s minus the actual runtime of DRL-S. The remaining experimental settings are identical to those described in the Section 5.1, and the corresponding results are summarized in

Table 7. DRL-S and HLS-FJSP’s results on Brandimarte instances (average of 10 runs).

Instance	Size	UB	DRL-S			DRL-S+OURS
			Cmax	PD	Time	Cmax	PD	Time
Mk01	10 × 6	39	42.0 ± 0.0	7.69%	1.3 ± 0.1	42.0 ± 0.0	7.69%	48.8 ± 4.5
Mk02	10 × 6	26	35.8 ± 0.6	37.69%	1.2 ± 0.1	32.7 ± 0.5	25.77%	123.6 ± 27.4
Mk03	15 × 8	204	204.0 ± 0.0	0.00%	3.7 ± 0.2	204.0 ± 0.0	0.00%	181.6 ± 45.1
Mk04	15 × 8	60	70.0 ± 1.6	16.67%	2.1 ± 0.2	69.8 ± 1.5	16.33%	104.0 ± 14.2
Mk05	15 × 4	172	181.4 ± 1.9	5.47%	2.4 ± 0.2	181.4 ± 1.9	5.47%	138.7 ± 21.5
Mk06	15 × 10	58	89.2 ± 2.4	53.79%	3.7 ± 0.2	87.3 ± 3.2	50.52%	370.9 ± 75.4
Mk07	5 × 20	139	190.8 ± 2.5	37.27%	2.1 ± 0.1	157.6 ± 2.7	13.38%	236.7 ± 49.9
Mk08	10 × 20	523	523.0 ± 0.0	0.00%	6.3 ± 0.3	523.0 ± 0.0	0.00%	298.5 ± 22.7
Mk09	10 × 20	307	319.5 ± 2.9	4.07%	6.8 ± 0.3	319.5 ± 2.9	4.07%	427.9 ± 70.3
Mk10	15 × 20	197	254.1 ± 1.6	28.98%	6.7 ± 0.3	254.1 ± 1.6	28.98%	448.7 ± 43.5

Note: “UB” is the best-known upper bound (makespan) for each instance from Behnke and Geiger (2012) [60]; “OURS” represents the proposed HLS-FJSP method; “DRL-S+OURS” denotes the hybrid approach where the schedules obtained by DRL-S are utilized as the initial solutions and further optimized by HLS-FJSP.

.

Table 7 reports the results of applying HLS-FJSP to further refine schedules produced by the DRL-based method DRL-S. HLS-FJSP improves the makespan on four instances: on Mk02, the mean makespan is reduced from 35.8 to 32.7 (PD from 37.69% to 25.77%); on Mk04, from 70.0 to 69.8 (PD from 16.67% to 16.33%); on Mk06, from 89.2 to 87.3 (PD from 53.79% to 50.52%); and on Mk07, from 190.8 to 157.6 (PD from 37.27% to 13.38%). On the remaining six instances (i.e., Mk01, Mk03, Mk05, Mk08, Mk09, and Mk10), our algorithm did not further improve the solutions; therefore, it is not surprising that the solutions returned by DRL-S and DRL-S+OURS remain identical.

5.6. Effectiveness of Each Core Technique

5.6.1. Single-Strategy Variants

To further assess the contribution of each individual search strategy, we compare the full HLS-FJSP with three single-strategy variants that exclusively rely on one component: HLS-GS (Greedy Search only), HLS-GA (Genetic Algorithm only), and HLS-TS (Tabu Search only). All variants are configured with the same parameter settings as the complete HLS-FJSP, and the resulting makespan and runtime on the Brandimarte benchmark set are summarized in

Table 8. Single-strategy variants and HLS-FJSP’s results on Brandimarte instances (average of 10 runs).

Instance	Size	UB	HLS-GS		HLS-GA		HLS-TS		OURS
			Cmax	Time	Cmax	Time	Cmax	Time	Cmax	Time
Mk01	10 × 6	39	98.0 ± 0.0	1.2 ± 0.4	42.0 ± 0.0	180.1 ± 14.7	77.0+0.0	275.4 ± 16.0	42.0 ± 0.0	179.2 ± 13.3
Mk02	10 × 6	26	88.0 ± 0.0	12.4 ± 1.8	32.3 ± 0.7	402.0 ± 101.4	63.0 ± 0.0	369.6 ± 28.7	32.3 ± 0.9	422.7 ± 106.2
Mk03	15 × 8	204	617.0 ± 0.0	108.9 ± 7.8	204.0 ± 0.0	882.7 ± 246.5	516.0 ± 0.0	1861.8 ± 32.1	204.2 ± 0.6	861.0 ± 162.7
Mk04	15 × 8	60	246.0 ± 0.0	7.9 ± 1.5	72.5 ± 1.0	556.9 ± 113.6	164.0 ± 0.0	546.2 ± 41.7	72.8 ± 1.2	420.1 ± 96.2
Mk05	15 × 4	172	455.0 ± 0.0	9.0 ± 1.9	190.7 ± 1.6	627.9 ± 160.0	406.0 ± 0.0	845.0 ± 38.6	188.7 ± 3.7	676.4 ± 173.7
Mk06	15 × 10	58	459.0 ± 0.0	14.7 ± 1.8	88.8 ± 1.1	905.9 ± 202.4	222.0 ± 0.0	2637.1 ± 27.9	85.9 ± 2.6	1199.9 ± 67.4
Mk07	5 × 20	139	645.0 ± 0.0	2.9 ± 1.0	163.4 ± 2.0	551.5 ± 95.7	309.0 ± 0.0	801.6 ± 40.0	159.0 ± 3.8	748.4 ± 125.0
Mk08	10 × 20	523	2133.0 ± 0.0	14.6 ± 1.8	541.6 ± 1.9	1209.2 ± 218.9	1961.0 ± 0.0	3521.9 ± 122.5	538.0 ± 6.4	1175.6 ± 182.9
Mk09	10 × 20	307	1772.0 ± 0.0	71.0 ± 2.8	400.9 ± 6.7	1271.8 ± 205.3	1396.0 ± 0.0	4435.4 ± 80.7	397.1 ± 8.2	1435.7 ± 252.7
Mk10	15 × 20	197	1310.0 ± 0.0	278.1 ± 10.8	317.0 ± 6.8	1300.2 ± 262.7	944.0 ± 0.0	4366.0 ± 91.9	290.5 ± 5.8	1812.2 ± 237.7

Note: “UB” is the best-known upper bound (makespan) for each instance from Behnke and Geiger (2012) [60]; “OURS” represents the proposed HLS-FJSP method.

.

Running greedy search alone (HLS-GS) leads to poor results on most instances. On Mk08, the makespan reaches 2133, while the upper bound is 523. A similar result can be observed on Mk10, where the makespan is 1310 compared with the upper bound of 197. However, GS requires very little computation time and usually finishes within several seconds. The results show that greedy search alone converges quickly but is difficult to improve further once the search becomes trapped in a local region.

Using only the genetic algorithm (HLS-GA) produces much better schedules than HLS-GS and HLS-TS. On Mk03, the makespan reaches 204.0, which is very close to the upper bound of 204. On Mk06, the makespan is reduced to 88.8. However, compared with the complete HLS-FJSP framework, there is still a noticeable gap on several larger instances. For example, the makespan on Mk08 is 541.6 for HLS-GA and 538.0 for HLS-FJSP, while on Mk10 the results are 317.0 and 290.5, respectively. This suggests that GA can maintain population diversity during the search, but additional local improvement is still necessary on more difficult instances.

When tabu search is used alone (HLS-TS), both the solution quality and runtime become unsatisfactory on most instances. On Mk08 and Mk10, the makespan values reach 1961 and 944, respectively. The runtime is also much longer than that of the complete HLS-FJSP framework. For example, on Mk09, HLS-TS requires 4435.4s, whereas HLS-FJSP finishes in 1435.7s and obtains a much smaller makespan. These results indicate that tabu search alone spends excessive time exploring limited neighborhoods and is difficult to guide efficiently without other search strategies.

The experimental results show that the three search strategies play different roles in HLS-FJSP. GA mainly supports global search, GS improves solutions quickly in local regions, and TS is used when the search becomes stagnant. Combining these strategies helps maintain both search efficiency and solution quality on different FJSP instances.

5.6.2. Dual-Strategy Variants

As described in the Section 4, HLS-FJSP combines greedy search (GS), genetic algorithm (GA), and tabu search (TS) during the search process. Different search strategies are selected according to the current search state instead of using a fixed search order. To analyze the role of each strategy, three reduced versions of HLS-FJSP are tested: HLS-GSGA without tabu search, HLS-GSTS without the genetic algorithm, and HLS-GATS without greedy search. The parameter settings are the same as those used in HLS-FJSP. Each benchmark instance is run independently 10 times. The makespan and runtime results on the Brandimarte benchmark are listed in

Table 9. Dual-strategy variants and HLS-FJSP’s results on Brandimarte instances (average of 10 runs).

Instance	Size	UB	HLS-GSTS		HLS-GATS		HLS-GSGA		OURS
			Cmax	Time	Cmax	Time	Cmax	Time	Cmax	Time
Mk01	10 × 6	39	77.0 ± 0.0	112.9 ± 17.9	42.0 ± 0.0	201.7 ± 18.9	42.0 ± 0.0	202.1 ± 8.3	42.0 ± 0.0	179.2 ± 13.3
Mk02	10 × 6	26	62.5 ± 0.5	187.7 ± 19.6	31.8 ± 0.8	540.5 ± 137.1	32.1 ± 0.6	408.3 ± 59.7	32.3 ± 0.9	422.7 ± 106.2
Mk03	15 × 8	204	516.0 ± 0.0	977.8 ± 29.2	204.0 ± 0.0	831.8 ± 182.9	204.1 ± 0.3	889.6 ± 135.0	204.2 ± 0.6	861.0 ± 162.7
Mk04	15 × 8	60	162.5 ± 1.6	247.7 ± 29.9	73.1 ± 0.7	530.8 ± 98.1	72.8 ± 1.7	559.0 ± 144.4	72.8 ± 1.2	420.1 ± 96.2
Mk05	15 × 4	172	405.5 ± 0.5	411.3 ± 32.8	189.1 ± 1.9	777.9 ± 131.9	189.0 ± 2.8	591.5 ± 85.2	188.7 ± 3.7	676.4 ± 173.7
Mk06	15 × 10	58	222.0 ± 0.0	1458.3 ± 36.2	83.9 ± 2.3	1515.5 ± 220.9	87.8+1.7	975.6 ± 171.8	85.9 ± 2.6	1199.9 ± 67.4
Mk07	5 × 20	139	308.6 ± 0.8	371.1 ± 39.7	158.1 ± 3.3	1007.1 ± 262.8	161.2 ± 2.8	659.0 ± 120.3	159.0 ± 3.8	748.4 ± 125.0
Mk08	10 × 20	523	1961.0 ± 0.0	1974.9 ± 24.6	540.9 ± 3.8	1634.6 ± 347.2	539.5 ± 5.2	1238.4 ± 239.9	538.0 ± 6.4	1175.6 ± 182.9
Mk09	10 × 20	307	1396.0 ± 0.0	2695.2 ± 37.2	402.3 ± 6.5	1853.2 ± 319.2	400.1 ± 5.5	1416.5 ± 347.7	397.1 ± 8.2	1435.7 ± 252.7
Mk10	15 × 20	197	944.3 ± 1.0	2651.1 ± 24.8	295.0 ± 8.3	2176.8 ± 317.9	311.3 ± 8.7	1530.9 ± 256.1	290.5 ± 5.8	1812.2 ± 237.7

Note: “UB” is the best-known upper bound (makespan) for each instance from Behnke and Geiger (2012) [60]; “OURS” represents the proposed HLS-FJSP method.

.

Removing the genetic algorithm (HLS-GSTS) noticeably reduces performance on most instances. For example, the makespan increases from 204.2 to 516 on Mk03 and from 290.5 to 944.3 on Mk10. The percentage deviation from the upper bound also becomes much larger in several cases. These results indicate that GA is necessary for maintaining broader search capability during optimization. The crossover and mutation operations help preserve population diversity and reduce the likelihood of early convergence.

When greedy search is removed (HLS-GATS), the algorithm can still obtain solutions close to those of the complete HLS-FJSP on several instances, and slightly better results are observed on Mk02, Mk03, and Mk06. However, the runtime increases consistently, especially on larger instances. For example, the runtime increases from 1175.6s to 1634.6s on Mk08 and from 1812.2s to 2176.8s on Mk10. In addition, the complete HLS-FJSP achieves lower PD values on Mk08–Mk10. These results show that greedy search mainly improves convergence efficiency and helps reduce computation time during local improvement.

Removing tabu search (HLS-GSGA) reduces performance on difficult instances. On relatively small instances such as Mk01 and Mk04, the results remain close to those of the complete framework. However, larger differences appear in difficult instances. For example, the PD increases from 2.87% to 3.15% on Mk08 and from 47.46% to 58.02% on Mk10. These results suggest that tabu search plays a larger role when further improvement becomes difficult.

Overall, the three search strategies play complementary roles during optimization. Greedy search accelerates local improvement, GA enlarges the search space through population evolution, and tabu search reduces repeated search around similar solutions. Their combination allows HLS-FJSP to obtain stable scheduling results on instances of different scales.

5.6.3. Effectiveness of the Process Monitoring Mechanism

To examine the effect of the process monitoring mechanism, an ablation variant named Alt-1 is constructed. In Alt-1, the switching rule based on the repetition count t is removed. As a result, the selection between the genetic algorithm (GA) and tabu search (TS) during the random search phase depends only on the fixed parameter $\beta$, without considering whether the search has stagnated. By comparing Alt-1 with the complete HLS-FJSP, we evaluate the role of the repetition-based switching strategy in escaping local optima during optimization. All other experimental settings, including parameter values and termination conditions, are kept the same as those of HLS-FJSP. The comparative results are reported in

Table 10. Alt-1 and HLS-FJSP’s results on Brandimarte instances (average of 10 runs).

Instance	Size	UB	Alt-1		OURS
			Cmax	Time	Cmax	Time
Mk01	10 × 6	39	42.0 ± 0.0	126.0 ± 25.8	42.0 ± 0.0	179.2 ± 13.3
Mk02	10 × 6	26	31.9 ± 0.7	322.2 ± 120.1	32.3 ± 0.9	422.7 ± 106.2
Mk03	15 × 8	204	204.4 ± 0.8	516.8 ± 126.5	204.2 ± 0.6	861.0 ± 162.7
Mk04	15 × 8	60	73.5 ± 0.9	329.9 ± 93.8	72.8 ± 1.2	420.1 ± 96.2
Mk05	15 × 4	172	188.5 ± 3.5	418.9 ± 97.1	188.7 ± 3.7	676.4 ± 173.7
Mk06	15 × 10	58	88.0 ± 2.8	1277.2 ± 587.1	85.9 ± 2.6	1199.9 ± 67.4
Mk07	5 × 20	139	161.0 ± 5.4	493.0 ± 148.3	159.0 ± 3.8	748.4 ± 125.0
Mk08	10 × 20	523	542.2 ± 7.6	1688.3 ± 915.0	538.0 ± 6.4	1175.6 ± 182.9
Mk09	10 × 20	307	394.0 ± 11.1	1848.4 ± 774.5	397.1 ± 8.2	1435.7 ± 252.7
Mk10	15 × 20	197	302.9 ± 11.3	2113.6 ± 811.4	290.5 ± 5.8	1812.2 ± 237.7

Note: “UB” is the best-known upper bound (makespan) for each instance from Behnke and Geiger (2012) [60]; “OURS” represents the proposed HLS-FJSP method.

.

The experimental results show that HLS-FJSP performs better than Alt-1 on several large and difficult instances. On Mk06, Mk08, and Mk10, the makespan is reduced by 2.4%, 0.8%, and 4.1%, respectively. The runtime on these instances is also slightly lower than that of Alt-1. On Mk03, Mk04, and Mk07, HLS-FJSP obtains better or similar results, indicating that the monitoring mechanism can help the search continue improving after repeated solutions appear. On smaller instances such as Mk01, Mk02, Mk05, and Mk09, Alt-1 occasionally produces slightly smaller makespan values and usually requires less runtime. For these relatively simple instances, random switching between GA and TS is often sufficient, and the additional monitoring process does not always improve the results.

Overall, the monitoring mechanism is more useful on difficult FJSP instances, especially when the search begins to stagnate. The complete HLS-FJSP generally produces more stable results on large-scale problems, while Alt-1 may reduce computation time on simpler cases.

5.7. Impacts of Parameter Settings

Parameter sensitivity experiments are conducted on the Brandimarte benchmark instances to evaluate the robustness of the proposed HLS-FJSP with respect to its key parameters. The default parameter settings are $\alpha =0.5$, $\beta =0.5$, $r=100$, $\delta =30$, $pn=20$, and $L=25$. During the experiments, only one parameter is changed at a time, while the remaining parameters keep their default values. The tested parameter ranges are: $\alpha \in \{0.1,0.3,0.5,0.7,0.9\}$, $\beta \in \{0.1,0.3,0.5,0.7,0.9\}$, $r\in \{25,50,100,150,200\}$, $\delta \in \{20,25,30,35,40\}$, $pn\in \{10,15,20,25,30\}$, and $L\in \{15,20,25,30,35\}$. For each parameter setting, the algorithm is executed 10 times on every benchmark instance. The average makespan and runtime are then calculated from these runs.

Table 11. Sensitivity analysis of parameter $\alpha$ on Brandimarte instances (average of 10 runs).

Instance	Size	UB	α = 0.1		α = 0.3		α = 0.5		α = 0.7		α = 0.9
			Cmax	Time	Cmax	Time	Cmax	Time	Cmax	Time	Cmax	Time
Mk01	10 × 6	39	42.0 ± 0.0	108.7 ± 22.7	42.0 ± 0.0	153.6 ± 21.6	42.0 ± 0.0	179.2 ± 13.3	41.9 ± 0.3	114.8 ± 32.9	42.0 ± 0.0	113.9 ± 22.4
Mk02	10 × 6	26	31.4 ± 1.1	288.4 ± 89.4	31.4 ± 0.7	400.6 ± 73.0	32.3 ± 0.9	422.7 ± 106.2	32.4 ± 0.7	285.4 ± 92.3	32.3 ± 0.8	260.9 ± 52.7
Mk03	15 × 8	204	204.4 ± 0.8	672.4 ± 130.1	204.2 ± 0.6	792.7 ± 225.2	204.2 ± 0.6	861.0 ± 162.7	204.0 ± 0.0	598.2 ± 101.8	204.8 ± 1.6	498.4 ± 151.7
Mk04	15 × 8	60	73.2 ± 1.4	305.5 ± 86.4	72.9 ± 1.0	324.8 ± 101.4	72.8 ± 1.2	420.1 ± 96.2	73.0 ± 1.2	312.5 ± 111.5	72.5 ± 1.7	340.0 ± 96.5
Mk05	15 × 4	172	188.2 ± 3.2	416.1 ± 107.2	186.9 ± 2.8	531.6 ± 144.2	188.7 ± 3.7	676.4 ± 173.7	187.9 ± 2.0	393.3 ± 56.3	187.1 ± 2.6	418.4 ± 50.0
Mk06	15 × 10	58	86.5 ± 2.6	816.7 ± 180.3	86.0 ± 2.4	1026.3 ± 233.6	85.9 ± 2.6	1199.9 ± 67.4	84.7 ± 1.8	780.5 ± 111.0	84.7 ± 3.0	826.4 ± 176.2
Mk07	5 × 20	139	157.9 ± 4.0	503.1 ± 88.5	156.5 ± 2.9	660.0 ± 157.1	159.0 ± 3.8	748.4 ± 125.0	160.9 ± 3.6	447.7 ± 138.7	159.6 ± 3.2	482.2 ± 68.2
Mk08	10 × 20	523	540.6 ± 5.4	918.6 ± 220.3	539.1 ± 6.0	1079.8 ± 288.5	538.0 ± 6.4	1175.6 ± 182.9	541.5 ± 6.9	779.2 ± 119.7	537.8 ± 7.0	841.7 ± 166.4
Mk09	10 × 20	307	394.9 ± 10.6	1163.4 ± 216.9	393.3 ± 8.1	1269.4 ± 254.8	397.1 ± 8.2	1435.7 ± 252.7	398.6 ± 5.6	991.1 ± 200.1	396.1 ± 9.6	1042.8 ± 241.2
Mk10	15 × 20	197	299.1 ± 7.2	1435.1 ± 153.0	298.1 ± 8.8	1588.9 ± 276.1	290.5 ± 5.8	1812.2 ± 237.7	295.3 ± 10.6	1344.6 ± 295.0	302.2 ± 8.6	1306.6 ± 269.4

Note: “UB” is the best-known upper bound (makespan) for each instance from Behnke and Geiger (2012) [60].

presents the performance of HLS-FJSP under different settings of the parameter $\alpha$. Larger $\alpha$ values increase the probability of using genetic algorithm and tabu search, which helps the algorithm explore more candidate solutions and move away from local optima. Smaller $\alpha$ values rely more on greedy search. Such settings usually reduce runtime and are suitable for small instances. However, when $\alpha$ is too small, the search may converge too early on complex instances, making it difficult to obtain better schedules in later iterations. On the other hand, very large $\alpha$ values may introduce too many random search operations, which can increase runtime without obvious improvement in solution quality.

Table 12. Sensitivity analysis of parameter $\beta$ on Brandimarte instances (average of 10 runs).

Instance	Size	UB	β = 0.1		β = 0.3		β = 0.5		β = 0.7		β = 0.9
			Cmax	Time	Cmax	Time	Cmax	Time	Cmax	Time	Cmax	Time
Mk01	10 × 6	39	42.0 ± 0.0	111.4 ± 25.4	42.0 ± 0.0	87.8 ± 13.8	42.0 ± 0.0	179.2 ± 13.3	42.0 ± 0.0	95.7 ± 11.1	42.0 ± 0.0	111.0 ± 23.8
Mk02	10 × 6	26	31.9 ± 1.3	347.9 ± 121.5	31.7 ± 0.7	265.3 ± 48.3	32.3 ± 0.9	422.7 ± 106.2	31.7 ± 1.1	242.4 ± 83.5	31.8 ± 1.3	262.8 ± 92.6
Mk03	15 × 8	204	204.4 ± 0.8	532.1 ± 137.9	204.1 ± 0.3	483.6 ± 122.4	204.2 ± 0.6	861.0 ± 162.7	204.0 ± 0.0	460.5 ± 77.3	204.0 ± 0.0	636.3 ± 249.4
Mk04	15 × 8	60	72.3 ± 2.0	340.5 ± 113.0	72.5 ± 1.2	269.4 ± 65.4	72.8 ± 1.2	420.1 ± 96.2	72.9 ± 1.5	295.9 ± 102.5	72.6 ± 1.4	305.6 ± 151.6
Mk05	15 × 4	172	188.3 ± 4.2	424.2 ± 103.9	188.9 ± 2.4	349.3 ± 57.9	188.7 ± 3.7	676.4 ± 173.7	186.5 ± 2.4	357.7 ± 112.0	187.3 ± 3.9	446.7 ± 194.5
Mk06	15 × 10	58	84.3 ± 3.0	1022.1 ± 235.6	86.8 ± 1.9	726.2 ± 137.8	85.9 ± 2.6	1199.9 ± 67.4	85.7 ± 2.8	684.9 ± 151.8	85.2 ± 1.8	739.2 ± 235.0
Mk07	5 × 20	139	159.8 ± 4.1	501.2 ± 97.2	160.0 ± 3.2	362.4 ± 74.9	159.0 ± 3.8	748.4 ± 125.0	158.6 ± 2.6	407.2 ± 84.3	158.8 ± 2.7	475.4 ± 151.8
Mk08	10 × 20	523	542.2 ± 3.7	824.5 ± 227.0	544.5 ± 6.5	626.0 ± 113.5	538.0 ± 6.4	1175.6 ± 182.9	541.0 ± 4.2	779.6 ± 346.2	541.4 ± 5.4	948.5 ± 240.6
Mk09	10 × 20	307	401.8 ± 7.3	1068.5 ± 304.6	387.1 ± 5.9	1037.3 ± 146.8	397.1 ± 8.2	1435.7 ± 252.7	390.2 ± 10.7	1031.9 ± 347.6	397.3 ± 6.0	1015.6 ± 300.4
Mk10	15 × 20	197	297.4 ± 7.3	1415.9 ± 224.3	297.4 ± 6.9	1285.3 ± 152.4	290.5 ± 5.8	1812.2 ± 237.7	295.2 ± 12.2	1263.5 ± 220.2	293.4 ± 6.7	1164.9 ± 162.7

Note: “UB” is the best-known upper bound (makespan) for each instance from Behnke and Geiger (2012) [60].

reports the results of HLS-FJSP with various parameter settings of $\beta$. Small-scale instances are less sensitive to $\beta$, since most parameter settings can obtain near-optimal solutions. Increasing the use of GA helps generate more candidate solutions, which is beneficial for several medium-scale instances. For large-scale instances, relying too much on either GA or TS does not consistently produce better results. Moderate $\beta$ values usually give more stable results by combining GA with TS. Although larger $\beta$ values increase the use of GA, excessive random search may increase runtime and lead to larger differences between runs. In contrast, very small $\beta$ values reduce population diversity and may cause the search to stop improving too early.

Table 13. Sensitivity analysis of parameter r on Brandimarte instances (average of 10 runs).

Instance	Size	UB	r = 25		r = 50		r = 100		r = 150		r = 200
			Cmax	Time	Cmax	Time	Cmax	Time	Cmax	Time	Cmax	Time
Mk01	10 × 6	39	42.0 ± 0.0	28.7 ± 5.9	42.0 ± 0.0	54.2 ± 11.5	42.0 ± 0.0	179.2 ± 13.3	42.0 ± 0.0	168.5 ± 54.1	42.0 ± 0.0	190.0 ± 18.6
Mk02	10 × 6	26	32.6 ± 1.1	73.4 ± 31.2	31.9 ± 1.5	142.8 ± 34.3	32.3 ± 0.9	422.7 ± 106.2	31.3 ± 0.8	473.1 ± 149.6	31.7 ± 1.2	523.6 ± 130.0
Mk03	15 × 8	204	204.0 ± 0.0	155.4 ± 44.6	204.2 ± 0.4	293.8 ± 67.4	204.2 ± 0.6	861.0 ± 162.7	204.0 ± 0.0	776.8 ± 171.1	204.0 ± 0.0	973.9 ± 174.2
Mk04	15 × 8	60	73.4 ± 1.5	65.8 ± 18.0	73.4 ± 0.8	162.1 ± 50.8	72.8 ± 1.2	420.1 ± 96.2	72.1 ± 2.0	410.9 ± 123.6	71.6 ± 1.2	580.6 ± 111.0
Mk05	15 × 4	172	189.9 ± 3.9	94.0 ± 30.8	188.6 ± 3.4	219.4 ± 85.3	188.7 ± 3.7	676.4 ± 173.7	188.1 ± 2.6	635.2 ± 235.7	187.6 ± 2.4	775.2 ± 135.3
Mk06	15 × 10	58	85.8 ± 2.6	257.2 ± 60.8	85.8 ± 2.7	422.8 ± 102.3	85.9 ± 2.6	1199.9 ± 67.4	85.5 ± 3.9	1218.6 ± 390.8	86.0 ± 1.9	1461.1 ± 153.4
Mk07	5 × 20	139	161.1 ± 3.5	122.7 ± 28.6	159.2 ± 3.9	254.9 ± 61.4	159.0 ± 3.8	748.4 ± 125.0	157.6 ± 2.8	684.2 ± 249.4	160.4 ± 4.9	735.5 ± 133.7
Mk08	10 × 20	523	544.5 ± 6.7	283.6 ± 76.1	542.2 ± 6.8	372.4 ± 100.4	538.0 ± 6.4	1175.6 ± 182.9	539.6 ± 4.1	1218.7 ± 317.9	541.2 ± 3.1	1441.7 ± 258.9
Mk09	10 × 20	307	400.9 ± 7.3	296.9 ± 108.3	398.3 ± 7.2	571.2 ± 162.3	397.1 ± 8.2	1435.7 ± 252.7	398.5 ± 4.2	1411.2 ± 208.2	394.9 ± 6.9	1855.1 ± 301.4
Mk10	15 × 20	197	295.0 ± 9.6	384.0 ± 112.5	301.1 ± 14.1	718.9 ± 165.3	290.5 ± 5.8	1812.2 ± 237.7	294.8 ± 6.6	2020.8 ± 309.4	299.2 ± 7.5	2384.5 ± 248.9

Note: “UB” is the best-known upper bound (makespan) for each instance from Behnke and Geiger (2012) [60].

presents the results of HLS-FJSP with various parameter settings of r. Small-scale instances can obtain optimal or near-optimal solutions even when r is small, while the runtime remains short. For medium-scale instances, increasing r usually improves the makespan because the algorithm is allowed to continue searching for better schedules. However, the improvement becomes smaller as the runtime increases. For large-scale instances, larger r values are more useful since these problems contain more operations and machine combinations. Nevertheless, when r exceeds 100, the improvement in solution quality is limited compared with the increase in runtime. Moderate settings such as $r=50$ or $r=100$ usually obtain competitive makespan with acceptable runtime, whereas excessively large r values noticeably increase runtime while only slightly improving the final solutions.

Table 14. Sensitivity analysis of parameter $\delta$ on Brandimarte instances (average of 10 runs).

Instance	Size	UB	δ = 20		δ = 25		δ = 30		δ = 35		δ = 40
			Cmax	Time	Cmax	Time	Cmax	Time	Cmax	Time	Cmax	Time
Mk01	10 × 6	39	42.0 ± 0.0	79.8 ± 14.3	42.0 ± 0.0	98.6 ± 21.9	42.0 ± 0.0	179.2 ± 13.3	42.0 ± 0.0	114.0 ± 10.2	41.9 ± 0.3	161.1 ± 30.7
Mk02	10 × 6	26	32.3 ± 1.3	210.4 ± 42.4	32.9 ± 0.9	229.1 ± 44.8	32.3 ± 0.9	422.7 ± 106.2	31.5 ± 1.5	333.7 ± 81.7	31.5 ± 1.0	392.1 ± 97.7
Mk03	15 × 8	204	204.4 ± 0.7	468.4 ± 110.9	204.1 ± 0.3	513.6 ± 126.2	204.2 ± 0.6	861.0 ± 162.7	204.1 ± 0.3	660.4 ± 139.4	204.0 ± 0.0	684.3 ± 136.7
Mk04	15 × 8	60	73.8 ± 1.2	240.4 ± 62.4	72.8 ± 0.8	221.7 ± 57.3	72.8 ± 1.2	420.1 ± 96.2	72.4 ± 1.3	332.6 ± 114.9	72.0 ± 1.1	365.3 ± 85.7
Mk05	15 × 4	172	190.4 ± 3.3	244.5 ± 47.4	189.4 ± 2.4	329.6 ± 41.1	188.7 ± 3.7	676.4 ± 173.7	187.2 ± 2.6	482.6 ± 101.4	186.1 ± 2.3	460.9 ± 125.6
Mk06	15 × 10	58	86.9 ± 1.9	645.7 ± 148.0	86.1 ± 3.5	753.8 ± 149.1	85.9 ± 2.6	1199.9 ± 67.4	84.2 ± 2.6	1052.4 ± 303.1	85.9 ± 2.8	1053.9 ± 249.4
Mk07	5 × 20	139	158.1 ± 6.5	357.3 ± 65.6	159.1 ± 3.6	400.7 ± 124.3	159.0 ± 3.8	748.4 ± 125.0	158.5 ± 2.8	531.0 ± 141.7	156.3 ± 3.6	594.5 ± 124.0
Mk08	10 × 20	523	543.9 ± 8.6	601.8 ± 128.5	545.2 ± 4.2	730.8 ± 190.7	538.0 ± 6.4	1175.6 ± 182.9	537.6 ± 3.6	1025.5 ± 330.2	536.0 ± 6.3	1203.0 ± 435.8
Mk09	10 × 20	307	398.5 ± 8.0	797.6 ± 119.6	397.5 ± 9.1	973.1 ± 241.9	397.1 ± 8.2	1435.7 ± 252.7	394.6 ± 7.2	1441.1 ± 225.1	389.5 ± 6.0	1332.4 ± 233.9
Mk10	15 × 20	197	301.4 ± 9.1	1085.4 ± 136.3	292.0 ± 8.1	1222.2 ± 206.0	290.5 ± 5.8	1812.2 ± 237.7	293.7 ± 11.1	1716.7 ± 277.8	291.1 ± 9.7	1709.2 ± 255.3

Note: “UB” is the best-known upper bound (makespan) for each instance from Behnke and Geiger (2012) [60].

presents the sensitivity analysis of parameter $\delta$ on the Brandimarte instances. Overall, increasing the value of $\delta$ leads to a consistent reduction in makespan ($C_{\max }$), bringing the solutions closer to the best-known upper bounds (UB). However, this improvement in solution quality is accompanied by a corresponding increase in computational time. Therefore, it is recommended to select $\delta$ based on practical priorities: for minimum runtime, $\delta =20$–25 is preferred; for a balanced performance across most instances, $\delta =30$ is recommended; and for the highest solution quality on large-scale problems, $\delta =35$–40 should be adopted when computational time is not the primary concern.

Table 15. Sensitivity analysis of parameter $pn$ on Brandimarte instances (average of 10 runs).

Instance	Size	UB	pn = 10		pn = 15		pn = 20		pn = 25		pn = 30
			Cmax	Time	Cmax	Time	Cmax	Time	Cmax	Time	Cmax	Time
Mk01	10 × 6	39	42.0 ± 0.0	65.2 ± 11.3	42.0 ± 0.0	91.0 ± 24.9	42.0 ± 0.0	179.2 ± 13.3	42.0 ± 0.0	140.7 ± 30.4	41.9 ± 0.3	173.8 ± 53.6
Mk02	10 × 6	26	31.9 ± 1.2	202.9 ± 32.6	32.1 ± 0.7	236.3 ± 55.2	32.3 ± 0.9	422.7 ± 106.2	32.0 ± 1.3	345.1 ± 63.9	31.5 ± 0.7	438.8 ± 143.7
Mk03	15 × 8	204	205.1 ± 1.7	338.7 ± 68.0	204.1 ± 0.3	472.7 ± 95.9	204.2 ± 0.6	861.0 ± 162.7	204.1 ± 0.3	611.5 ± 142.1	204.0 ± 0.0	656.8 ± 112.2
Mk04	15 × 8	60	72.4 ± 1.4	197.3 ± 61.7	72.8 ± 1.4	220.5 ± 53.4	72.8 ± 1.2	420.1 ± 96.2	73.1 ± 0.9	372.2 ± 128.5	72.7 ± 1.0	387.6 ± 85.7
Mk05	15 × 4	172	188.2 ± 3.5	243.8 ± 48.1	186.3 ± 2.2	342.9 ± 62.9	188.7 ± 3.7	676.4 ± 173.7	187.8 ± 3.0	482.6 ± 151.4	188.5 ± 2.2	513.8 ± 174.2
Mk06	15 × 10	58	85.5 ± 4.3	554.3 ± 76.0	85.9 ± 1.7	749.9 ± 197.7	85.9 ± 2.6	1199.9 ± 67.4	85.6 ± 2.1	878.3 ± 186.1	84.7 ± 2.2	1069.0 ± 130.9
Mk07	5 × 20	139	157.4 ± 3.2	282.1 ± 56.1	159.8 ± 3.2	354.6 ± 73.2	159.0 ± 3.8	748.4 ± 125.0	157.2 ± 4.9	575.5 ± 104.7	159.5 ± 3.0	686.8 ± 186.4
Mk08	10 × 20	523	543.1 ± 3.0	480.3 ± 124.1	540.6 ± 5.4	648.4 ± 146.9	538.0 ± 6.4	1175.6 ± 182.9	537.5 ± 5.2	1060.8 ± 248.0	533.9 ± 6.0	1166.4 ± 197.0
Mk09	10 × 20	307	398.2 ± 7.8	665.6 ± 111.8	399.4 ± 10.0	887.6 ± 245.8	397.1 ± 8.2	1435.7 ± 252.7	396.2 ± 11.4	1151.5 ± 248.2	394.0 ± 7.3	1408.9 ± 346.0
Mk10	15 × 20	197	297.0 ± 12.3	985.2 ± 231.9	298.7 ± 9.2	1123.3 ± 141.7	290.5 ± 5.8	1812.2 ± 237.7	294.4 ± 11.2	1587.8 ± 343.3	293.3 ± 10.5	1681.5 ± 160.5

Note: “UB” is the best-known upper bound (makespan) for each instance from Behnke and Geiger (2012) [60].

summarizes the results of HLS-FJSP with different settings of $pn$. Small $pn$ can already obtain optimal or near-optimal solutions with short runtime on small-scale instances. For medium-scale instances, moderate population sizes usually produce better makespan with acceptable runtime. In these cases, a moderate $pn$ is sufficient to keep enough solution variation during the search. For large-scale instances, larger population sizes often produce better schedules because more candidate solutions are generated during optimization. However, the improvement becomes smaller when $pn$ continues to increase, while the runtime increases noticeably. Considering both makespan and runtime, $pn=20$ performs well on most benchmark instances.

Table 16. Sensitivity analysis of parameter L on Brandimarte instances (average of 10 runs).

Instance	Size	UB	L = 15		L = 20		L = 25		L = 30		L = 35
			Cmax	Time	Cmax	Time	Cmax	Time	Cmax	Time	Cmax	Time
mk01	10 × 6	39	42.0 ± 0.0	113.1 ± 16.2	42.0 ± 0.0	99.1 ± 8.7	42.0 ± 0.0	179.2 ± 13.3	42.0 ± 0.0	100.7 ± 10.7	42.0 ± 0.0	121.6 ± 16.4
mk02	10 × 6	26	32.3 ± 1.7	272.3 ± 63.2	31.8 ± 1.3	287.8 ± 60.0	32.3 ± 0.9	422.7 ± 106.2	32.2 ± 0.6	266.7 ± 74.2	31.9 ± 1.2	258.0 ± 64.2
mk03	15 × 8	204	204.2 ± 0.6	547.2 ± 120.5	204.2 ± 0.6	622.5 ± 143.6	204.2 ± 0.6	861.0 ± 162.7	204.0 ± 0.0	498.1 ± 102.2	204.9 ± 1.9	546.3 ± 121.4
mk04	15 × 8	60	71.9 ± 1.7	288.9 ± 80.4	72.9 ± 0.9	274.8 ± 50.4	72.8 ± 1.2	420.1 ± 96.2	72.7 ± 1.3	267.3 ± 78.4	72.7 ± 1.6	278.1 ± 87.7
mk05	15 × 4	172	187.4 ± 2.6	372.7 ± 106.7	187.2 ± 2.8	412.2 ± 85.8	188.7 ± 3.7	676.4 ± 173.7	186.9 ± 3.0	409.5 ± 167.1	188.7 ± 1.9	419.5 ± 139.3
mk06	15 × 10	58	86.4 ± 1.7	769.3 ± 182.1	86.0 ± 3.4	818.4 ± 125.5	85.9 ± 2.6	1199.9 ± 67.4	85.2 ± 3.3	785.6 ± 196.0	86.1 ± 1.4	827.6 ± 102.0
mk07	5 × 20	139	158.7 ± 4.2	443.6 ± 81.7	160.1 ± 3.7	504.9 ± 90.5	159.0 ± 3.8	748.4 ± 125.0	159.0 ± 2.9	498.3 ± 139.1	158.2 ± 4.1	501.5 ± 108.1
mk08	10 × 20	523	542.9 ± 4.8	703.1 ± 155.9	536.3 ± 6.6	973.8 ± 226.5	538.0 ± 6.4	1175.6 ± 182.9	538.6 ± 3.3	753.0 ± 188.6	540.3 ± 4.0	755.2 ± 115.2
mk09	10 × 20	307	394.1 ± 9.5	1053.4 ± 139.0	393.9 ± 11.8	1166.5 ± 262.6	397.1 ± 8.2	1435.7 ± 252.7	392.9 ± 11.8	1012.1 ± 247.5	394.0 ± 6.8	955.7 ± 213.9
mk10	15 × 20	197	296.6 ± 10.0	1239.3 ± 104.8	291.1 ± 11.2	1480.7 ± 212.8	290.5 ± 5.8	1812.2 ± 237.7	295.6 ± 9.9	1406.2 ± 418.5	297.7 ± 7.4	1406.7 ± 247.7

Note: “UB” is the best-known upper bound (makespan) for each instance from Behnke and Geiger (2012) [60].

summarizes the results of HLS-FJSP with different settings of L. The value of L mainly affects how many recently visited solutions are stored in the tabu list. Smaller or moderate L values usually allow the algorithm to update schedules more quickly, which is suitable for small-scale instances. Larger L values help reduce repeated search on more difficult instances by preventing the algorithm from revisiting similar schedules too often. However, when L is too small, the search may repeatedly move around similar solutions and stop improving early. In contrast, excessively large L values may restrict neighborhood updates and slow down local schedule improvement. Overall, $L=20$ is suitable when a shorter runtime is preferred on small and medium instances. Setting $L=25$ produces relatively stable results across different problem sizes, while $L=30$ may further improve solution quality on some large instances, with only a small increase in runtime.

5.8. Significance for Smart Manufacturing Systems

The experimental results indicate that HLS-FJSP can obtain feasible scheduling solutions within practical computation time on different benchmark instances. The decision-making mechanism controlled by process monitoring and control parameters also allows the algorithm to adjust the search process when the current solution repeatedly stagnates. The proposed method can also be combined with other scheduling frameworks used in smart manufacturing environments. For example, it may be integrated with digital twin systems or cloud-edge production platforms to support complex scheduling tasks [61]. In addition, HLS-FJSP can be used as a further optimization tool to further improve schedules generated by deep reinforcement learning approaches [30,62].

Since the algorithm does not rely on offline training, it can be applied together with data-driven manufacturing systems and IIoT-based production platforms [63]. The experimental results show that the hybrid search strategy is effective for solving FJSP instances with different scales and structures.

6. Conclusions

This paper proposes HLS-FJSP, a hybrid local search method for the Flexible Job-shop Scheduling Problem. The method combines greedy search, genetic algorithm, and tabu search through a search mode switching strategy based on process monitoring. Experimental results on standard benchmark instances show that HLS-FJSP can obtain better scheduling results than several composite dispatching rules within an acceptable computation time. The proposed method maintains stable performance across different benchmark sets and problem sizes. In particular, the algorithm performs well on several large and complex instances, where local search alone or fixed hybrid strategies are less effective. These results indicate that combining different search strategies through adaptive switching can improve the optimization process for FJSP.