KTNSGA-II: An Enhanced Hybrid Heuristic Algorithm for Multi-Objective Flexible Job Shop Scheduling with Makespan Workload Balance and Energy Consumption

Abstract

The Multi-Objective Flexible Job Shop Scheduling Problem (MOFJSSP) represents a core challenge in modern manufacturing: achieving synergistic optimization of multiple conflicting objectives while pursuing production efficiency and energy sustainability. To address this, this study proposes an enhanced hybrid heuristic algorithm—KNN–Tabu Search NSGA-II (KTNSGA-II)—for simultaneously optimizing completion time, machine load, and total energy consumption. First, a three-objective mathematical model is established. Subsequently, four key strategies are integrated: (1) workload balancing initialization rapidly generates high-quality initial solutions; (2) an adaptive job-level crossover mechanism dynamically adjusts subset sizes during iterations to balance global exploration and local exploitation; (3) K-nearest neighbor-based congestion distance calculation maintains population diversity; (4) tabu search applied to non-dominated solutions on the Pareto front for local refinement. Extensive experiments on standard benchmark instances demonstrate that KTNSGA-II significantly outperforms representative algorithms in terms of convergence and diversity. For large-scale Behnke benchmark instances, KTNSGA-II achieves an average hypervolume (HV) improvement of 32.32% compared to other comparison algorithms. Furthermore, this method substantially enhances solution diversity: the Spacing Performance (SP) metric improved by 39.72%, indicating more uniform distribution of Pareto optimal solutions; the Diversity Metric (DM) increased by 57.54%, reflecting broader coverage and more even distribution along the Pareto frontier boundary. These results confirm that KTNSGA-II generates higher-quality, better-distributed Pareto fronts, achieving a more optimal trade-off between completion time, machine load, and energy consumption.

1. Introduction

Optimization of shop scheduling, a key component of production management, holds paramount importance for improving efficiency and reducing costs [1]. The Flexible Job Shop Scheduling Problem (FJSSP) [2]—an extension of the classic Job Shop Scheduling Problem (JSSP) [3]—presents a significant challenge in the fields of modern manufacturing and operations research. Unlike JSSP where each operation can only be performed on a pre-specified machine, FJSSP allows each operation to be processed on any one of a set of available machines. This flexible mode can more realistically reflect real production scenarios, but it also increases the complexity of finding an optimal scheduling solution.

In research on Flexible Job Shop Scheduling Problem (FJSSP), researchers initially focused primarily on optimizing single performance indicators. Among various performance metrics, Makespan became the most emphasized objective due to its direct correlation with production efficiency. Subsequently, with the increasing complexity of manufacturing systems and enterprises’ comprehensive consideration of multiple performance aspects, research gradually shifted toward multi-objective optimization, incorporating multiple indicators such as machine workload, cost, and tardiness. In recent years, sustainable development has received growing attention, with energy consumption being introduced as a key indicator in FJSSP research, driving the development of energy-efficient scheduling strategies.

However, existing multi-objective evolutionary algorithms still exhibit several unresolved challenges when addressing such problems, which can be summarized in three aspects:

(i)

Insufficient convergence performance, often manifested as premature convergence to local optima;

(ii)

Inadequate diversity preservation, especially on complex and irregular Pareto frontiers;

(iii)

Weak local exploitation capability, which limits further refinement of non-dominated solutions.

Although some studies have attempted to alleviate one or two of these issues [4,5,6], most existing approaches focus on isolated objectives or partial improvements, such as enhancing convergence speed or optimizing machine load, while failing to address convergence, diversity, and local exploitation in an integrated manner. Moreover, comprehensive studies simultaneously considering completion time, machine load, and energy consumption remain relatively scarce. Therefore, further research is still necessary to design multi-objective evolutionary algorithms capable of simultaneously optimizing completion time, machine load, and energy consumption while maintaining good convergence and diversity.

To address the above challenges, this paper proposes an enhanced hybrid heuristic algorithm, KTNSGA-II, which is specifically designed to simultaneously improve convergence performance, preserve population diversity, and enhance local exploitation, thereby achieving a more balanced trade-off among time cost, machine load, and green shop floor requirements.

The primary contributions of this work, in comparison with existing NSGA-II hybrid variants, are summarized as follows:

(1)

Mathematical Modeling: We establish a novel mathematical model for the MOFJSSP, integrating key performance indicators such as Makespan, machine load, and shop floor energy consumption.

(2)

Algorithmic Innovation: Compared with conventional NSGA-II and its existing hybrid variants, which often suffer from limited local search capability, premature convergence, or insufficient diversity maintenance in complex scheduling problems, this study proposes a coordinated hybrid improvement framework, including:

• Workload Balancing Initialization: A problem-specific initialization strategy is designed to promote balanced machine workloads at the population generation stage, which is rarely considered in standard NSGA-II hybrids.
• Adaptive Job-based Crossover Strategy: Unlike fixed or static crossover mechanisms, a job-adaptive crossover strategy is developed, in which the crossover subset size is dynamically adjusted according to the evolutionary stage, enabling strong global exploration in early generations and refined local exploitation in later stages.
• K-Nearest Neighbor Density Estimation: Instead of the standard crowding distance, a KNN-based density estimation method is incorporated to better preserve population diversity on complex and irregular Pareto frontiers.
• Pareto-front-oriented Tabu Search: Different from conventional hybrid approaches where local search is applied indiscriminately, a Tabu search procedure is selectively applied to non-dominated solutions on the Pareto front after each generation, further enhancing solution quality while maintaining multi-objective trade-offs.

In flexible job shop scheduling problems, symmetry naturally arises from the presence of interchangeable machines and alternative processing routes for the same operation. When multiple machines are capable of performing identical operations with comparable processing characteristics, numerous scheduling solutions become structurally equivalent, forming a symmetric solution space. Such symmetry increases the complexity of the search process, as different schedules may exhibit similar objective values while differing only in machine assignments or operation sequences.

From a multi-objective perspective, symmetry is also closely related to workload balance and energy efficiency. An unbalanced assignment often corresponds to symmetry breaking, where certain machines are overloaded while others remain underutilized, leading to increased Makespan and unnecessary energy consumption. Conversely, restoring symmetry through balanced machine utilization contributes to improved system efficiency and sustainability.

Motivated by these observations, this study considers the structural symmetry inherent in the MOFJSSP and proposes a symmetry-aware hybrid heuristic algorithm. By integrating workload-balanced initialization, diversity-preserving mechanisms, and adaptive local search strategies, the proposed KTNSGA-II is designed to effectively explore symmetric regions of the solution space while selectively breaking symmetry to identify high-quality Pareto-optimal solutions. This perspective not only enhances optimization performance but also aligns the scheduling process with the fundamental principles of symmetry in complex manufacturing systems.

The remainder of this paper is organized as follows: Section 2 presents the literature review Section 3 provides a formal description of the MOFJSSP and presents the mathematical model. Section 4 details the proposed KTNSGA-II algorithm. Section 5 presents and analyzes the results of simulation experiments designed to validate both the model and algorithm. Finally, Section 6 summarizes the key findings of the study and outlines directions for future research.

2. Literature Review

In this section, relevant research on the Flexible Job Shop Scheduling Problem (FJSSP) and its Multi-Objective Scaling (MOFJSSP) will be reviewed, with a particular focus on green scheduling strategies that have incorporated energy considerations in recent years.

Currently, solution methods for the Flexible Job Shop Scheduling Problem (FJSSP) are mainly divided into two categories: exact methods and approximate methods. Exact methods, such as mathematical programming, seek to determine optimal solutions through exhaustive exploration of the entire solution space. However, the inherent NP-hard complexity of FJSSP poses substantial challenges, particularly when scaling to large-sized scheduling problems within practical time constraints. Recognizing the computational intractability of FJSSP, approximate methodologies have gained prominence in recent years for tackling real-world problem instances. Generally, approximate methods offer a pragmatic trade-off between computational expenditure and solution quality. Notable within these approximate methodologies are swarm intelligence (SI) and evolutionary algorithms (EA), encompassing techniques such as Genetic Algorithms (GA) [7], Differential Evolution (DE) [8], Particle Swarm Optimization (PSO) [9], Simulated Annealing (SA) [10], Tabu Search (TS) [11], Harmony Search (HS) [12], Grey Wolf Optimizer (GWO) [13], Harris Hawks Optimization (HHO) [14], NSGA-II [15], IBEA [16] and MOEA/D [17].

2.1. Study of Single-Objective Flexible Job Shop Scheduling Problem

In the field of single-objective FJSSP optimization research, numerous scholars have optimized key indicators such as Makespan by improving existing algorithms or proposing new hybrid algorithms [18]. An enhanced Genetic Algorithm to address the Distributed and Flexible Job Shop Scheduling Problem (DFJS) was proposed, extending gene encoding to incorporate job allocation to Flexible Manufacturing Units (FMUs) and employing a greedy decoding process to leverage job routing flexibility, effectively optimizing global Makespan [19]. A hybrid metaheuristic algorithm combining Artificial Immune Algorithm and Simulated Annealing for complex FJSSP was developed, alongside two novel Mixed-Integer Linear Programming (MILP) models detailing shop floor operations [20]. A Parallel Variable Neighborhood Search (PVNS) algorithm for FJSSP was proposed, minimizing total processing time [21]. FJSSP was investigated and a Hybrid Differential Evolution (HDE) algorithm was proposed to minimize Makespan. A novel transformation mechanism adapted continuous-domain Differential Evolution to the discrete FJSP space, embedding a critical-path-based local search to balance global exploration and local exploitation [22]. An integrated scheduling method was proposed for flexible manufacturing workshops that comprehensively considers conflict-free path planning. By employing a hybrid genetic algorithm to optimize production and AGV scheduling, it effectively minimizes the maximum completion time. Its efficiency and feasibility were validated through practical case studies [23]. To address the scheduling problem in flexible manufacturing workshops with limited AGV capacity (FJSP-AGV) an improved genetic algorithm (IGA) was proposed. By incorporating a population diversity check mechanism, premature convergence was effectively avoided. The approach updated 34 current optimal solutions across multiple benchmark instances, demonstrating significant improvement over existing algorithms.

2.2. Research on Multi-Objective Flexible Job Shop Scheduling Problem

However, with the increasing emphasis on production efficiency, resource utilization, and sustainability in modern manufacturing systems, scheduling research that only considers a single objective no longer meets the various requirements of actual production. Therefore, researchers have begun to shift their focus to the study of Multi-Objective Flexible Job Shop Scheduling Problem (MOFJSSP) [24]. NHGASA—a hybrid metaheuristic combining genetic and simulated annealing algorithms—was presented, achieving high-quality Pareto solutions for multi-objective FJSSP in reduced computation time [25]. A discrete artificial bee colony algorithm (DABC) for multi-objective FJSSP with maintenance was proposed, effectively optimizing Makespan, machine workload, and critical machine workload using tabu search and adaptive neighbor-hoods [26]. An object-oriented approach with simulated annealing for multi-objective FJSSP was developed, simplifying FJSP encoding via UML class diagrams and enhancing integration into manufacturing control systems [27]. A distributed ant colony system (DACS) was introduced for multi-objective optimization in flexible assembly job shop scheduling [28]. EMOGWO—an efficient evolutionary grey wolf optimizer for multi-objective FJSSP with hierarchical job priorities—was presented, significantly improving convergence and diversity [29]. MODJA—a Pareto-based discrete Jaya algorithm—was proposed, minimizing Makespan, total machine workload, and critical machine workload, enhanced by problem specific local search and improved crowding distance [30]. Multi-objective flexible job shop cell scheduling was investigated, considering disruptions and inter-cell factors, finding transgenerational membrane algorithms superior for Pareto front generation [31]. INSBBO—an improved non-dominated sorting biogeography-based optimization algorithm for (hybrid) multi-objective FJSSP—was introduced, significantly enhancing convergence and solution quality [32]. An improved African Vulture Optimization Algorithm (IAVOA) was proposed for the multi-objective flexible job shop scheduling problem (DRCFJSP) under dual resource constraints of machines and workers. Through three stage encoding, a memory mechanism, and a neighborhood search strategy, the algorithm effectively minimized both maximum completion time and total delay. Experimental results demonstrate its superior performance compared to mainstream algorithms such as SPEA2 and NSGA-II.

2.3. Green Flexible Job Shop Scheduling Study Considering Energy Consumption

However, growing environmental consciousness and rising energy prices have propelled energy consumption to the forefront of manufacturing considerations, fueling the imperative for energy-conscious scheduling strategies [33,34]. A multi-objective genetic algorithm for energy-efficient job-shop scheduling was proposed. By concurrently optimizing production efficiency and energy consumption, their algorithm effectively reduced total energy consumption while maintaining near optimal Makespan, offering a novel optimization strategy for sustainable manufacturing [35]. Energy-efficient flexible job shop scheduling with transportation constraints was addressed, developing a multi-objective optimization model to minimize both energy consumption and Makespan [36]. An improved artificial bee colony algorithm (IABC) for multi-objective low carbon FJSSP (MLFJSSP) was proposed, minimizing Makespan, total carbon emissions, and machine workload [37]. A multi-objective evolutionary algorithm based on decomposition for energy-efficient distributed job-shop scheduling (EEDJSP) was introduced, minimizing Makespan and total energy consumption [38]. A model for energy-saving flexible workshop scheduling that considers the flexibility of discrete operation sequences was proposed, and an improved hybrid genetic algorithm was designed to simultaneously minimize the maximum completion time and total energy consumption [39]. The QNSGA-II algorithm was proposed to solve the dynamic scheduling problem for flexible manufacturing workshops under AGV charging constraints. By minimizing the maximum completion time and total energy consumption, the algorithm significantly enhances scheduling quality and stability in multi-disturbance environments through Q-Learning guided neighborhood search and hybrid initialization strategies [40]. A Rainbow DQN deep reinforcement learning framework incorporating compo-site scheduling rules was proposed, which simultaneously addresses the challenges of low carbon, heterogeneous, and transferable dynamic scheduling in distributed flexible manufacturing workshops for the first time. It significantly outperforms traditional rules and mainstream DRL algorithms in both weighted total lead time and total energy consumption objectives.

2.4. Comparative Summary

Table 1. Comparative summary of related work on Multi-Objective Flexible Job Shop Scheduling.

Ref	Algorithm	Objectives	Energy Considered	Dataset	Key Strength	Limitation
May et al., 2015 [34]	Multi-objective Genetic Algorithm (MOGA)	Makespan + Energy Consumption	✓	Brandimarte benchmark instances	Early integration of energy objective into scheduling optimization;	Lacks machine load objective; no advanced diversity preservation;
Zhang et al., 2020 [27]	Distributed Ant Colony System (DACS)	Makespan + Machine Load + Total Workload	✗	Benchmark + Real assembly cases	Distributed ACO improves scalability and solution quality for flexible assembly FJSP	Energy consumption not considered; limited sustainability perspective
Zhu and Zhou, 2020 [28]	Efficient Evolutionary Multi-Objective Grey Wolf Optimizer (EMOGWO)	Makespan + Maximum Machine Workload + Total Machine Workload	✗	Brandimarte benchmark instances	Improved convergence and diversity via leadership hierarchy and evolutionary operators	No energy/green objective; local exploitation capability is limited without explicit local search
Deliktaş et al., 2021 [30]	Genetic Algorithms (GA) and Memetic Algorithms (MA) with scalarization methods	Makespan + Maximum Machine Workload + Total Machine Workload	✗	Benchmark instances	Systematic comparison of MOEAs for job shop cell scheduling; good Pareto diversity	No energy objective; limited local search enhancement
An et al., 2021 [31]	Improved Non-Dominated Sorting Biogeography-Based Optimization (INSBBO)	Makespan + Maximum Machine Workload + Total Machine Workload	✗	Brandimarte benchmark instances	Enhanced convergence and solution quality via improved migration and mutation operators	No energy consumption objective; diversity maintenance relies on crowding distance
Dai et al., 2019 [35]	Multi-objective evolutionary algorithm (MOEA, GA-based hybrid)	Makespan + Total Energy Consumption	✓	Benchmark instances	Explicit modeling of machine energy consumption; effective trade-off between productivity and energy efficiency	Does not consider machine workload balance; diversity maintenance relies on standard mechanisms
Gong et al., 2024 [38]	Improved Memetic Algorithm (IMA)	Makespan + Total Energy Consumption	✓	Benchmark instances	Novel FJSP with discrete sequence flexibility; IMA with flexible sequencing + local search; outperforms EAs in convergence	Limited to two objectives; does not consider machine workload balance;
Chen et al., 2024 [39]	Q-Learning based NSGA-II (QNSGA-II)	Makespan + Total Energy Consumption	✓	Benchmark instances	Integrates Q-Learning to guide neighborhood search;	Does not consider machine workload balance; increased computational complexity due to learning component
Our Work	KNN–Tabu Search NSGA-II (KTNSGA-II)	Makespan + Machine Load + Total Energy Consumption	✓	Benchmark instances	Coordinated hybrid framework integrating workload-balanced initialization, adaptive job-level crossover, KNN-based density estimation, and Pareto-front-oriented tabu search; this study addresses previous limitations through integrated adaptive strategies and strong local refinement, achieving superior convergence, diversity, and trade-off quality	Slightly higher computational cost due to KNN density calculation and local search

provides a comparative summary of representative studies on multi-objective flexible job shop scheduling, highlighting key algorithms, objectives, datasets, and findings. This analysis reveals persistent gaps in existing approaches, particularly in maintaining population diversity, enhancing local search capability on Pareto fronts, and comprehensively integrating energy consumption as a critical objective. Our proposed KTNSGA-II addresses these limitations through innovative mechanisms: workload-balanced initialization for high-quality starting solutions, adaptive job-level crossover for dynamic global-local balance, K-nearest neighbor congestion distance for robust diversity preservation, and targeted tabu search on non-dominated solutions for effective local refinement. By delivering better-converged, more uniformly distributed Pareto fronts, KTNSGA-II offers a practical and effective solution for balancing production efficiency, resource utilization, and energy sustainability in modern green manufacturing systems.

In summary, shop floor scheduling research has evolved towards being multi-objective, intelligent and green. Despite the progress made in different aspects, most algorithms still face the dual challenges of convergence and diversity when simultaneously optimizing the three core objectives of productivity (completion time), resource balance (machine load) and environmental impact (total energy consumption). There is room for improving the algorithm’s ability regarding local fine search and the mechanism of population diversity maintenance. This provides a research opportunity for the improved algorithm proposed in this paper.

3. Multi-Objective Flexible Job-Shop Scheduling Model Incorporating Makespan, Machine Workload, and Energy Consumption

In this section, the multi-objective flexible job shop scheduling problem (MOFJSSP) is first described in detail. Then, the assumptions and relevant notations of the mathematical model are introduced. Finally, an optimization model for the MOFJSSP is established.

3.1. Problem Statement

The Flexible Job Shop Scheduling Problem (FJSSP) presents a significant resource allocation challenge, fundamentally concerned with the optimization of task assignment and sequencing under operational constraints. In FJSSP scenarios, we consider a set of $n$ jobs (denoted as J = $\left\{{\mathrm{J}}_1,{\mathrm{J}}_2,\dots ,{\mathrm{J}}_{\mathrm{i}},\dots ,{\mathrm{J}}_{\mathrm{n}}\right\}$ and m machines ($\mathrm{M}=\left\{{\mathrm{M}}_1,{\mathrm{M}}_2,\dots ,{\mathrm{M}}_{\mathrm{k}},\dots ,{\mathrm{M}}_{\mathrm{m}}\right\},\mathrm{k}\in \left[1,\mathrm{m}\right]$). Each job requires a sequence of operations for completion, with the number of operations varying across jobs. Critically, each operation exhibits processing flexibility, capable of being performed on a subset of available machines. The central objective is to jointly determine the optimal machine assignment for each operation and the processing sequence on each machine, ultimately aiming to optimize overall shop floor performance. Figure 1 illustrates a schematic diagram of FJSSP.

The Multi-Objective Flexible Job Shop Scheduling Problem (MOFJSSP) expands upon the traditional FJSSP by incorporating a broader spectrum of objectives. It moves beyond solely considering conventional economic metrics such as Makespan and processing costs, to also encompass green manufacturing imperatives, notably energy consumption. An effective scheduling strategy within the MOFJSSP context can synergistically enhance production efficiency, curtail shop floor energy consumption, elevate product quality, and ultimately advance a company’s intelligent manufacturing capabilities.

The multi-objective flexible job shop scheduling model considered in this study rests upon the following foundational assumptions:

(1)

All jobs are assumed to have equal priority; job priorities and processing times are predetermined.

(2)

All machines are assumed to be initially available and reliable, and the potential for machine breakdowns or other disruptions is neglected.

(3)

Once the processing of a job commences, it must be completed without interruption (non-preemptive).

(4)

Within any given time period, each machine can process at most one job, and each job can be processed on only one machine from its eligible machine set.

(5)

The influence of job transportation time between machines within the shop floor is neglected.

Table 2. Notation.

Symbol	Definition	Unit/Dimension
Parameters
$n$	Number of jobs	dimensionless
$m$	Number of machines	dimensionless
$n_i$	Number of operations in job i	dimensionless
$O_{i,j}$	The j-th operation of job i	dimensionless
$J_i$	Set of operations for job i	dimensionless
$M_{i,j}$	Set of eligible machines for operation $O_{i,j}$	dimensionless
L	A sufficiently large positive number	time unit (hours)
Popsize	Population size	dimensionless
$P_0$	Initial Population	dimensionless
w	Load correction weight	dimensionless
$P_k$	Unit time energy consumption of machine $M_k$ during processing	energy unit per time unit(kWh/h)
$I_k$	Unit time energy consumption of machine $M_k$ when idle	energy unit per time unit(kWh/h)
Chrom	Chromosome (individual representation)	dimensionless
$P_t$	Population of the t-th generation	dimensionless
$Q_t$	Offspring populations generated by selection, crossover, and mutation operations	dimensionless
$R_t$	The merged candidate set of parent and offspring generations	dimensionless
$P_{t+1}$	The next generation population obtained through elitist selection	dimensionless
$P^{*}$	The next generation population obtained through elitist selection	dimensionless
$M^{*}$	The Chosen Machine	dimensionless
variables
$x_{i,j,k}$	Binary variable, equals 1 if operation $O_{i,j}$ is processed on machine Mk, and 0 otherwise.	binary (0/1)
$t_{i,j,k}$ ${\tilde{t}}_{i,j,k}$	Processing time of operation $O_{i,j}$ on machine $M_k$ Adjust processing time (considering load balancing)	time unit (hours)
$s_{i,j}$	Start time of operation $O_{i,j}$	time unit (hours)
$f_{i,j}$	Completion time of operation $O_{i,j}$	time unit (hours)
$L_k$	Machine $M_k$ Current Load	time unit (hours)
$C_i$	Completion time of job i	time unit (hours)
$p_c$	Cross-probability	dimensionless
$p_m$	Mutation probability	dimensionless
$Makespan$	Maximum completion time	time unit (hours)
$MLoad$	Total machine workload (sum of processing times)	time unit (hours)
$EC$	Energy consumption	energy unit(kWh/h)

summarizes all symbols used in this study.

3.2. Objective Functions

(1)

Makespan minimization: In the context of the Flexible Job Shop Scheduling Problem (FJSSP), minimizing the Makespan is a primary objective. The Makespan represents the total time elapsed from the start of the first operation to the completion of the last operation across all jobs in a parallel processing environment. This can be mathematically represented as:

$$f1=Makespan=\max \left(C_i\right|i=\mathrm{1,2},\dots ,n)$$

(1)

(2)

Optimizing Machine workload: In the Flexible Job Shop Scheduling Problem (FJSSP), machine load characterizes the amount of processing burden imposed on each machine. The machine load metric can be quantified mathematically using the following expressions:

$$f2=MLoad={\sum }_{i=1}^n {\sum }_{j=1}^{n_i} {\sum }_{k=1}^m t_{i,j,k}·x_{i,j,k}$$

(2)

(3)

Minimizing Energy consumption as a Green Metric: In the Flexible Job Shop Scheduling Problem (FJSSP), the minimization of energy consumption serves as a critical green metric, focusing on curtailing energy expenditure during manufacturing processes. The unit of energy consumption is kW·h

$$f3=EC=E_w+E_l$$

(3)

$$E_w=\sum _{k=1}^m \sum _{i=1}^n \sum _{j=1}^{ni} {P_k·t}_{i,j,k}·x_{i,j,k}$$

(4)

$$E_l=\sum _{k=1}^m I_k.\left(Makespan-\sum _{i=1}^n \sum _{j=1}^{ni} t_{i,j,k}·x_{i,j,k}\right)$$

(5)

$EC$ denotes the total energy consumption, partitioned into energy consumed during processing $Ew$ and energy consumed during machine idling $El$.

$$x_{i,j,k}=\left\{\begin{array}{l}1\hspace{0.25em}\hspace{0.25em}\hspace{0.25em}\hspace{0.25em} \text{operation} O_{i,j} \text{is processed on machine} M_k\\ 0\hspace{0.25em}\hspace{0.25em}\hspace{0.25em}\hspace{0.25em} \mathrm{otherwise} \end{array}\right.$$

(6)

$$y_{i,j,x,y,k}=\left\{\begin{array}{l}1\hspace{0.25em}\hspace{0.25em}\hspace{0.25em}\hspace{0.25em} \text{On machine} M_k, \text{operation} O_{i,j} \text{is processed prior to operation} O_{x,y}. \\ 0\hspace{0.25em}\hspace{0.25em}\hspace{0.25em}\hspace{0.25em} otherwise\end{array}\right.$$

(7)

$$s_{i,j}+x_{i,j,k}.t_{i,j,k}=f_{i,j}$$

(8)

$$f_{i,j}⩽s_{i,j+1}$$

(9)

$$f_{i,J_i}⩽Makespan$$

(10)

$$s_{i,j}+x_{i,j,k}.t_{i,j,k}⩽s_{x,y}+L·\left(1-y_{i,j,x,y,k}\right)$$

(11)

$$\sum _{\mathrm{k}\in \mathrm{M}\mathrm{i},\mathrm{j}} x_{i,j,k}=1$$

(12)

$$s_{i,j}⩾0$$

(13)

$$f_{i,j}⩾0$$

(14)

Equation (6) defines the machine selection variable, a binary variable that equals 1 if operation $O_{i,j}$ is processed on machine $Mk$, and 0 otherwise. Equation (7) defines the operation sequencing variable, a binary variable indicating the processing order of operations on the same machine; it equals 1 if operation $O_{i,j}$ precedes operation $O_{x,y}$ on the same machine, and 0 otherwise. Equation (8) enforces the non-preemption constraint, ensuring that once an operation commences processing, it must be completed without interruption. Equation (9) ensures job operation precedence, stipulating that operations within each job must be processed strictly according to their predefined sequence. Equation (10) defines the Makespan, constraining the completion time of any job i ($C_i$) to be less than or equal to the Makespan. Equation (11) ensures operation sequencing on the same machine, preventing operation overlap when processed on the same machine. Equation (12) prevents simultaneous processing of an operation on multiple machines. Equations (13) and (14) impose non-negativity constraints on start and completion times, ensuring that both operation start times ($s_{i,j}$) and completion times ($f_{i,j}$) are non-negative.

4. KTNSGA-II Algorithm Description

In this study, a KTNSGA-II algorithm is proposed for solving the proposed multi-objective flexible job shop scheduling problem. In this section, the initialization strategy is presented first, then the improved crossover operator strategy and KNN crowding computation are presented, and finally the improved tabu search strategy is presented. Figure 2 illustrates the overall framework of the method proposed in this study. Algorithm 1 is the pseudocode for the KTNSGA-II algorithm.

Algorithm 1 KTNSGA-II for MOFJSSP

Input:         J = {$J_1, J_2, \dots , J_n$}                 // Set of jobs         M = {$M_1, M_2, \dots , M_m$}       // Set of machines         T = {$t_{i,j,k}$}                               // Processing time for operation $O_{i,j}$ on machine $M_k$         Popsize                              // Population size         max_gen                             // Maximum number of iterations         $p_c, p_m$                                // Crossover and mutation probabilities Output:         Pareto set P*                    // Pareto optimal solution set 1:    // Step 1: Initialization 2:    $P_0$ ← GenerateInitialPopulation(Popsize)                using Machine-workLoad-Balancing Initialization 3:    Evaluate ($P_0$)                                 // Compute objective values (Makespam, WL, EC) 4:    gen ← 0                                                     // Iteration counter 5:    // Step 2: Evolutionary Loop 6:    while (gen < max_gen) do 7:              $Q_t$ ← ∅ 8:              while (|$Q_t$| < Popsize) do 9:                        // Parent selection 10:                      (p1, p2) ← EliteSelection($P_t$) 11:                      // Adaptive Job Crossover (AJX) 12:                      c1, c2 ← AdaptiveJobCrossover(p1, p2, $p_c$)                                   // Dynamically select job segment crossover method, adaptively adjusting crossover probability based on objective feedback 13:                      // Mutation 14:                      c1 ← Mutation(c1, $p_m$) 15:                      c2 ← Mutation(c2, $p_m$) 16:                      $Q_t$ ← $Q_t$ ∪ {c1, c2} 17:              end while 18:              Evaluate ($Q_t$) 19:              // Step 3: Environmental Selection 20:              $R_t$ ← $P_t$ ∪ $Q_t$ 21:              $P_{t+1}$ ← ElitistSelection($R_t$, PopSize)                                 // Based on fast non-dominated sorting and k-nearest neighbor crowding degree 22:    Tabu search 23:              t ← t + 1 24:    end while 25:    // Step 4: Output 26:    return P* = NonDominatedSolutions($P_t$)

4.1. Encoding and Decoding

The algorithm employs a dual-vector representation method [41], comprising a Machine Selection (MS) component and an Operations Sequencing (OS) component. In the MS component, each gene position is represented by an integer, arranged according to the processing sequence of jobs and their operations. Each integer denotes the sequential number of the selected processing machine within the set of available machines for the current operation. The OS component directly encodes job numbers, where the sequence of job number appearances indicates the machining order of workpiece processes.

In the dual-vector representation method, both the MS and OS chromosome lengths are equal to the total number of operations. To illustrate the encoding scheme, Figure 3 demonstrates the dual-vector representation for a problem involving three jobs, eight operations, and four machines. The OS sequence 13233221 represents the operation sequence [O_1,1, O_3,1, O_2,1, O_3,2, O_3,3, O_2,2, O_2,3, O_1,2]. The first 1 in the OS sequence denotes the first operation O_1,1 of Job 1, the second 1 denotes the second operation O_1,2 of Job 1, and so on. The MS sequence 31223412 indicates the index of the corresponding operation within the corresponding machine set. For example, the 3 corresponding to operation O_1,1 indicates that operation O_1,1 is processed on machine 4.

The decoding process converts the aforementioned MSOS encoding into an actual scheduling plan, with the main steps as follows:

• Determine the processing sequence of operations based on the operation codes: Iterate through the operation code array to sequentially identify the jobs to be processed and their corresponding operations.
• Determine the processing machine for each operation based on the machine code: Based on the current operation and the machine code, determine which machine will process that operation.
• Calculate the start and end times for each operation: Based on the machine’s available time and the processing time for each operation, calculate the start and end times for each operation.

It should be noted that the feasibility of solutions is inherently preserved by the adopted MSOS encoding scheme. Specifically, precedence constraints among operations are guaranteed by the OS component, where each job appears exactly as many times as its number of operations, and the decoding process always schedules operations in the order of their occurrences. Therefore, any crossover or mutation applied to the OS chromosome that maintains the relative ordering of job appearances will not violate technological constraints.

Meanwhile, the MS component only selects machine indices from the predefined feasible machine set of each operation. During crossover and mutation, machine genes are exchanged or altered within their allowable ranges, ensuring that each operation is always assigned to a valid machine. Consequently, no additional repair mechanism is required, and all offspring generated by the genetic operators remain feasible by construction.

4.2. Initialization Strategy, Machine Workload Balancing

The initialization strategy is important in the evolution algorithms which can affect the convergence speed and the quality of the final solution [42]. Traditional initialization methods for FJSSP are usually carried out by randomly generating sequences of processes and machine assignments, but this approach often leads to low-quality initial solutions, which affects the performance of the algorithm. To address this problem, this paper proposes an initialization method based on machine load balancing, which aims to generate initial solutions with a more uniform distribution, thus reducing the degree of machine load imbalance from the outset.

Specifically, all process sets are first randomly permuted to ensure diversity in job scheduling sequences. Then, for each process $O_{i,j}$, its set of available machines $M_{i,j}$ and corresponding processing time set {$t_{i,j,k}$} are determined. When selecting machines, not only is the process’s own processing time considered, but a correction term based on the machine’s current load $L_k$ is also introduced:

$${\tilde{t}}_{i,j,k}=t_{i,j,k}+w·L_k,{ M}_k\in M_{i,j}$$

(15)

where w is the weighting coefficient (set to 0.5 in this study), used to balance the effects of processing time and machine load. The machine with the smallest corrected processing time is ultimately selected:

$$M^{*}=\arg \underset{M_k\in M_{i,j}}{min} {\tilde{t}}_{i,j,k}$$

(16)

After completing the assignment, update the load for this machine:

$$L_k=L_k+t_{i,j,k}$$

(17)

Through this mechanism, the initialization phase can effectively balance the load across machines while ensuring diversity, thereby enhancing the algorithm’s global search capability. Algorithm 2 demonstrates the machine load balancing initialization strategy:

Algorithm 2 Initialization with Machine Load Balancing

Input:         J = {$J_1, J_2, \dots , J_n$}                       # Job set         M = {$M_1, M_2, \dots , M_m$}              # Set of machines       $t_{i,j,k}$                                               # Processing time of operation $O_{ij}$ on machine $M_k$      $M_{ij}$                                                # Set of available machines for operation $O_{i,j}$         w                                               # Balancing parameter 1:    $P_0$ ← ∅        // Initial population 2:    for p = 1 to PopSize do          // Population size PopSize 3:              Chrom ← ∅ 4:              Initialize $L_k$ = 0, $\forall M_k\in M$ 5:              JobSequence ← RandomPermutation(all operations $O_{i,j}$) 6:              for each operation${ O}_{i,j}$ in JobSequence do 7:                      Machines ← $M_{i,j}$ 8:                        for each $M_k$ ∈ Machines do 9:                                  Compute ${\tilde{t}}_{i,j,k}=t_{i,j,k}+w·L_k$ 10:                      end for 11:                      Select M* = argmin{$M_k$ ∈Machines} ${\tilde{t}}_{i,j,k}$ 12:                      Assign $O_{i,j}$ to M* 13:                      Update $L_M$* ← $L_M$* + $t_{i,j,k}$ 14:              end for 15:              Chrom ← Encode(JobSequence, machine assignments) 16:              $P_0$ ← $P_0$ ∪ {Chrom} 17:    end for 18:    return ${ P}_0$

4.3. Crossover Operations

In order to effectively balance the algorithm’s global exploration capability and local exploitation capability, an adaptive job subset crossover (AJSC) operator is designed in this study. The core idea of this operator is to dynamically adjust the strength of the crossover operation according to the number of evolutionary generations. In the early stage of evolution, a relatively large subset of jobs is selected for crossover, thus promoting extensive information exchange between parent generations, enhancing population diversity, and strengthening the global search capability. As the iteration progresses, the size of the crossover subset is gradually reduced to preserve high-quality genetic fragments and shift the search to fine-grained local exploitation, focusing on the optimization of elite solutions. In this way, premature convergence is avoided while the accuracy of the solutions is improved.

The crossover operator acts on two parent individuals P1 and P2, whose operation codes are chrom_L1 and chrom_L2 respectively, and generates two child individuals C1 and C2. The specific process is described below:

• Generate a random job subset

Extract a set of unique job IDs Num = {$J_1,\dots ,J_n$} from the parent generation chrom_L1, then randomly shuffle the sequence Num. Calculate the adaptive ratio α based on the current iteration number gen and the maximum iteration number max_gen.

$$\alpha =0.2·\left(2-{\displaystyle \frac{gen}{\mathrm{m}\mathrm{a}\mathrm{x}\_gen}}\right)$$

(18)

2.

Partition the job into subsets

and determine the partition index accordingly, thereby obtaining two complementary job subsets:

$$\mathrm{i}\mathrm{n}\mathrm{d}\mathrm{e}\mathrm{x}=\left[\begin{array}{c}\alpha \times \left(\mathrm{U}-\mathrm{L}+1\right)+\mathrm{L}-1\end{array}\right]$$

(19)

where L = 1 is the lower bound on the subset size and U = |Num| − 1 is the upper bound.

$$JobSe{t}_1=\left\{J_1,\dots ,J_{index}\right\}$$

(20)

$$JobSe{t}_2=Num\setminus JobSe{t}_1$$

(21)

3.

Generate offspring

During crossover, offspring $C_1$ and $C_2$ are generated as follows:

(1)

If an operation belonging to JobSet1 is present in the parent process sequence, its position is retained directly;

(2)

Otherwise, it is marked as vacant (−1) and will be filled later by an unselected process sequence from the other parent.

The two offspring $C_1$ and $C_2$ generated by this strategy not only preserve the parent’s favorable genes but also introduce randomness, helping to avoid premature convergence.

4.4. Mutation Strategy

In the research and application of the KTNSGA-II algorithm, mutation operations serve as one of the core mechanisms. By introducing new genetic diversity, they sustain the evolutionary potential of the population and prevent the algorithm from prematurely converging to local optima.

Machine mutation involves selecting an operation and replacing its processing machine with another machine from the set of available processing machines, thereby introducing diversity.

The operation sequence component employs reverse mutation. The reverse mutation function is a genetic operator designed for local search space exploration on chromosomes encoded as operation sequences. This function randomly selects a contiguous segment of operations within a sequence and reverses its order to generate a new sequence. Its design accounts for the critical importance of operation sequence in workshop scheduling problems, enabling local exploration by altering the execution order of operations.

4.5. Elite Selection Strategy

Elite selection strategy is a key component in multi-objective evolutionary algorithms, and its main goal is to retain the best individuals for the next generation, thus ensuring the convergence of the algorithm and improving the search efficiency. In this study, an elite selection strategy based on fast non-dominated sorting and k-nearest-neighbor crowding distance calculation is implemented. The strategy aims to select more competitive individuals from the merged parent and offspring populations, effectively guiding the search process while maintaining the diversity of the population.

4.5.1. K-Nearest Neighbors Based Crowding Distance Calculation

The KNN crowding strategy aims to maintain the diversity of the population by evaluating the sparsity of individuals in the objective space based on the neighborhood density. If the number of non-dominated solutions is smaller than k, the value of k is adaptively set to N − 1, where N denotes the number of solutions on the Pareto front.

Let the population size be N and the number of objective functions be M. The set of points in the objective space can be represented as P = {$f_1, f_2, \dots , f_N$}, $f_i$ = ($f_{ 1}^i, f_{ 2}^i,\dots , f_{ M}^i$). For individual i, the KNN crowding is computed as follows:

• Distance metric: The Euclidean distance between individuals i and j in the target space is defined as:

  $$d_{ij}=\sqrt{\sum _{m=1}^M (f_m^i-f_m^j{)}^2 }$$

  (22)
• K-Nearest Neighbors Determination: For each individual i, construct the set of its k nearest neighbors $N_k$= {j|j ≠ i, d_ij is among the k smallest distances}
• Crowding calculation: the KNN crowding distance of individual i is defined as its average distance from its k nearest neighbors:

  $$d_i^{knn}={\displaystyle \frac{1}{k}}\sum _{j\in N_k\left(i\right)} d_{ij}$$

  (23)
• Selection Criteria: In the elite selection phase, individuals with larger $d_i^{knn}$, those located in relatively sparse regions in the target space, are prioritized to enhance the diversity of the solution set.

4.5.2. Elite Selection Strategy Process

• Population merger: The parent population $P_t$ is merged with the offspring population $Q_t$ to form a temporary population Rt of size 2N, where N is the population size.

  $$R_t=P_t\cup Q_t$$

  (24)
• Fast non-dominated sorting: Perform non-dominated sorting on Rt to obtain a series of non-dominated fronts F = {$F_1, F_2, \dots , F_o$}, where $F_1$ denotes the first non-dominated front.
• Determination of reserved fronts: Populate the next generation population $P_{t+1}$ step by step until a front Fk satisfies the condition.

  $$\left|\bigcup _{i=1}^{k-1} F_i\right|<N\le \left|\bigcup _{i=1}^k F_i\right|$$

  (25)
• K-Nearest Neighbors Distance Calculation for Boundary front: For boundary frontier $F_k$ calculate KNN distance for each individual.
• Selection of individuals from the boundary front: If ∣${\bigcup }_{ i=1}^{k-1} F_i$∣ < N, select N − ∣${\bigcup }_{ i=1}^{k-1} F_i$∣ individuals from the boundary front $F_k$ to populate the next generation of the population. The selection criterion prioritizes individuals with large KNN distances—those located in relatively sparse regions in the target space—to maintain population diversity.
• Next generation population formation: the next generation population Pt + 1 is then formed:

  $$P_{t+1}=\bigcup _{i=1}^{k-1} F_i\cup \mathrm{S}\mathrm{e}\mathrm{l}\mathrm{e}\mathrm{c}\mathrm{t}\_\mathrm{b}\mathrm{y}\_\mathrm{K}\mathrm{N}\mathrm{N}\left(F_k,N-\left|\bigcup _{i=1}^{k-1} F_i\right|\right)$$

  (26)

The elite selection strategy is a key component of the KTNSGA-II algorithm. By combining fast non-dominated sorting with KNN-based crowding estimation, the KNN method evaluates the average distance to the k nearest neighbors. This allows the algorithm to more accurately identify densely populated regions and promote solutions located in sparse areas, thereby maintaining a more uniform distribution along the Pareto front and effectively improving population diversity. It ensures the retention of high-quality solutions while facilitating exploration in sparse regions of the search space, thus providing a strong guarantee for finding high-quality Pareto-optimal solutions.

4.5.3. Computational Complexity Analysis

Let N denote the population size and M the number of objectives. In standard NSGA-II, the dominant computational cost comes from non-dominated sorting, which has a time complexity of O(MN²), and the crowding distance calculation, which requires sorting individuals for each objective and thus incurs a cost of O(MNlogN).

In the proposed algorithm, the conventional crowding distance is replaced by a K-nearest neighbor (KNN) based congestion distance. For each individual on the Pareto front, the KNN distance computation requires evaluating pairwise distances to other individuals in the same front, resulting in a worst-case complexity of O(N²). Therefore, the overall complexity of the proposed method becomes O(MN² + N²), which remains quadratic with respect to the population size.

It is worth noting that the parameter k is set to a small constant (k = 5) and the KNN-based distance is only computed for individuals in the current Pareto front. Consequently, the additional computational overhead introduced by the KNN mechanism is limited and does not change the asymptotic order of complexity compared with standard NSGA-II.

In exchange for this moderate increase in computational cost, the KNN congestion distance provides a more accurate estimation of local solution density, especially in irregular or discontinuous Pareto fronts. This leads to improved solution diversity and convergence quality, as demonstrated in the experimental results.

4.6. Adaptive Neighborhood Tabu Search for Local Search

To enhance the local search capability of the proposed algorithm in solving the flexible job shop scheduling problem, an adaptive neighborhood tabu search (TS) is incorporated into the NSGA-II framework. Specifically, TS is applied only to the non-dominated solutions on the current Pareto front at the end of each generation, aiming to further refine solution quality and improve the convergence toward the true Pareto front.

(1)

Neighborhood Structure Definition:

The key to tabu search lies in defining a suitable neighborhood structure. In this study, the neighborhood solution is generated by exchanging the machine assignments of two processes. Specifically, given a scheduling S = (J, M), where J denotes a sequence of jobs and M denotes a machine allocation, the neighborhood solution S′ = (J, M′) is obtained by exchanging the machine allocations of the two processes and is accepted only if the generated solution satisfies all feasibility constraints.

To improve the search efficiency, an adaptive neighborhood scale is introduced:

$$N_s=max\left(N_{min},⌊N_{init}-\left(N_{init}-N_{min}\right)\ast \left({\displaystyle \frac{Tgen}{Tma{x}_{-}gen}}\right)⌋\right)$$

(27)

where Ns is the current neighborhood size, $N_{init}$ = |J|/2, $N_{min}=2$, Tgen is the current iteration count for the tabu search, and Tmax_gen is the maximum iteration count.

(2)

Tabu List and Tabu Length:

To avoid early convergence of populations, a tabu list T is maintained for recording recent move operations. The tabu length is fixed to L = 10 in this study. When |T| > L, the earliest move operation is removed. Each move operation is defined as a change in machine assignment: ∆M: (J, M) → (J, M′)

(3)

Stopping criterion:

The tabu search terminates when the maximum number of iterations Tmax_gen is reached.

(4)

Algorithm procedure:

• Initialize the current solution as input solution S = (J, M) and make the optimal solution $S_{best}$= S.
• Initialize the tabu list T = ∅.
• For Tgen = 1 to Tmax_gen:

  (a)

  Generate the set of solutions $N_S$ in the neighborhood of the current solution S.

  (b)

  Select a solution S′ ∈ N(S) that is not in.

  (c)

  If the fitness of S′ is better than $S_{best}$, update $S_{best}$= S′.

  (d)

  Update the current solution S = S′.

  (e)

  Add the move that produced S′ to T; if |T| > L, remove the earliest added move.

• Return the optimal solution $S_{best}$.

(5)

Summary: The local optimization strategy of Pareto frontiers based on tabu search proposed in this paper integrates TS algorithm into NSGA-II, aiming to combine the advantages of both to improve the solution efficiency and quality of FJSSP. The local search capability of TS can effectively refine the Pareto frontiers obtained by NSGA-II, making its solution set closer to the real Pareto frontiers and improving the distribution of solutions. The tabu list mechanism helps to avoid falling into local optimality, thus improving the search efficiency and robustness of the algorithm.

5. Experimental Results and Analysis

In this section, the proposed KTNSGA-II algorithm is experimentally analyzed to evaluate its performance. The algorithm is implemented in Python 3.9 and runs on a laptop configured with a 13th generation Intel i5 processor (2.5 GHz), 8 GB RAM and running Windows 11. The experimental analysis includes the following two main aspects:

• Evaluating the effectiveness of the proposed improvement strategies;
• Verifying the overall performance of the KTNSGA-II algorithm on standard benchmark examples.

The main parameters are as follows: Popsize = 200, number of iterations max_gen = 200, crossover probability $p_c$ = 0.9, mutation probability $p_m$ = 0.1, K-nearest neighbor parameter k = 5, number of tabu search iterations Tmax_gen = 50, and length of tabu list table L = 10. In this study, the unit energy consumption of machines is considered constant, and the value of energy consumption coefficients in the process is in the range of 0.5–2.0, and the energy consumption coefficient in idle state is 0.1–0.4. In the experiment, all comparison algorithms used identical base parameters, with each instance running independently 20 times.

5.1. Evaluation Metrics

To comprehensively evaluate the quality of the generated Pareto front solution set, three different metrics are employed in this study: Spacing (SP), Diversity Metric (DM), and Hypervolume (HV), which assess the Pareto front from different perspectives. SP, DM and HV are dimensionless indicators.

SP Metric: The SP metric reflects the uniformity of the distribution of solutions in the solution set by calculating the deviation of the distances between neighboring solutions. A smaller SP value indicates that the obtained Pareto front solutions are more evenly distributed in the objective space, corresponding to better diversity. The SP metric is defined as follows, di denotes the distance between the i-th non-dominated solution and its nearest neighbor in the objective space.

$$SP=\sqrt{{\displaystyle \frac{1}{n-1}}\sum _{i=1}^n (d_i-\overline{d}{)}^2}$$

(28)

Diversification Metric (DM): The DM is used to measure the extent of spread or expansion along the boundaries of the generated non-dominated solutions. Let fa denote the value of the a-th objective function, and M be the number of objectives. A higher DM value indicates better diversity. The DM is defined as follows:

$$DM=\sqrt{\sum _{a=1}^M {\left(max\left(f_a\right)-min\left(f_a\right)\right)}^2}$$

(29)

Hypervolume Metric (HV): The HV, evaluates both the convergence and diversity of a solution set. It is a comprehensive measure of the quality of the Pareto front, considering simultaneously how close the solutions are to the true Pareto front (convergence) and how well they are spread in the objective space (diversity). A larger HV value indicates better convergence and diversity, corresponding to superior algorithm performance. Since there is no standard HV reference point for this type of research, the HV reference point in this study was obtained by running these algorithms independently 20 times on each instance and then taking the maximum value across all dimensions and multiplying it by 1.1.

5.2. Validating the Effectiveness of the Four Improvement Strategies

To evaluate the effectiveness of the four improvement strategies proposed in Section 4, comparative experiments were conducted on the Fattahi [43] benchmark set mfjs01-mfjs10. The comparison involved the standard NSGA-II, NSGA-II+ML (with machine workload balancing), NSGA-II+ML+K (with KNN-based crowding estimation), NSGA-II+ML+K+Ad (with adaptive job-level crossover subset), and NSGA-II+ML+K+Ad+Tabu (with tabu search). The experimental results are summarized in

Table 3. Verifying the effectiveness of various strategies.

Benchmark Instances	NSGA-II			NSGA-II+ML			NSGA-II+ML+K			NSGA-II+ML+K+Ad			NSGA-II+ML+K+Ad+Tabu
	SP	DM	HV	SP	DM	HV	SP	DM	HV	SP	DM	HV	SP	DM	HV
mfjs01: 5 × 6	10.91	406.76	0.77	11.0	400.75	0.83	10.8	437.3	0.84	10.02	368.65	0.89	9.67	422.44	0.95
mfjs02: 5 × 7	15.61	385.48	0.71	12.12	488.44	0.80	8.69	486.16	0.88	8.52	486.16	0.88	7.88	576.23	0.94
mfjs03: 6 × 7	11.21	479.15	0.70	10.60	487.52	0.84	13.07	576.82	0.86	10.81	579.64	0.88	8.35	596.44	0.94
mfjs04: 7 × 7	28.75	645.52	0.77	28.47	748.53	0.87	22.86	658.37	0.87	23.45	817.95	0.90	21.55	824.18	1.03
mfjs05: 7 × 7	12.08	429.14	0.82	11.97	786.21	0.84	13.69	786.30	0.85	12.84	707.99	0.84	11.30	863.66	0.88
mfjs06: 8 × 7	11.61	712.92	0.82	10.66	739.60	0.82	11.84	763.33	0.84	10.49	774.68	0.87	10.47	983.29	0.97
mfjs07: 8 × 7	14.72	686.04	0.78	13.36	759.63	0.82	12.70	839.46	0.84	11.65	778.68	0.87	10.29	992.38	0.94
mfjs08: 9 × 8	16.25	611.07	0.79	10.87	652.59	0.85	14.14	699.93	0.88	13.90	784.44	0.88	12.65	837.48	1.03
mfjs09: 11 × 8	19.60	656.84	0.77	14.35	853.60	0.90	18.21	1018.04	0.81	16.19	1060.61	0.92	10.85	1288.83	1.07
mfjs10: 12 × 8	23.26	495.46	0.64	21.18	975.17	0.80	22.63	849.76	0.85	20.96	977.24	0.86	15.17	1287.95	0.97

Note: Bold values indicate the superior performance among the compared algorithms for each metric.

.

The blackened parts indicate the superior solutions, and the table shows that after the introduction of the load balancing mechanism, compared with the baseline NSGA-II shows an upward trend in all the indexes. Especially in DM and HV, their values generally increase, indicating that the load balancing strategy effectively enhances the diversity and coverage of the solutions in the Pareto front; the SP value usually decreases, which predicts that the uniformity of the solution distribution is improved. The performance of the algorithm is further optimized with the addition of KNN congestion. Although the SP and DM boosts may fluctuate on some instances, the HV values are generally improved, which clearly indicates that KNN further extends the algorithm’s Pareto frontier exploration capability. With the introduction of the adaptive mechanism crossover, lower SP values and higher HV values are achieved on most instances, further improving the convergence and coverage of the solution set. The improvement effect of the DMs has an overall positive trend although there are instance differences. Finally, the algorithm after incorporating all the improvement strategies shows the most excellent and consistent performance, as shown in the table, which achieves the lowest SP, the highest DM, and the highest HV on almost all the tested instances. The key contribution of the four improvement strategies in solving the multi-objective flexible job shop scheduling problem and their efficient synergy are strongly confirmed, which helps to improve the quality, diversity and convergence of the final Pareto solution set.

5.3. Comparative Experiments with Other Algorithms

To demonstrate the effectiveness of the proposed KTNSGA-II algorithm, comparative experiments were conducted against NSGA-III [44], NSGA-II, and MOEA/D on the standard benchmark set Brandimarte [45]. The experimental results are summarized in

Table 4. Algorithm performance comparison (SP, DM, HV).

Benchmark Instances	KTNSGA-II			NSGA-II			NSGA-III			MOEA/D
	SP	DM	HV	SP	DM	HV	SP	DM	HV	SP	DM	HV
M1: 10 × 6	0.37	20.86	0.93	0.42	18.95	0.73	0.57	15.72	0.76	0.41	19.12	0.85
M2: 10 × 6	0.64	9.87	0.76	0.98	5.45	0.44	0.32	7.42	0.45	0.56	8.13	0.71
M3: 15 × 8	2.55	165.95	0.92	3.58	140.57	0.83	4.14	124.21	0.81	3.40	145.10	0.88
M4: 15 × 8	1.44	78.30	0.87	2.31	53.62	0.91	3.05	60.81	0.87	1.91	58.12	0.92
M5: 15 × 4	2.22	35.46	0.82	2.94	31.91	0.66	3.88	33.58	0.68	2.78	30.20	0.84
M6: 10 × 10	0.97	40.24	0.81	1.30	29.46	0.70	1.01	28.82	0.74	1.21	34.87	0.73
M7: 20 × 5	1.74	73.65	1.06	2.17	71.50	0.78	1.88	56.96	0.81	1.95	61.45	0.81
M8: 20 × 10	0.73	60.19	0.89	2.43	182.56	0.60	1.87	173.62	0.62	1.80	118.73	0.73
M9: 20 × 10	3.83	168.11	0.97	7.92	167.40	0.93	8.50	123.62	0.93	6.17	148.43	0.91
M10: 20 × 15	3.10	160.49	0.85	3.15	84.21	0.79	2.22	84.21	0.89	2.10	101.48	0.82
M11: 30 × 5	3.87	237.82	0.98	5.00	227.01	0.92	7.48	218.44	0.96	6.27	208.10	0.93
M12: 30 × 10	5.79	179.04	0.91	6.12	213.16	0.63	6.12	275.90	0.74	7.14	163.60	0.80
M13: 30 × 10	3.83	380.28	0.96	4.17	336.51	0.83	4.34	347.69	0.81	3.97	280.97	0.79
M14: 30 × 15	5.30	315.95	0.95	6.78	211.07	0.84	5.84	177.11	0.94	7.21	267.40	0.88
M15: 30 × 15	5.34	401.63	0.96	6.18	357.39	0.89	7.66	228.63	0.84	5.94	328.17	0.86

Note: SP (lower values are better); DM (higher values are better); HV (higher values are better); bold indicates optimal values.

and

Table 5. Algorithm performance comparison (f1, f2, f3).

Benchmark Instances	KTNSGA-II			NSGA-II			NSGA-III			MOEA/D
	f1	f2	f3	f1	f2	f3	f1	f2	f3	f1	f2	f3
M1: 10 × 6	42	161	217	43	159	219.8	42	164	235.3	42	163	219.5
M2: 10 × 6	29	144	186.4	31	143	183.4	29	144	186.2	30	142	183.7
M3: 15 × 8	204	852	1072.8	213	870	1055.4	204	862	1090.8	204	868	1079.4
M4: 15 × 8	66	349	410	68	353	420.6	68	352.0	424.2	68	350	418.2
M5: 15 × 4	173	685	854.7	179	681	855.1	175	683	856.4	174	686	855.8
M6: 10 × 10	74	370	516.8	77	371	521.5	74	373	517.9	74	372	521.3
M7: 20 × 5	144	675	835.9	150	680	846.8	144	674	836.6	146	678	838.2
M8: 20 × 10	523	2530	3669.7	523	2532	3693	523	2530	3682.5	523	2532	3691.2
M9: 20 × 10	338	2278	3061.7	350	2307	3101.1	354	2297	3106.2	346	2286	3089.5
M10: 20 × 15	247	1971	2484	280	1930	2535.9	256	1945	2532.3	251	1986	2522.0
M11: 30 × 5	624	3023	3725.4	679	3018	3744.2	675	3028	3712.2	658	3037	3745.2
M12: 30 × 10	524	3298	4398.1	569	3254	4567.7	572	3217	4400.1	538	3286	4423.6
M13: 30 × 10	488	3647	4720	513	3666	4750.8	501	3719	4801.6	498	3672	4736.4
M14: 30 × 15	694	5149	6884.1	707	5165	7033.9	694	5176	7170	698	5168	7054.2
M15: 30 × 15	465	4423	5765.5	500	4410	5811.6	496	4416	5918	485	4408	5837.1

Note: Bold values indicate the superior performance among the compared algorithms for each metric. f1, f2, f3 represent completion time, machine total load, and energy consumption, respectively.

. Table 4 shows the average results of each algorithm running independently 20 times, while Table 5 presents the optimal scheduling results after 20 runs. Figure 4 and Figure 5 illustrate the scheduling Gantt charts obtained by KTNSGA-II on instances MK05 and MK11, respectively.

As shown in the optimization metric results of Table 4, KTNSGA-II demonstrates significant advantages in solution spread (SP), diversity (DM), and hypervolume (HV) metrics. Specifically: For the SP metric, KTNSGA-II achieved optimal results in 13 out of 15 benchmark cases, accounting for approximately 87%, significantly outperforming NSGA-II (0 cases), NSGA-III (1 case), and MOEA/D (1 case). This indicates that the KTNSGA-II algorithm demonstrates markedly superior solution distribution uniformity compared to other algorithms. For the DM, KTNSGA-II achieved optimal results in 13 out of 15 benchmark cases, outperforming NSGA-II (1 case), NSGA-III (1 case), and MOEA/D (0 cases). This demonstrates that KTNSGA-II maintains superior solution set diversity across most cases. Regarding the HV, KTNSGA-II achieved optimal results in 12 out of 15 benchmark cases (80%), significantly outperforming NSGA-II (0), NSGA-III (1), and MOEA/D (2). This demonstrates that KTNSGA-II exhibits higher overall quality when approximating the true Pareto frontier. These results fully demonstrate that KTNSGA-II outperforms the comparison algorithms in three dimensions: convergence, solution set diversity, and overall Pareto frontier quality, enabling it to provide high-quality solution sets more stably. As shown in the optimization metric results of Table 5, regarding scheduling performance, KTNSGA-II outperformed NSGA-II, NSGA-III, and MOEA/D in most algorithms, achieving shorter completion times, lower energy consumption, and higher equipment utilization. This effectively reduced workshop idle time and enhanced production efficiency.

Figure 4 and Figure 5 demonstrate that the scheduling schemes obtained by the KTNSGA-II algorithm exhibit high machine utilization, compact inter-process scheduling, and minimal idle states. Results from small-to-medium-scale Brandimarte benchmark cases further validate the robustness and stability of KTNSGA-II in delivering high-quality Pareto solutions.

5.4. Performance on Large-Scale Test Sets

To further demonstrate the effectiveness of the proposed KTNSGA-II algorithm, three representative large-scale instances from the Behnke [46] benchmark set, namely sm04 1 (100 × 20), med04 1 (100 × 40), and lar04 1 (100 × 60), were selected for experimental evaluation. The corresponding results are reported in

Table 6. Algorithm performance comparison on Behnke instances (SP, DM, HV).

Benchmark Instances	KTNSGA-II			NSGA-II			NSGA-III			MOEA/D
	SP	DM	HV	SP	DM	HV	SP	DM	HV	SP	DM	HV
Sm04-1: 100 × 20	4.18	282.89	1.03	14.96	227.77	0.78	12.86	124.33	0.79	6.21	247.13	0.82
Med04-1: 100 × 40	4.90	380.35	1.04	5.31	264.31	0.83	12.84	292.26	0.77	5.28	324.15	0.79
Lar04-1: 100 × 60	4.37	532.65	1.14	10.08	231.68	0.76	6.25	271.23	0.85	5.58	397.14	0.90

Note: Bold values indicate the superior performance among the compared algorithms for each metric.

and

Table 7. Algorithm performance comparison on Behnke instances (f1, f2, f3).

Benchmark Instances	KTNSGA-II			NSGA-II			NSGA-III			MOEA/D
	f1	f2	f3	f1	f2	f3	f1	f2	f3	f1	f2	f3
Sm04-1: 100 × 20	615.0	6555.0	8336.0	629.0	6819.0	8581.0	637.0	6830	8423.1	627.0	6625	8425.4
Med04-1: 100 × 40	535.0	6098.0	8582.7	552.0	6472.0	8961.1	532.0	6387.0	8847.9	548.0	6322.0	8836.8
Lar04-1: 100 × 60	491.0	5945.0	9412.1	510.0	6361.0	9811.1	521.0	6244.0	9772.1	524.0	6232.0	9773.5

Note: Bold values indicate the superior performance among the compared algorithms for each metric.

.

Table 8. The runtime comparison of different algorithms on Behnke instances.

Benchmark Instances	KTNSGA-II	NSGA-II	NSGA-III	MOEA/D
Sm04-1: 100 × 20	268 s	254 s	256 s	252 s
Med04-1: 100 × 40	292 s	264 s	276 s	278 s
Lar04-1: 100 × 60	310 s	272 s	272 s	294 s

Note: Bold values indicate the superior performance among the compared algorithms for each metric.

shows the runtime comparison. Figure 6 displays a three-dimension scatter plot of the Pareto solution sets obtained by the four algorithms on instance Lar04-1. Figure 7, Figure 8 and Figure 9 display box plots of Makespan, MLoad, and EC generated by running the KTBSGA-II algorithm and the other three algorithms independently 20 times on instance Lar04-1.

Table 6 presents the comparative results of different algorithms in terms of SP, DM, and HV. Overall, KTNSGA-II demonstrates superior performance across all tested instances. On average, KTNSGA-II improves the SP, DM, and HV metrics by 39.72%, 57.54%, and 32.32%, respectively, compared with the competing algorithms, clearly indicating its advantage in both solution diversity and convergence quality. Specifically, KTNSGA-II consistently achieves the lowest SP values, reflecting a more uniform distribution of solutions; meanwhile, the highest DM values indicate a wider spread and better coverage of the Pareto front. In addition, the HV values obtained by KTNSGA-II are significantly higher than those of NSGA-II, NSGA-III, and MOEA/D, confirming that the proposed method can generate solution sets closer to the true Pareto frontiers. It can also be observed that the performance improvements of KTNSGA-II become more pronounced for large-scale instances, where the search space is larger and the scheduling problem exhibits higher flexibility and complexity. In such cases, the adaptive crossover and tabu-search-based local refinement mechanisms contribute more effectively to enhancing both diversity and convergence, whereas for small-scale instances, the performance differences among algorithms tend to be marginal due to the limited solution space.

Table 7 further reports the comparison results in terms of completion time, machine load, and total energy consumption. Overall, KTNSGA-II achieves the best or near-best objective values in the majority of test cases, demonstrating its capability to simultaneously shorten completion time, balance machine workload, and reduce energy consumption. In particular, the advantages of KTNSGA-II become increasingly evident as the problem scale grows. For medium- and large-scale instances, the proposed algorithm consistently outperforms NSGA-II, NSGA-III, and MOEA/D across all three objectives, indicating a stronger ability to handle complex trade-offs among time efficiency, load balancing, and energy efficiency. This improvement can be attributed to the synergistic effect of adaptive job-level crossover and Pareto-front-oriented tabu search, which enables effective global exploration while refining elite solutions. By contrast, for small-scale instances, the performance differences among algorithms are relatively limited due to the reduced search space and lower scheduling complexity, although KTNSGA-II still maintains competitive results. As shown in Figure 6, the Pareto solution set generated by KTNSGA-II (red dots) on the lar04-1 instance is generally closer to the ideal frontier, while exhibiting uniform distribution and broad coverage. Compared to NSGA-II, NSGA-III, and MOEA/D, KTNSGA-II achieves superior boundary solutions across all three objectives Makespan, MLoad, and EC while offering more trade-off options, demonstrating its superiority in multi-objective optimization. As shown in the boxplots of Figure 7, Figure 8 and Figure 9, KTNSGA-II achieved the lowest median and narrowest boxplots across all three metrics: Makespan, MLoad, and EC. This demonstrates that KTNSGA-II significantly outperforms other methods in all three performance indicators. Not only does it yield superior solutions, but it also exhibits higher stability, indicating its distinct advantages in addressing multi-objective flexible shop floor scheduling problems.

Table 8 reports the runtime comparison of different algorithms on large-scale Behnke benchmark instances. It can be observed that KTNSGA-II requires slightly more computational time than NSGA-II, NSGA-III, and MOEA/D. This is mainly due to the incorporation of adaptive crossover strategies and the tabu-search-based local refinement mechanism, which introduce additional computational overhead during the evolutionary process.

Nevertheless, the overall runtime of KTNSGA-II remains in the same order of magnitude as the compared algorithms, and the additional computational cost is relatively moderate. Considering the substantial improvements achieved in SP, DM, and HV, the trade-off between solution quality and computational time is acceptable. In particular, for large-scale and highly flexible scheduling instances, the proposed method demonstrates superior scalability and effectiveness, where enhanced diversity and convergence are more critical than a small increase in runtime.

5.5. Managerial Discussion and Policy Implications

This study investigates multi-objective flexible workshop scheduling by simultaneously considering total project duration, overall workshop load, and energy consumption. Beyond evaluating algorithm performance, experimental results provide valuable management insights for practical manufacturing systems.

From a management perspective, the proposed KTNSGA-II algorithm generates diverse and well-distributed Pareto fronts, enabling decision-makers to flexibly select scheduling schemes based on varying production priorities. For instance, when delivery deadlines are tight, the focus should be on minimizing total processing time. Conversely, in resource-constrained or energy-sensitive environments, workload balancing or energy-saving objectives should take precedence.

Furthermore, experimental results demonstrate that incorporating workload balance and energy consumption into scheduling decisions enhances equipment utilization and supports energy-efficient production. This indicates that multi-objective scheduling methods can serve as effective decision support tools for production planning and sustainable manufacturing, aligning with current trends in green intelligent manufacturing.

6. Conclusions

This study provides an in-depth investigation of the multi-objective flexible job shop scheduling problem (MOFJSSP) considering completion time, machine workload and energy consumption. First, a mathematical model of MOFJSSP is developed. In order to solve the problem effectively, four effective improvement strategies for the traditional NSGA-II algorithm are carried out: (1) a strategy considering machine workload balancing is designed; (2) an adaptive operation crossover strategy with dynamic subset size adjustment is developed; (3) a KNN-based congestion distance calculation method is adopted; and (4) a tabu search strategy is integrated. The results of large, medium, and small-scale test instances fully demonstrate the effectiveness of these four improved strategies. Compared with other algorithms, the proposed algorithm shows significant performance improvement, especially on large-scale instances. The workload balancing strategy improves the quality of the initial solution. The adaptive operation crossover strategy with dynamic subset size adjustment better balances the exploratory ability of the population at an early stage and its utilization at a later stage. The KNN crowding distance computation helps to maintain the population diversity, while the tabu search strategy further improves the quality of the Pareto solution by preventing the population from converging to a local optimum too early.

Despite these encouraging results, there are still some limitations that need to be addressed in future research. First, our energy model is relatively simplified, considering only the machine’s processing energy and idle energy, while the energy dynamics of the actual shop floor are more complex. Second, the current model has not yet incorporated machine failures. Future research will focus on developing more complex energy consumption models and incorporating machine failure scenarios to enhance the practical applicability of the proposed approach.