AGV调度:A*和双向A*算法

这篇具有很好参考价值的文章主要介绍了AGV调度:A*和双向A*算法。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

        这是我在参与AGV调度系统开发工作中形成的一些认识,是我的个人观点,想到什么写到什么。我自己也在学习,有不同观点可以一起讨论。由于涉及企业知识产权,文中代码为另外单独实现的DEMO,文章内容仅供参考。

      A*算法是路径规划中使用得比较多的算法,其实现起来比较简单,实践效果也挺好且便于在规划中引入一些定制化规则。故在AGV调度的应用场景需求下,其相比D*之类的算法要更加适合。

        在AGV调度场景下,D*之类算法重规划上的优势用处不大,因为AGV调度系统的重规划往往是由交管系统发起的,要么交管模块用其他算法直接搜索出策略,要么交管模块更新状态代价之后重规划。而这两者都使得上次规划得到的状态失去意义。

        故本章来讨论一下A*和双向A*算法在AGV调度系统里的应用。在调度系统中,双向A*算法相比于A*算法其实有好有坏。好的是部分情况下搜索量变小,坏的是会引入一些A*算法没有的问题。而且双向A*代价其实并不一定比A*低。

        A*算法不管是在栅格地图还是拓扑地图的场景都是可以使用的,实际调度系统项目中,用的比较多的还是拓扑地图。因为栅格地图通常只用在控制点不偏心的AGV小车上,而拓扑地图则通用所有场景并且也可以给地图附加更多的属性信息。但是拓扑地图比较抽象也不好呈现效果,为了方便演示,这里使用的是栅格地图。

        A*算法:

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.colors as colors

import heapq as hq

# 搜索节点
class Node(object):
    def __init__(self, nowx=0, nowy=0, cost=0, dist=0, lastx=0, lasty=0) -> None:
        self.nowx = nowx
        self.nowy = nowy
        self.cost = cost
        self.dist = dist
        self.lastx = lastx
        self.lasty = lasty

    def __lt__(self, other):
        return self.dist < other.dist
    
    def __le__(self, other):
        return self.dist <= other.dist
    
    def __gt__(self, other):
        return self.dist > other.dist
    
    def __ge__(self, other):
        return self.dist >= other.dist
    
    def __eqeq__(self, other):
        return self.dist == other.dist
    
    def __ne__(self, other):
        return self.dist != other.dist

# 求距离
def GetDist(start, end):
    # return abs(end[0] - start[0]) + abs(end[1] - start[1])
    return (abs(end[0] - start[0])**2 + abs(end[1] - start[1])**2)**0.5 * 2

def Contain(list, point):
    for i in range(len(list)):
        if list[i].nowx == point[0] and list[i].nowy == point[1]:
            return True

map_x = 20
map_y = 20
obsindex = 3

# 产生地图矩阵
# Map = np.zeros(map_x * map_y)
# obs_num = int(Map.size * 0.1)
# obs_a = np.random.randint(low=0, high=Map.size, size=obs_num)
# Map[obs_a] = obsindex
# map = Map.reshape([map_x, map_y])

# start = [9, 4]
# end = [9, 14]
# map = [ [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
#         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
#         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
#         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
#         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
#         [0, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 0],
#         [0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0],
#         [0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0],
#         [0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0],
#         [0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0],
#         [0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0],
#         [0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0],
#         [0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0],
#         [0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0],
#         [0, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 0],
#         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
#         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
#         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
#         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
#         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
#         ]

start = [0, 0]
end = [19, 19]
map = [ [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        [0, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        [0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        [0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        [0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        [0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        [0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        [0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        [0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0],
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0],
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0],
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0],
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0],
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0],
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0],
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0],
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0],
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
        ]

cmap = colors.ListedColormap(
    ['none', 'black', 'white', 'magenta', 'yellow', 'cyan', 'green', 'red', 'blue'])

# 初始化open与close数组
open = []
close = []
hq.heapify(open)
hq.heappush(open, (GetDist(start, end), Node(nowx=start[0], nowy=start[1], dist=GetDist(start, end))))

# 搜索路径
while len(open) > 0:
    item = hq.heappop(open)
    nowx = item[1].nowx
    nowy = item[1].nowy

    # 避免超出地图界限
    if nowx < 0 or nowx >= map_x or nowy < 0 or nowy >= map_y:
        continue

    # 避开障碍
    if map[nowx][nowy] == obsindex:
        continue
    
    # 标记地图
    map[nowx][nowy] = 1

    # 搜索到终点
    if nowx == end[0] and nowy == end[1]:
        break

    # 取出的节点已经在close列表里面则不在使用
    if Contain(close, [nowx, nowy]):
        continue
    
    # 当前节点加入close列表
    close.append(item[1])

    # 生成当前节点的下一步策略
    newcost = item[1].cost + 1
    hq.heappush(open, (GetDist([nowx + 1, nowy], end) + newcost, Node(nowx=nowx + 1, nowy=nowy, dist=GetDist([nowx + 1, nowy], end), lastx=nowx, lasty = nowy, cost = newcost)))
    hq.heappush(open, (GetDist([nowx, nowy + 1], end) + newcost, Node(nowx=nowx, nowy=nowy + 1, dist=GetDist([nowx, nowy + 1], end), lastx=nowx, lasty = nowy, cost = newcost)))
    hq.heappush(open, (GetDist([nowx - 1, nowy], end) + newcost, Node(nowx=nowx - 1, nowy=nowy, dist=GetDist([nowx - 1, nowy], end), lastx=nowx, lasty = nowy, cost = newcost)))
    hq.heappush(open, (GetDist([nowx, nowy - 1], end) + newcost, Node(nowx=nowx, nowy=nowy - 1, dist=GetDist([nowx, nowy - 1], end), lastx=nowx, lasty = nowy, cost = newcost)))

map[start[0]][start[1]] = 5
map[end[0]][end[1]] = 6

# 打印最终结果
print(map)

plt.imshow(map, cmap=cmap, interpolation='nearest', vmin=0, vmax=7)
plt.show()

AGV调度:A*和双向A*算法

  第一种障碍物场景的效果       AGV调度:A*和双向A*算法

第二种障碍物场景的效果

        双向A*:

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.colors as colors

import heapq as hq

# 搜索节点
class Node(object):
    def __init__(self, nowx=0, nowy=0, cost=0, dist=0, lastx=0, lasty=0) -> None:
        self.nowx = nowx
        self.nowy = nowy
        self.cost = cost
        self.dist = dist
        self.lastx = lastx
        self.lasty = lasty

    def __lt__(self, other):
        return self.dist < other.dist
    
    def __le__(self, other):
        return self.dist <= other.dist
    
    def __gt__(self, other):
        return self.dist > other.dist
    
    def __ge__(self, other):
        return self.dist >= other.dist
    
    def __eqeq__(self, other):
        return self.dist == other.dist
    
    def __ne__(self, other):
        return self.dist != other.dist

# 求距离
def GetDist(start, end):
    # return abs(end[0] - start[0]) + abs(end[1] - start[1])
    return (abs(end[0] - start[0])**2 + abs(end[1] - start[1])**2)**0.5 * 2

def Contain(list, point):
    for i in range(len(list)):
        if list[i].nowx == point[0] and list[i].nowy == point[1]:
            return True

map_x = 20
map_y = 20
obsindex = 3

# 产生地图矩阵
# Map = np.zeros(map_x * map_y)
# obs_num = int(Map.size * 0.1)
# obs_a = np.random.randint(low=0, high=Map.size, size=obs_num)
# Map[obs_a] = obsindex
# map = Map.reshape([map_x, map_y])

# start = [9, 4]
# end = [9, 14]
# map = [ [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
#         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
#         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
#         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
#         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
#         [0, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 0],
#         [0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0],
#         [0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0],
#         [0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0],
#         [0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0],
#         [0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0],
#         [0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0],
#         [0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0],
#         [0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0],
#         [0, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 0],
#         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
#         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
#         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
#         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
#         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
#         ]

start = [0, 0]
end = [19, 19]
map = [ [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        [0, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        [0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        [0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        [0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        [0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        [0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        [0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        [0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0],
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0],
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0],
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0],
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0],
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0],
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0],
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0],
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0],
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
        ]

cmap = colors.ListedColormap(
    ['none', 'black', 'white', 'magenta', 'yellow', 'cyan', 'green', 'red', 'blue'])

# 初始化open与close数组
openA = []
closeA = []
hq.heapify(openA)
hq.heappush(openA, (GetDist(start, end), Node(nowx=start[0], nowy=start[1], dist=GetDist(start, end))))

openB = []
closeB = []
hq.heapify(openB)
hq.heappush(openB, (GetDist(end, start), Node(nowx=end[0], nowy=end[1], dist=GetDist(end, start))))

# 搜索路径
while len(openA) > 0 and len(openB) > 0:
    item = hq.heappop(openA)
    nowx = item[1].nowx
    nowy = item[1].nowy

    # 避免超出地图界限
    if nowx < 0 or nowx >= map_x or nowy < 0 or nowy >= map_y:
        continue

    # 避开障碍
    if map[nowx][nowy] == obsindex:
        continue

    # 搜索到终点
    if Contain(closeB, [nowx, nowy]):
        break
    
    # 标记地图
    map[nowx][nowy] = 1

    # 取出的节点已经在close列表里面则不在使用
    if Contain(closeA, [nowx, nowy]):
        continue
    
    # 当前节点加入close列表
    closeA.append(item[1])

    # 生成当前节点的下一步策略
    newcost = item[1].cost + 1
    hq.heappush(openA, (GetDist([nowx + 1, nowy], end) + newcost, Node(nowx=nowx + 1, nowy=nowy, dist=GetDist([nowx + 1, nowy], end), lastx=nowx, lasty = nowy, cost = newcost)))
    hq.heappush(openA, (GetDist([nowx, nowy + 1], end) + newcost, Node(nowx=nowx, nowy=nowy + 1, dist=GetDist([nowx, nowy + 1], end), lastx=nowx, lasty = nowy, cost = newcost)))
    hq.heappush(openA, (GetDist([nowx - 1, nowy], end) + newcost, Node(nowx=nowx - 1, nowy=nowy, dist=GetDist([nowx - 1, nowy], end), lastx=nowx, lasty = nowy, cost = newcost)))
    hq.heappush(openA, (GetDist([nowx, nowy - 1], end) + newcost, Node(nowx=nowx, nowy=nowy - 1, dist=GetDist([nowx, nowy - 1], end), lastx=nowx, lasty = nowy, cost = newcost)))

    item = hq.heappop(openB)
    nowx = item[1].nowx
    nowy = item[1].nowy

    # 避免超出地图界限
    if nowx < 0 or nowx >= map_x or nowy < 0 or nowy >= map_y:
        continue

    # 避开障碍
    if map[nowx][nowy] == obsindex:
        continue

    # 搜索到终点
    if Contain(closeA, [nowx, nowy]):
        break
    
    # 标记地图
    map[nowx][nowy] = 4

    # 取出的节点已经在close列表里面则不在使用
    if Contain(closeB, [nowx, nowy]):
        continue
    
    # 当前节点加入close列表
    closeB.append(item[1])

    # 生成当前节点的下一步策略
    newcost = item[1].cost + 1
    hq.heappush(openB, (GetDist([nowx, nowy - 1], start) + newcost, Node(nowx=nowx, nowy=nowy - 1, dist=GetDist([nowx, nowy - 1], start), lastx=nowx, lasty = nowy, cost = newcost)))
    hq.heappush(openB, (GetDist([nowx - 1, nowy], start) + newcost, Node(nowx=nowx - 1, nowy=nowy, dist=GetDist([nowx - 1, nowy], start), lastx=nowx, lasty = nowy, cost = newcost)))
    hq.heappush(openB, (GetDist([nowx, nowy + 1], start) + newcost, Node(nowx=nowx, nowy=nowy + 1, dist=GetDist([nowx, nowy + 1], start), lastx=nowx, lasty = nowy, cost = newcost)))
    hq.heappush(openB, (GetDist([nowx + 1, nowy], start) + newcost, Node(nowx=nowx + 1, nowy=nowy, dist=GetDist([nowx + 1, nowy], start), lastx=nowx, lasty = nowy, cost = newcost)))  

map[start[0]][start[1]] = 5
map[end[0]][end[1]] = 6

# 打印最终结果
print(map)

plt.imshow(map, cmap=cmap, interpolation='nearest', vmin=0, vmax=7)
plt.show()

AGV调度:A*和双向A*算法

第一种障碍物场景的效果

AGV调度:A*和双向A*算法

第二种障碍物场景的效果

        从上面对比效果来看由于启发值的存在,双向搜索对A*的改进并没有体现出优势来。可能双向算法对Dijkstar算法比A*算法要有效果。这还是写这篇文章的时候我才认识到的,之前在公司实现的时候没有去对比两者,想当然以为双向A*会比A*好,现在看来怕不是改了个寂寞。

        而在问题上面,我们参考下面的图片:

AGV调度:A*和双向A*算法

         在调度系统中,很明显搜索结果是1这条路线,但是实际1和2的行驶代价是一样的,但是转向代价不一样。我们更希望车辆走2的路线而不是1的路线,所以通常我们会加上转向代价并调整启发值的计算方式。如果是双向A*,由于交汇的是中间点,即使加上代价,我们求得的仍然不是2这条路径。文章来源地址https://www.toymoban.com/news/detail-417748.html

到了这里,关于AGV调度:A*和双向A*算法的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 操作系统有关进程调度算法(含先来先服务,短作业优先,优先级调度算法和时间片轮转调度算法)

    本文采用的进程调度算法有:先来先服务,短作业优先,优先级调度算法和时间片轮转调度算法。 针对这四种算法,我采用的是建立数组结构体,如: 先来先服务(FCFS)调度算法是一种最简单的调度算法,该算法既可用于作业调度,也可用于进程调度。采用FCFS算法,每次从

    2024年02月03日
    浏览(61)
  • 操作系统进程调度算法——先来先服务、时间片轮转、优先级调度算法

    (1)算法内容: 先来先服务调度算法是一种最简单的调度算法,可以应用于高级调度也可以运用于低级调度。高级调度时,FCFS调度算法按照作业进入后备作业队列的先后顺序选择作业进入内存,即先进入后备作业队列的作业被优先选择进入内存,然后为选中的作业创建进程

    2023年04月21日
    浏览(44)
  • 操作系统页面调度算法

    实验项目名称:操作系统页面调度算法 一、实验目的和要求 目的:对操作系统中使用的页面调度算法进行设计。 要求:对教材中所讲述的几种页面调度算法进行深入的分析,通过请求页式存储管理中页面置换算法模拟设计,了解虚拟存储技术的特点,掌握请求页式存储管理的

    2024年02月04日
    浏览(40)
  • 【操作系统】调度算法

    目录 🏫基本概念 🏥先来先服务(FCFS, First Come First Serve) 🏩短作业优先(SJF, Shortest Job First) 🍆细节 ⛪️高响应比优先(HRRN,Highest Response Ratio Next) 🌇时间片轮转(RR,Round-Robin) 🏰时间片大小的影响 🗼优先级调度算法 🌄多级反馈队列调度算法 🌈实例  🗽多级队列调度

    2024年02月08日
    浏览(41)
  • 操作系统——调度算法

    本文的主要内容是调度算法的介绍,包括先来先服务(FCFS)、最短时间优先(SJF)、最高响应比优先(HRRN)、时间片轮转(RR)、优先级调度和多级反馈队列这六种方法,这些调度算法会从其算法思想、算法规则、该方法用于作业调度还是进程调度、进程调度的方式(抢占式和非抢占式

    2023年04月14日
    浏览(36)
  • 「 操作系统 」聊聊进程调度算法

    图文并茂!谈谈进程调度那些算法 Cone 进程调度/页面置换/磁盘调度算法 xiaolinCoding 图解经典的进程调度算法 飞天小牛肉 进程调度算法是操作系统中非常重要的一部分,它决定了操作系统中各个进程的执行顺序和时间片。在单核CPU下,任何时刻都只可能有一个程序在执行,比

    2024年02月04日
    浏览(61)
  • 操作系统:实验一:进程调度实验——最高优先数优先的调度算法以及先来先服务算法 源码

    一、实验目的 (1)了解进程实体PCB结构; (2)理解进程不同状态和状态之间的转换过程; (3)掌握优先数的调度算法和先来先服务算法; 二、实验内容与要求 设计一个有 N个进程共行的进程调度程序 四、实验步骤 (1)实验设计 进程调度算法: 采用最高优先数优先的调

    2024年02月06日
    浏览(45)
  • 操作系统中的调度算法

    处理机调度层次: 1.高级调度( 作业 调度/) 2.中级调度( 内存 调度/) 3.低级调度( 进程 调度/) 一、作业调度算法 1.先来先服务算法(FCFS) 2.短作业优先算法(SJF) 3.优先级调度算法(PR) 4.高响应比调度算法(PR特例) 5.时间片轮转算法(RR) 6.多级队列调度算法 7.基

    2024年02月10日
    浏览(46)
  • 操作系统之调度算法(学习笔记)

    周转时间 :从作业被提交给系统开始,到作业完成为止的这段时间间隔称为作业周转时间。( 周转时间=作业完成时间-作业提交时间 ) 平均周转时间 :作业周转总时间 / 作业个数( 平均周转时间=(作业1周转时间+作业2周转时间+……作业n周转时间)/n ) 服务时间 :进程在

    2024年02月03日
    浏览(42)
  • 操作系统磁盘调度算法(c++)

    先来先服务这个没什么好说了,按顺序来就是了。将需要访问的磁道序列直接作为算法的访问序列,然后将每次移动的磁道数量记录下来。 最短寻道时间优先,每次执行完,看一下离自己最近的哪条磁道有任务,就移动过去执行。每次寻找下一次访问的磁道号时,都遍历磁道

    2024年02月04日
    浏览(45)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包