操作系統：利用python畫出SJF調度圖

SJF算法：

最短作業優先（SJF）調度算法將每個進程與其下次 CPU 執行的長度關聯起來。實際上，短進程/作業（要求服務時間最短）在實際情況中佔有很大比例，爲了使得它們優先執行，追求最少的平均等待時間時間、平均週轉時間、平均帶權週轉時間。短作業優先可能導致長作業一直得不到處理）

總體構想

用python繪圖這個想法產生於寫調度圖作業那段時間。當時就想着用python繪圖，有兩個想法trutle動態繪製調度圖，還有就是現在所使用的方法。爲什麼用類寫這次的作業，一是下次的作業可以直接繼承SJF類，然後修改調度函數和排序函數就行了。二是用類寫代碼解決一類問題，代碼看起來比較漂亮。

算法設計結構圖

程序執行結果圖

作業信息

作業名	到達時間	運行時間
A	0	5
B	1	4
C	2	1
D	4	2
E	5	1

基本思路

（1）類初始化：

對於進程調度SJF算法這個類，首先我們需要有成員變量，也就是大致所需要的成員變量。基本也就需要這麼多。

self.data = []	存儲進程
self.name = ''	進程名字
self.service_time = 0	服務時間
self.arrival_time = 0	到達時間
self.state = ''	初始狀態
self.number = 0	進程數量
self.timeout = 0	超時限定
self.start = 0	開始時間
self.end = 0	結束時間

def __init__(self):
        super(Solution, self).__init__()
        # save tasks
        self.data = []
        self.name = ''
        self.service_time = 0
        self.arrival_time = 0
        self.state = ''
        self.number = 0
        self.timeout = 0
        self.start = 0
        self.end = 0

（2）獲取數據：

獲取數據可以從文件（如.txt）中讀入，亦可以從console讀入。這裏要求一個地方，就是數據的格式，名字，到達時間，服務時間。中間用空格分開。如下面表格：

name	arrival_time	service_time
A	0	5
B	1	4
C	2	1
D	4	2
E	5	1

def get_data_file(self):
        with open('data.txt', "r", encoding="utf-8") as file:
            for line in file.read().splitlines():
                name, arrival_time, service_time = line.split()
                # insert the task
                self.insert_data(name, arrival_time, service_time)
        file.close()
        # initial queue
        # sort first arrival_time and second service_time
        self.data.sort(key=lambda x: (x['arrival_time'], x['service_time']))
        # update and recode id
        for i in range(self.number):
            self.data[i]['index'] = i

def get_data_input(self):
        print('How many tasks do you want input?')
        tasks_number = int(input('Please enter an integer of type int:'))
        print('Please enter name and arrival_time and service_time of task')
        print('such as:A 0 5')
        for _ in range(tasks_number):
            name, arrival_time, service_time = input('Please enter\n').split()
            self.insert_data(name, arrival_time, service_time)
        # initial queue
        # sort first arrival_time and second service_time
        self.data.sort(key=lambda x: (x['arrival_time'], x['service_time']))
        # update and recode id
        for i in range(self.number):
            self.data[i]['index'] = i

（3）進行調度：

也就是設計算法，來實現SJF。基本的算法思路，就是維護一個優先隊列。如圖：

每次調度的時候根據需要，然後更新信息，更改作業的狀態和到達和結束的時間。同時獲取下一個或者多個作業，這裏需要考慮到一種情況，就是當前時間片不能獲取下一個作業，需要等待一段時間作業到達，才能執行。這種情況特判一下。然後執行排序，維護這個優先隊列。

def implement(self):
        '''start algorithm'''
        # get first task
        data = [self.data[0]]
        # update the time of start
        self.start = self.end = data[0]['arrival_time']
        while data:
            # update information
            self.update_information(
                data[0]['index'], self.end, self.end + data[0]['service_time'])
            # get next task or tasks
            data += self.get_next_data(data.pop(0)['index'], data)
            # maintain the queue
            data = self.sort_data(data)
        self.data.sort(key=lambda x: x['id'])

（4）排序和信息更新：

對於排序的實現其實很簡單，前面的結構圖也已經展示了，對於SJF算法一共有兩種排序方式，分別在不同的過程進行使用。數據更新就是更新原始的數據，包括計算狀態，開始時間，結束時間，週轉時間，平均週轉時間等等。

def update_information(self, index, start, end):
        self.data[index]['start'] = start
        self.data[index]['end'] = end
        self.data[index]['state'] = 'f'
        self.data[index]['turnaround_time'] = end - \
            self.data[index]['arrival_time']
        self.data[index]['authorized_turnover_time'] = self.data[index]['turnaround_time'] / \
            self.data[index]['service_time']
        self.start = start
        self.end = end
        self.show_data_running(start, end, self.data[index])

（5）數據輸出：

爲什麼要數據輸出，其實這就是一個數據可視化的一種方法。也就是直觀的表達各種信息。所以數據輸出部分，就是自己設置自己的排版，佈局，可以利用\t製表符來打表。

def show_data(self):
        print("{:<6}{:<10}{:<10}{:<10}{:<6}{:<8}{:<7}{:<6}".format(
            'name', 'arr_time', 'ser_time', 'state', '週轉時間', '帶權週轉時間', 'start', 'end'))
        for task in sorted(self.data, key=lambda x: x['id']):
            print("{:<6}{:<10}{:<10}{:<10}{:<10}{:<14.2f}{:<7}{:<4}".format(
                task['name'],
                task['arrival_time'],
                task['service_time'],
                task['state'],
                task['turnaround_time'],
                task['authorized_turnover_time'],
                task['start'],
                task['end']))

（6）plt生成調度圖展示：

利用python的第三方庫，根據數據進行繪圖，然後展示出好看的圖片。

def init_image(self):
        # size = 1000 * 500
        plt.figure('SJF', figsize=(10, 5))
        self.drow_image()
        # setting xticks for 0 to self.end + 2
        plt.xticks([i for i in range(self.end + 3)])
        # setting title
        plt.title('the time of task about SJF')

        plt.xlabel('')
        plt.ylabel('tasks')
        # setting yticks.such as A == 0
        plt.yticks(self.get_y_ticks()[0], self.get_y_ticks()[1])

def drow_image(self):
        for task in self.data:
            # the time line of task from start to end
            plt.plot([task['start'], task['end']],
                     [task['id'], task['id']],
                     label=task['name'],
                     lw=2)
            # annotation of the key point
            plt.plot([task['end'], task['end']],
                     [-1, task['id']],
                     'k--',
                     lw=1)
        # legend
        plt.legend(loc='best')

def set_ax(self):
        ax = plt.gca()  # 獲取到當前座標軸信息
        ax.spines['right'].set_color('none')
        ax.spines['bottom'].set_color('none')
        ax.xaxis.set_ticks_position('top')   # 將X座標軸移到上面
        ax.invert_yaxis()  # 反轉Y座標軸
        ax.grid(True, linestyle='-.')  # 網格

def show_image(self):
        self.init_image()
        self.set_ax()
        plt.savefig('SJF.png', dpi=300)
        plt.show()

程序執行過程：

支持兩種輸入方式，手動輸入和數據導入。

數據導入：

原始數據

調度前：

調度中：

調度後：

生成調度圖：

手動輸入數據：

調度前

調度中

調度後

生成調度圖：

程序源代碼：

# -*- coding: utf-8 -*-
# @Author: wfy
# @Date:   2020-04-10 15:31:44
# @Last Modified by:   wfy
# @Last Modified time: 2020-04-14 13:46:31
import matplotlib.pyplot as plt


class Solution():
    """to achieve SJF"""

    def __init__(self):
        super(Solution, self).__init__()
        # save tasks
        self.data = []
        self.name = ''
        self.service_time = 0
        self.arrival_time = 0
        self.state = ''
        self.number = 0
        self.timeout = 0
        self.start = 0
        self.end = 0

    def insert_data(self, name, arrival_time, service_time):
        self.data.append({
            'id': self.number,
            'name': name,
            'arrival_time': int(arrival_time),
            'service_time': int(service_time),
            'state': 'w',
            'turnaround_time': 0,
            'authorized_turnover_time': 0,
            'start': 0,
            'end': 0
        })
        self.timeout = max(self.timeout, int(arrival_time))
        self.number += 1

    def get_data_file(self):
        with open('data.txt', "r", encoding="utf-8") as file:
            for line in file.read().splitlines():
                name, arrival_time, service_time = line.split()
                # insert the task
                self.insert_data(name, arrival_time, service_time)
        file.close()
        # initial queue
        # sort first arrival_time and second service_time
        self.data.sort(key=lambda x: (x['arrival_time'], x['service_time']))
        # update and recode id
        for i in range(self.number):
            self.data[i]['index'] = i

    def get_data_input(self):
        print('How many tasks do you want input?')
        tasks_number = int(input('Please enter an integer of type int:'))
        print('Please enter name and arrival_time and service_time of task')
        print('such as:A 0 5')
        for _ in range(tasks_number):
            name, arrival_time, service_time = input('Please enter\n').split()
            self.insert_data(name, arrival_time, service_time)
        # initial queue
        # sort first arrival_time and second service_time
        self.data.sort(key=lambda x: (x['arrival_time'], x['service_time']))
        # update and recode id
        for i in range(self.number):
            self.data[i]['index'] = i

    def show_data_running(self, start, end, data):
        print('-'*40)
        print("from {:} to {:}".format(start, end))
        print("task name:{:}".format(data['name']))
        print("task state:{:}\n".format('R'))

    def show_data(self):
        print("{:<6}{:<10}{:<10}{:<10}{:<6}{:<8}{:<7}{:<6}".format(
            'name', 'arr_time', 'ser_time', 'state', '週轉時間', '帶權週轉時間', 'start', 'end'))
        for task in sorted(self.data, key=lambda x: x['id']):
            print("{:<6}{:<10}{:<10}{:<10}{:<10}{:<14.2f}{:<7}{:<4}".format(
                task['name'],
                task['arrival_time'],
                task['service_time'],
                task['state'],
                task['turnaround_time'],
                task['authorized_turnover_time'],
                task['start'],
                task['end']))

    def cmp(self):
        '''the method of sort'''
        return lambda x: (x['service_time'], x['arrival_time'], x['index'])

    def sort_data(self, data):
        return sorted(data, key=self.cmp())

    def update_information(self, index, start, end):
        self.data[index]['start'] = start
        self.data[index]['end'] = end
        self.data[index]['state'] = 'f'
        self.data[index]['turnaround_time'] = end - \
            self.data[index]['arrival_time']
        self.data[index]['authorized_turnover_time'] = self.data[index]['turnaround_time'] / \
            self.data[index]['service_time']
        self.start = start
        self.end = end
        self.show_data_running(start, end, self.data[index])

    def get_next_data(self, index,  data):
        # get tasks from the beginning to the end of the current task
        result = [x for x in self.data if x['arrival_time'] <=
                  self.end and x['state'] == 'w' and x not in data]
        if result or data:
            return result
        # no tasks entered at current time
        for task in self.data:
            if task['state'] == 'w':
                self.start = self.end = task['arrival_time']
                return [task]
        return []

    def implement(self):
        '''start algorithm'''
        # get first task
        data = [self.data[0]]
        # update the time of start
        self.start = self.end = data[0]['arrival_time']
        while data:
            # update information
            self.update_information(
                data[0]['index'], self.end, self.end + data[0]['service_time'])
            # get next task or tasks
            data += self.get_next_data(data.pop(0)['index'], data)
            # maintain the queue
            data = self.sort_data(data)
        self.data.sort(key=lambda x: x['id'])

    def get_y_ticks(self):
        return [x['id'] for x in self.data] + [self.data[-1]['id'] + 1], [x['name'] for x in self.data] + ['']

    def init_image(self):
        # size = 1000 * 500
        plt.figure('SJF', figsize=(10, 5))
        self.drow_image()
        # setting xticks for 0 to self.end + 2
        plt.xticks([i for i in range(self.end + 3)])
        # setting title
        plt.title('the time of task about SJF')

        plt.xlabel('')
        plt.ylabel('tasks')
        # setting yticks.such as A == 0
        plt.yticks(self.get_y_ticks()[0], self.get_y_ticks()[1])

    def drow_image(self):
        for task in self.data:
            # the time line of task from start to end
            plt.plot([task['start'], task['end']],
                     [task['id'], task['id']],
                     label=task['name'],
                     lw=2)
            # annotation of the key point
            plt.plot([task['end'], task['end']],
                     [-1, task['id']],
                     'k--',
                     lw=1)
        # legend
        plt.legend(loc='best')

    def set_ax(self):
        ax = plt.gca()  # 獲取到當前座標軸信息
        ax.spines['right'].set_color('none')
        ax.spines['bottom'].set_color('none')
        ax.xaxis.set_ticks_position('top')   # 將X座標軸移到上面
        ax.invert_yaxis()  # 反轉Y座標軸
        ax.grid(True, linestyle='-.')  # 網格

    def show_image(self):
        self.init_image()
        self.set_ax()
        plt.savefig('SJF.png', dpi=300)
        plt.show()

    def main(self):
        if input('Do you want get data by file? y/Y or n/N\n') in ['y', 'Y']:
            SJF.get_data_file()
        else:
            SJF.get_data_input()
        SJF.show_data()
        SJF.implement()
        SJF.show_data()
        SJF.show_image()


if __name__ == '__main__':
    try:
        SJF = Solution()
        SJF.main()
    except Exception as e:
        print('An exception', e)
    else:
        print('Finish')
    finally:
        print('finally')

操作系統：利用python畫出SJF調度圖

SJF算法：

總體構想

算法設計結構圖

程序執行結果圖

作業信息

基本思路

（1）類初始化：

（2）獲取數據：

（3）進行調度：

（4）排序和信息更新：

（5）數據輸出：

（6）plt生成調度圖展示：

程序執行過程：

程序源代碼：

前端使用 Konva 實現可視化設計器（13）- 折線 - 最優路徑應用【思路篇】

Typora+colordrop+PicGo+GitHub圖牀，讓Markdown飛（一）

7-18 六度空間 (30分)

《校園十大優秀青年評比》課程設計作品——順利通過！！！

7-21 QQ帳戶的申請與登陸 (25分)

操作系統：利用python畫出SJF調度圖

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結