Given the challenges of manufacturing resource sharing and competition in the modern manufacturing industry, the coordinated scheduling problem of parallel machine production and transportation is investigated. The problem takes into account the coordination of production and transportation before production as well as the disparities in machine spatial position and performance. A non-cooperative game model is established, considering the competition and self-interest behavior of jobs from different customers for machine resources. The job from different customers is mapped to the players in the game model, the corresponding optional processing machine and location are mapped to the strategy set, and the makespan of the job is mapped to the payoff. Then the solution of the scheduling model is transformed into the Nash equilibrium of the non-cooperative game model. A Nash equilibrium solution algorithm based on the genetic algorithm (NE-GA) is designed, and the effective solution of approximate Nash equilibrium for the game model is realized. The fitness function, single-point crossover operator, and mutation operator are derived from the non-cooperative game model’s characteristics and the definition of Nash equilibrium. Rules are also designed to avoid the generation of invalid offspring chromosomes. The effectiveness of the proposed algorithm is demonstrated through numerical experiments of various sizes. Compared with other algorithms such as heuristic algorithms (FCFS, SPT, and LPT), the simulated annealing algorithm (SA), and the particle swarm optimization algorithm (PSO), experimental results show that the proposed NE-GA algorithm has obvious performance advantages.

The sharing economy model began to emerge strongly and swiftly with the advent of Internet information technology. Shared manufacturing, which uses Internet technology to optimize and match supply and demand, has become popular in recent years [

The concept of shared manufacturing was first proposed by Ellen Brandt [

As the sharing economy and manufacturing have become more integrated, many scholars have studied production scheduling problems under the sharing of manufacturing resources. Jiang et al. [

Although many scholars have studied the production scheduling model or resource allocation model under manufacturing resource sharing, few have considered the coordinated scheduling of parallel machine production and transportation. Most problem-solving methods are rule-based, with a focus on theoretical analysis and influencing factor analysis. It cannot effectively coordinate the allocation of multiple tasks and resources.

Because the demand in the sharing mode frequently comes from multiple self-interested individuals, it has obvious advantages to study the production scheduling problem based on a non-cooperative game. Koutsoupias et al. [

As a result, this paper investigates the non-cooperative game of coordinated scheduling of parallel machine production and transportation in shared manufacturing from three perspectives.

An unrelated parallel machine production scheduling model considering pre-production transportation is established to target machine resources that can perform the same type of processing tasks on the shared manufacturing platform. The model takes into account different machine positions as well as performance differences, processing time, and job transportation time.

Aiming at the characteristics of the coordinated scheduling problem of parallel machine production and transportation in shared manufacturing, a non-cooperative game model considering the competition and self-interest behavior of orders (jobs) from different customers for machine resources is constructed. The job is the player in the non-cooperative game model, the processing machine and processing position are the strategies, and the opposite number of the completion time of the job is the payoff for each customer.

A Nash equilibrium solution algorithm based on the genetic algorithm (NE-GA) is designed to find the Nash equilibrium of the scheduling scheme to address the problem that the Nash equilibrium of multiple game players is difficult to solve. The fitness function is designed according to the Nash equilibrium definition, and to ensure the feasibility of the chromosome, the coding scheme and genetic operators are designed according to the game strategy.

The remainder of this paper is organized as follows. Section 2 develops a non-cooperative game model to handle the coordinated scheduling problem of production and transportation in shared manufacturing. Section 3 designs a Nash equilibrium solution algorithm based on the genetic algorithm. Section 4 describes the simulation experiment and analysis. Section 5 summarizes the conclusions.

Multiple machines from different manufacturers are at different locations in a shared manufacturing environment and can receive orders from different customers or upstream enterprises to provide processing services. The order (processing job) must first be transported to the machine, and the scheduling production of the manufacturer is determined by the number of orders received.

Assume that there are _{1}, _{2}, …, _{n}} in various locations, and orders from these _{j}. The time required to transport job _{ij}, _{ij}, indicating that the machine environment can be thought of as unrelated parallel machine, denoted by _{m}.

Define the span time of one job as the time between the job leaving the customer and the completion of processing, including transport time, waiting time, and processing time. Because the problem addressed in this paper is pre-production transportation, the span time of job _{j},

The problem is expressed as a three-field representation _{j}, denoted _{max} = max{_{j}, _{m}|_{j} |_{max}.

The problem under consideration is consistent with the following assumptions:

All jobs have arrived at time zero and can be transported.

The machine is available at time zero.

All machines can process jobs continuously, with no setup time or transfer time.

The processing of each job will not be interrupted once it begins.

Each machine can process only one job at a time.

In the previous problem, each customer wanted his job completed as soon as possible, and multiple players were aiming for their interests. For this problem, a non-cooperative game model with

_{1}, _{2}, …, _{n}}, _{j} represents the strategy of the _{1}, _{2}, …, _{n}}, _{j} represents the payoff of the

In _{i} to be processed is formed in front of each machine. Set |_{i}| = _{i}, that is, the number of jobs processed on machine _{i}. The job on each machine then chooses the processing position. The selected machine and the processing position of each job comprise the job strategy, and the strategy of all jobs comprises the complete strategy, which corresponds to a feasible solution to the problem. The strategies and payoffs are discussed further below.

A strategy is a collection of actions or decisions that a player can implement. The strategy for _{1}, _{2}, …, _{n}}. Each job must make two decisions: the first involves selecting the machine from a pool of _{j} for job

The strategy set consists of all possible strategies, where (^{n} is the total number of possible strategies. Of course, not all strategies are effective. When the following events occur, the strategy

(1) Processing position conflict: Because each processing sequence on each machine is unique, this strategy is invalid when two jobs have chosen to be processed in the same position on the same machine. That is, in strategy

(2) Discontinuity in processing: The processing sequence on each machine should be continuous. However, the scheduling discontinuity on the same machine may occur in the previously considered strategy, making it invalid.

For example, three jobs from three customers need to be processed on two unrelated parallel machine on the shared platform. If the repetition strategy is ignored, each player has a choice of two machines, three processing sequences on each machine, and six different strategies, for a total of 6^{3} = 216 different strategies, some of which are ineffective. For instance, if _{1} = _{3} = (1,2), that strategy is invalid. There are

During the game, each player acts according to its own strategy in order to obtain payoffs and expect the best payoffs for itself. In this paper, each job is played to reduce its makespan. As a result, the opposite number of the completion time of each job is taken as the payoff function of each customer, i.e, _{j} = −_{j}.

The completion time _{j} of job _{ij}, the waiting time _{j} after transportation arrives, and the job processing time _{ij}, as shown in

The waiting time of Job _{j} equal to the sum of the transportation and job processing times, so _{j} = _{ij} + _{ij}. If the machine is busy when the job arrives, or if another job is waiting to be processed before it, the completion time of the job _{j} is the sum of the completion time of the previous job processed by the machine and the processing time of the job. Assume that job _{j} = _{l} + _{ij}. In conclusion, the completion time _{j} can be expressed as

If job _{0} = 0.

Individual jobs can have a negative influence on one another. Processing on the same machine to reduce their own completion time may cause other jobs to take longer to complete. As a result, we must find an equilibrium point of interest for all jobs. The production scheduling problem with transportation under equipment sharing is transformed into a Nash equilibrium solution for relevant constraints based on the non-cooperative game model established above.

When there is a strategy

_{–j} is the set of all players' strategies except player

In the non-cooperative game model established in this paper, there are n customers involved in the game, and each customer can choose a limited number of strategies, which is a finite game. According to “Nash Theorem”, Nash equilibrium exists in the game model developed in this paper.

For example, there are two unrelated parallel machines on the shared platform, and two jobs must be processed. The transport time _{ij} of job _{11} = 3, _{12} = 2, _{21} = 3, _{22} = 4, the processing time _{ij} of job _{11} = 5, _{12} = 8, _{21} = 7, _{22} = 5. The alternative strategies for jobs 1 and 2 are: (1,1), (1,2), (2,1), (2,2). The payoff matrix can then be written as A.

Adopting the streak plate method, the Nash equilibrium solution of this example can be derived as

As the number of jobs and machines rises, the strategy space of the established game model expands exponentially, making it harder to achieve Nash equilibrium by adopting traditional approaches. The genetic algorithm can find an approximate optimal solution without being influenced or limited by the deduction condition or function continuity. As a result, this paper designs the Nash equilibrium solution algorithm based on the genetic algorithm (NE-GA) to seek the approximate Nash equilibrium of the established game model based on the characteristics of the constructed non-cooperative game model and the definition of Nash equilibrium.

The coding of genetic algorithms is the process of describing feasible scheduling solutions as “chromosomes” of genetic algorithms. The “chromosome” contains information about feasible scheduling solutions, i.e., the action strategies of each player in the game model. Integer coding is used for the production and transportation coordination scheduling problem of parallel machine under manufacturing resource sharing. Each chromosome contains

For example, three unrelated parallel machines are at different locations on the shared manufacturing platform to provide processing and manufacturing services, and there are six jobs to be processed from six customers. A chromosome of the problem is shown in

The chromosome in

To ensure that the corresponding strategy of chromosomes is feasible, the generation process of chromosomes is designed as follows.

_{i} (_{1} + _{2} + ⋯ _{m} = _{i} represents the number of jobs assigned to the

_{i}, the gene locus (_{i}) are generated in a sequential.

_{1}), (2, 1), (2, 2), …, (2, _{2}), …, (_{m})).

The chromosomes generated by the method described above can ensure that all of the chromosomes generated correspond to feasible strategies.

The key to a genetic algorithm is the fitness function. The ability to adopt a genetic algorithm to achieve Nash equilibrium is primarily due to the design of the fitness function. To ensure that the solution of the algorithm is approximate Nash equilibrium, the fitness function is designed according to the non-cooperative game model of production and transportation coordination scheduling under manufacturing resource sharing and the definition of Nash equilibrium.

Since the payoff of each job defines the negative value of its completion time, each job competes with others for a better processing position to minimize its completion time. According to the definition of Nash equilibrium, Nash equilibrium is reached when each job cannot increase its payoff by changing its strategy. As a result, by minimizing the completion time of each job in the scheduling scheme, the objective of payoff equilibrium is reached, and the fitness function is guaranteed to be positive. The fitness function is defined as

When

_{j} is the threshold value for determining the conditions for solving Nash equilibrium points. To simplify the problem, we can take _{1} = _{2} = ⋯ = _{n} =

The roulette choice operator is employed. Because the fitness value defined in this paper is the smaller the better,

The difference in fitness _{q} between the chromosome with the largest converted fitness value and each chromosome is then calculated:

To increase the likelihood of selecting a chromosome with a good fitness function, the exponential function is used to widen the gap between the fitness of each chromosome and the maximum fitness value: _{q} is:

Adopting a single point crossing. First, two parental chromosomes, P_{1} and P_{2}, were chosen. As crossing points, integers between 1 and _{1} and O_{2}. The crossing process is shown in

A single-point crossing can produce invalid chromosomes. As shown in _{1} select the same position on the same machine. So chromosomes produced by a single crossover must be processed further. First, the jobs processed on the same machine are counted according to the offspring chromosome, and then the jobs processed on the same machine are sorted according to the original processing position of the machine. If two processing positions are identical, the jobwith the smaller serial number is ranked first.

For example, in _{1}. On machine 1, there are job 1 and job 4. Reorder by job serial number. The processing position of job 1 is 1, and the processing position of job 4 is 2. On machine 2, there are job 2, job 3, and job 5. The processing positions are 2, 3, and 2, and the reordering positions are 1, 3, and 2. Job 6 is located on machine 3, and the processing position is 1. The effective offspring chromosome after processing is shown in

To generate new genes, adopt the single point mutation operator. First, as a mutation locus, an integer between 1 and

The Nash equilibrium solution algorithm based on the genetic algorithm (NE-GA) is designed in this paper, and the algorithm steps are as follows. The algorithm flow diagram is shown in

_{ij}), job transport time (_{ij}). Set size of the population (_{m}), crossover probabilities (_{c}).

The following simulation analysis examples are aimed at verifying the effectiveness of the proposed scheduling game model and the designed NE-GA algorithm. To compile the algorithm, the Pycharm-2017.3.4 compiler and Python-3.7 interpreter are used. Experiments are performed on a computer equipped with an Intel(R) Core(TM) i3-4170 CPU @ 3.70 GHz and 8 GB of RAM.

Assume that the shared manufacturing platform has 5 machines available for shared production, each of which is located in a different factory, and that 20 jobs from 20 customers are to be processed on these shared machines. Both the processing time _{ij} and the transportation time _{ij} are generated at random from the interval [1,10], and the unit of both is hours.

Job |
Machine |
||||
---|---|---|---|---|---|

1 | 2 | 3 | 4 | 5 | |

1 | (6, 7) | (10, 7) | (5, 8) | (6, 6) | (2, 6) |

2 | (2, 3) | (6, 1) | (7, 3) | (5, 10) | (9, 2) |

3 | (10, 6) | (4, 4) | (10, 4) | (10, 4) | (1, 4) |

4 | (5, 9) | (8, 7) | (9, 6) | (8, 10) | (4, 7) |

5 | (4, 9) | (5, 5) | (1, 6) | (4, 6) | (4, 9) |

6 | (5, 8) | (10, 3) | (9, 5) | (3, 9) | (10, 1) |

7 | (7, 5) | (3, 4) | (8, 4) | (4, 1) | (1, 4) |

8 | (9, 3) | (5, 7) | (3, 7) | (8, 3) | (7, 3) |

9 | (6, 8) | (2, 10) | (5, 8) | (8, 10) | (4, 3) |

10 | (4, 3) | (1, 2) | (7, 5) | (10, 8) | (8, 9) |

11 | (4, 1) | (8, 10) | (10, 10) | (3, 4) | (8, 9) |

12 | (7, 1) | (6, 4) | (3, 9) | (1, 6) | (6, 7) |

13 | (9, 8) | (7, 2) | (5, 8) | (7, 5) | (5, 4) |

14 | (4, 1) | (7, 3) | (4, 10) | (5, 1) | (8, 1) |

15 | (2, 10) | (9, 10) | (1, 2) | (3, 5) | (2, 6) |

16 | (3, 8) | (2, 10) | (10, 9) | (10, 7) | (4, 5) |

17 | (7, 5) | (1, 9) | (3, 4) | (1, 10) | (5, 5) |

18 | (6, 9) | (8, 8) | (2, 2) | (7, 10) | (3, 9) |

19 | (6, 6) | (5, 6) | (1, 8) | (6, 9) | (7, 10) |

20 | (5, 6) | (9, 2) | (4, 10) | (2, 4) | (7, 6) |

Note: The 6 of binary arrays (6, 7) in the table represents the transportation time _{ij} of job _{ij} of job

The following orthogonal experiments are designed to determine the parameter values of the algorithm. The population sizes (_{m}) of 0.1, 0.2, and 0.3, respectively. _{max} is listed for comparing calculation results.

_{m} |
_{c} |
_{max} |
||
---|---|---|---|---|

30 | 0.1 | 0.9 | 205 | 19 |

30 | 0.2 | 0.8 | 570 | 18 |

30 | 0.3 | 0.7 | 720 | 17 |

50 | 0.1 | 0.9 | 156 | 18 |

50 | 0.2 | 0.8 | 352 | 18 |

50 | 0.3 | 0.7 | 1000 | 17 |

100 | 0.2 | 0.8 | 1000 | 16 |

100 | 0.3 | 0.7 | 1000 | 16 |

As shown in

_{max} when the algorithm iterates 1000 times under the data in _{max} tend to converge steadily.

The Gantt charts of the best individuals when the algorithm runs the first, 100th, and 400th generations are shown in

Job |
1 | 100 | 400 | Job |
1 | 100 | 400 |
---|---|---|---|---|---|---|---|

1 | 12 | 14 | 11 | 22 | 18 | ||

2 | 16 | 12 | 28 | 22 | |||

3 | 5 | 8 | 13 | 14 | 20 | ||

4 | 23 | 15 | 14 | 13 | 16 | ||

5 | 21 | 12 | 15 | 12 | |||

6 | 28 | 16 | 21 | 22 | |||

7 | 20 | 17 | 17 | 13 | |||

8 | 18 | 15 | 18 | 14 | 15 | ||

9 | 13 | 11 | 19 | 26 | 15 | ||

10 | 16 | 20 | 17 | 22 | |||

_{max} |
28 | 22 |

Note: The data in bold in the table indicates the minimum completion time of the corresponding job

To demonstrate the effectiveness of the designed algorithm, the NE-GA algorithm is compared to the heuristic algorithms: First Come First Served (FCFS), Shortest Processing Time First (SPT), Longest Processing Time First (LPT), and the intelligent optimization algorithms: the simulated annealing algorithm (SA) and the particle swarm optimization algorithm (PSO) at different sizes of experiments. The Gantt chart of these algorithms when

_{max} of the NE-GA algorithm is also the shortest among the six algorithms. Although SA and PSO are superior to the three heuristic algorithms (FCFS, SPT, and LPT), the completion time of each job and makespan are still worse than those of NE-GA. When

Job |
Algorithms | Job |
Algorithms | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|

FCFS | SPT | LPT | NE-GA | SA | PSO | FCFS | SPT | LPT | NE-GA | SA | PSO | ||

1 | 15 | 17 | 8 | 14 | 11 | 24 | 6 | 19 | |||||

2 | 10 | 23 | 10 | 18 | 12 | 8 | 8 | 8 | 13 | ||||

3 | 14 | 17 | 8 | 12 | 13 | 24 | 20 | 10 | 15 | ||||

4 | 22 | 20 | 15 | 17 | 15 | 14 | 23 | 18 | |||||

5 | 16 | 16 | 12 | 10 | 15 | 15 | 21 | 9 | 19 | ||||

6 | 20 | 24 | 15 | 12 | 13 | 16 | 23 | 19 | 16 | 17 | 11 | ||

7 | 9 | 5 | 8 | 17 | 12 | 13 | 19 | 17 | 16 | ||||

8 | 24 | 23 | 15 | 18 | 17 | 23 | 11 | 17 | |||||

9 | 22 | 14 | 20 | 11 | 16 | 19 | 15 | 19 | 14 | 12 | 9 | ||

10 | 18 | 14 | 9 | 20 | 12 | 22 | 12 | 15 | |||||

_{max} |
24 | 20 | 24 | 17 | 19 | ||||||||

Running time (s) | 0.07 | 0.29 | 0.25 | 6.20 | 37.18 | 13.38 |

Job |
Algorithms | Job |
Algorithms | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|

FCFS | SPT | LPT | NE-GA | SA | PSO | FCFS | SPT | LPT | NE-GA | SA | PSO | ||

1 | 20 | 12 | 15 | 11 | 23 | 26 | 16 | 9 | 7 | 12 | 19 | ||

2 | 10 | 8 | 8 | 9 | 27 | 7 | 17 | 11 | 10 | 15 | |||

3 | 6 | 16 | 22 | 28 | 22 | 15 | 10 | 15 | 14 | ||||

4 | 9 | 13 | 12 | 12 | 29 | 12 | 10 | 11 | 11 | ||||

5 | 12 | 13 | 5 | 14 | 30 | 8 | 14 | 13 | 14 | 24 | |||

6 | 35 | 15 | 19 | 11 | 31 | 19 | 7 | 7 | 14 | 13 | |||

7 | 9 | 14 | 17 | 12 | 24 | 32 | 5 | 12 | 12 | 21 | |||

8 | 17 | 13 | 18 | 5 | 11 | 33 | 21 | 14 | 10 | 15 | 22 | ||

9 | 25 | 12 | 12 | 7 | 34 | 16 | 9 | 10 | 15 | 23 | |||

10 | 10 | 7 | 9 | 6 | 17 | 35 | 35 | 13 | 9 | 13 | 21 | ||

11 | 29 | 17 | 14 | 15 | 36 | 25 | 11 | 13 | 12 | 10 | |||

12 | 18 | 10 | 9 | 11 | 37 | 10 | 8 | 10 | 13 | 20 | |||

13 | 10 | 13 | 11 | 11 | 12 | 38 | 9 | 12 | 6 | 14 | 19 | ||

14 | 28 | 14 | 15 | 8 | 39 | 11 | 11 | 5 | 9 | 17 | |||

15 | 11 | 14 | 12 | 6 | 7 | 40 | 7 | 7 | 10 | ||||

16 | 25 | 17 | 10 | 10 | 12 | 41 | 19 | 19 | 12 | 15 | 15 | ||

17 | 11 | 9 | 12 | 10 | 11 | 42 | 43 | 11 | 8 | 23 | |||

18 | 13 | 12 | 15 | 8 | 9 | 43 | 24 | 11 | 16 | 11 | 24 | ||

19 | 7 | 12 | 13 | 16 | 44 | 22 | 12 | 14 | 14 | 14 | |||

20 | 41 | 18 | 12 | 11 | 13 | 45 | 25 | 12 | 12 | 14 | 17 | ||

21 | 33 | 15 | 13 | 10 | 11 | 46 | 24 | 14 | 13 | 14 | 20 | ||

22 | 11 | 10 | 5 | 13 | 47 | 14 | 12 | 13 | 14 | ||||

23 | 15 | 7 | 15 | 9 | 48 | 17 | 16 | 12 | 15 | 20 | |||

24 | 37 | 22 | 10 | 6 | 17 | 49 | 7 | 8 | 9 | 6 | 20 | ||

25 | 5 | 15 | 12 | 12 | 23 | 50 | 13 | 11 | 11 | 11 | 23 | ||

_{max} |
43 | 22 | 19 | 15 | 24 | ||||||||

Running time | 0.22 | 0.39 | 0.39 | 16.50 | 70.2 | 36.53 |

Note: The data in bold in the table indicates the minimum completion time of the corresponding job

In this paper, we have investigated the coordinated scheduling problem of parallel machine production and transportation in shared manufacturing. A non-cooperative game model was established when jobs from different customers competed for the shared machines at different locations, and the jobs took their respective completion times as payoff. The fitness function was constructed based on the definition of Nash equilibrium, and the Nash equilibrium solution algorithm based on the genetic algorithm (NE-GA) was designed to find the Nash equilibrium point of the game model. The proposed model and algorithm were simulated, analyzed with several scheduling examples of different sizes, and compared with the heuristic algorithms (FCFS, SPT, and LPT) and other intelligent optimization algorithms (SA and PSO). The results showed that the method performed well in terms of completion time and makespan for each job and that it balanced the payoffs for multiple customers.

In the future, the coordinated scheduling problem of parallel machine production and transportation can be studied, considering the transportation capacity limitation in the shared manufacturing environment. In addition, the theoretical convergence analysis of the proposed algorithm is also future work.

The authors wish to acknowledge the contribution of Liaoning Key Lab of Equipment Manufacturing Engineering Management, Liaoning Research Base of Equipment Manufacturing Development, Liaoning Key Research Base of Humanities and Social Sciences: Research Center of Micro-management Theory of SUT.

This work was supported in part by the Project of Liaoning BaiQianWan Talents Program under Grand No. 2021921089, the Science Research Foundation of Educational Department of Liaoning Province under Grand No. LJKQZ2021057 and WJGD2020001, the Key Program of Social Science Planning Foundation of Liaoning Province under Grant L21AGL017.

The authors declare that they have no conflicts of interest to report regarding the present study.