使用Java模拟操作系统高优先级算法

最近做操作系统的课程设计，网上看到一些动态调度的算法都是基于C写的，下午闲来无事，用Java写了一个高优先级调度的算法玩玩，这个算法首先有这几条要注意

  • 优先级是否可以为负的，答案是肯定的，如果有一个线程阻塞了另外一个线程一直去运行就可能一直减去，让优先级变成负数了
  • 阻塞的时机：可以说阻塞的时机特别的重要，一旦到达时间需要线程进行阻塞的状态就要立刻将状态改变掉，让它产生调度
  • 恢复成就绪状态的问题：因为是有可能是线程进行I/O操作，让其阻塞了，所以说，一个时间片就需要让恢复阻塞的时间常数+1，当变为0的时候让他进入调度状态
  • 如果在系统中都是阻塞的线程怎么办？那没有办法，操作系统只能干等着让他们变为就绪状态的时候才能运行

先上一个PCB结构体函数块

    

  1. public class PCB {
    2. 

  2. 	//进程的ID
    3. 

  3. 	private long id;
    4. 

  4. 	//优先级顺序
    5. 

  5. 	private int priority;
    6. 

  6. //	运行的cpu时间
    7. 

  7. 	private long cputime;
    8. 

  8. //  需要运行的时间
    9. 

  9. 	private long alltime;
    10. 

  10. //  即将阻塞的时间
    11. 

  11. 	private long startblock;
    12. 

  12. //	从阻塞中回复的时间
    13. 

  13. 	private long blocktime;
    14. 

    15. 

  15. //	现在线程的状态
    16. 

  16. 	private String state;
    17. 

  17. 	
    18. 

  18. 	
    19. 

  19. 	public PCB(long id, int priority, long cputime, long alltime,
    20. 

  20. 			long startblock, long blocktime, String state) {
    21. 

  21. 		super();
    22. 

  22. 		this.id = id;
    23. 

  23. 		this.priority = priority;
    24. 

  24. 		this.cputime = cputime;
    25. 

  25. 		this.alltime = alltime;
    26. 

  26. 		this.startblock = startblock;
    27. 

  27. 		this.blocktime = blocktime;
    28. 

  28. 		this.state = state;
    29. 

  29. 	}
    30. 

    31. 

  31. 	public String getState() {
    32. 

  32. 		return state;
    33. 

  33. 	}
    34. 

    35. 

  35. 	public void setState(String state) {
    36. 

  36. 		this.state = state;
    37. 

  37. 	}
    38. 

    39. 

  39. 	public long getBlocktime() {
    40. 

  40. 		return blocktime;
    41. 

  41. 	}
    42. 

    43. 

  43. 	public void setBlocktime(long blocktime) {
    44. 

  44. 		this.blocktime = blocktime;
    45. 

  45. 	}
    46. 

  46. //  运行的三个状态
    47. 

  47. 	public final static String STATE_READY = "READY";
    48. 

  48. 	public final static String STATE_RUN = "RUN";
    49. 

  49. 	public final static String STATE_BLOCK = "BLOCK";
    50. 

    51. 

  51. 	
    52. 

  52. 	
    53. 

  53. 	public long getId() {
    54. 

  54. 		return id;
    55. 

  55. 	}
    56. 

    57. 

  57. 	public void setId(long id) {
    58. 

  58. 		this.id = id;
    59. 

  59. 	}
    60. 

    61. 

  61. 	public int getPriority() {
    62. 

  62. 		return priority;
    63. 

  63. 	}
    64. 

    65. 

  65. 	public void setPriority(int priority) {
    66. 

  66. 		this.priority = priority;
    67. 

  67. 	}
    68. 

    69. 

  69. 	public long getCputime() {
    70. 

  70. 		return cputime;
    71. 

  71. 	}
    72. 

    73. 

  73. 	public void setCputime(long cputime) {
    74. 

  74. 		this.cputime = cputime;
    75. 

  75. 	}
    76. 

    77. 

  77. 	public long getAlltime() {
    78. 

  78. 		return alltime;
    79. 

  79. 	}
    80. 

    81. 

  81. 	public void setAlltime(long alltime) {
    82. 

  82. 		this.alltime = alltime;
    83. 

  83. 	}
    84. 

    85. 

  85. 	public long getStartblock() {
    86. 

  86. 		return startblock;
    87. 

  87. 	}
    88. 

    89. 

  89. 	public void setStartblock(long startblock) {
    90. 

  90. 		this.startblock = startblock;
    91. 

  91. 	}
    92. 

    93. 

  93. }
    94.

好了，现在是主要的线程调度算法，注意优先级的调整：

    

  1. import java.util.ArrayList;
    2. 

  2. import java.util.Arrays;
    3. 

  3. import java.util.Comparator;
    4. 

  4. import java.util.Iterator;
    5. 

  5. import java.util.List;
    6. 

    7. 

  7. public class OrderImitate {
    8. 

  8. 	
    9. 

  9. //  按优先级次序排列的数组
    10. 

  10. 	private ArrayList<PCB> priorityArrayList = null;
    11. 

  11. 	
    12. 

  12. 	
    13. 

  13. /**
    14. 

  14.  * 	优先级排序
    15. 

  15.  */
    16. 

  16. 	public void sortArray(){
    17. 

  17. 		PCB[] pcbs = (PCB[])priorityArrayList.toArray(new PCB[priorityArrayList.size()]);
    18. 

  18. 		Arrays.sort(pcbs, new MyComprator());
    19. 

  19. 		List<PCB> list = Arrays.asList(pcbs);
    20. 

  20. 		this.priorityArrayList = new ArrayList<PCB>(list);
    21. 

  21. 	}
    22. 

  22. 	
    23. 

  23. /**
    24. 

  24.  * 	初始化，按照书中的数据进行初始化操作
    25. 

  25.  */
    26. 

  26. 	private void init(){
    27. 

  27. 		priorityArrayList = new ArrayList<PCB>();
    28. 

  28. 		PCB zero = new PCB(0, 9, 0, 3, 2, 3, PCB.STATE_READY);
    29. 

  29. 		priorityArrayList.add(zero);
    30. 

  30. 		
    31. 

  31. 		PCB one = new PCB(1, 38, 0, 3, -1, 0, PCB.STATE_READY);
    32. 

  32. 		priorityArrayList.add(one);
    33. 

  33. 		
    34. 

  34. 		PCB two = new PCB(2, 30, 0, 6, -1, 0, PCB.STATE_READY);
    35. 

  35. 		priorityArrayList.add(two);
    36. 

  36. 		
    37. 

  37. 		PCB three = new PCB(3, 29, 0, 3, -1, 0, PCB.STATE_READY);
    38. 

  38. 		priorityArrayList.add(three);
    39. 

  39. 		
    40. 

  40. 		PCB four = new PCB(4, 0, 0, 4, -1, 0, PCB.STATE_READY);
    41. 

  41. 		priorityArrayList.add(four);
    42. 

  42. 		
    43. 

  43. 		sortArray();
    44. 

  44. 	}
    45. 

  45. 	
    46. 

  46. 	
    47. 

  47. /**
    48. 

  48.  * 优先级执行算法
    49. 

  49.  * @return
    50. 

  50.  */
    51. 

  51. 	public boolean hightpPriority(){
    52. 

  52. 		
    53. 

  53. //		获得第一个元素
    54. 

  54. 		PCB first = priorityArrayList.get(0);
    55. 

  55. 		
    56. 

  56. 		if(!first.getState().equals(PCB.STATE_BLOCK)){
    57. 

  57. //			运行一次优先级顺序-3
    58. 

  58. 			first.setPriority(first.getPriority()-3);
    59. 

  59. 			first.setCputime(first.getCputime()+1);
    60. 

  60. 			first.setAlltime(first.getAlltime()-1);
    61. 

  61. //			是否进入阻塞状态
    62. 

  62. 			if(first.getStartblock() > 0){
    63. 

  63. 				first.setStartblock(first.getStartblock() - 1);
    64. 

  64. 			}
    65. 

  65. //			当是阻塞状态的时候，将状态变为阻塞
    66. 

  66. 			if(first.getStartblock() == 0){
    67. 

  67. 				first.setState(PCB.STATE_BLOCK);
    68. 

  68. 			}
    69. 

  69. 		}
    70. 

  70. 		
    71. 

  71. //		所需要的时间片完成，结束运行
    72. 

  72. 		if(first.getAlltime() == 0){
    73. 

  73. 			System.out.println("----------------------------------------------");
    74. 

  74. 			System.out.println("ID " + first.getId() + " have done !");
    75. 

  75. 			System.out.println("----------------------------------------------");
    76. 

  76. 			priorityArrayList.remove(0);
    77. 

  77. 		}
    78. 

  78. 		
    79. 

  79. //		后面的任务优先级+1
    80. 

  80. 		Iterator<PCB> iterator = priorityArrayList.iterator();
    81. 

  81. 		int count = 0;
    82. 

  82. 		while(iterator.hasNext()){
    83. 

  83. 			if(count == 0){
    84. 

  84. 				count++;
    85. 

  85. 				iterator.next();
    86. 

  86. 				continue;
    87. 

  87. 			}
    88. 

  88. 			PCB pcb = iterator.next();
    89. 

  89. 			pcb.setPriority(pcb.getPriority()+1);
    90. 

  90. //			PCB的阻塞状态改变
    91. 

  91. 			if(pcb.getBlocktime() != 0 && pcb.getState().equals(PCB.STATE_BLOCK)){
    92. 

  92. 				pcb.setBlocktime(pcb.getBlocktime() -1);
    93. 

  93. 				if(pcb.getBlocktime() == 0){
    94. 

  94. 					pcb.setState(PCB.STATE_READY);
    95. 

  95. 				}
    96. 

  96. 			}
    97. 

  97. 		}
    98. 

  98. 		
    99. 

  99. 		sortArray();
    100. 

  100. 		
    101. 

  101. 		return true;
    102. 

  102. 	}
    103. 

  103. 	
    104. 

  104. 	/**
    105. 

  105. 	 * 执行程序
    106. 

  106. 	 */
    107. 

  107. 	public void startRuning(){
    108. 

  108. 		while(hightpPriority()){
    109. 

  109. 			if(this.priorityArrayList.size() == 0){
    110. 

  110. 				System.out.println("-----------------> ALL Works have done !");
    111. 

  111. 				break;
    112. 

  112. 			}
    113. 

  113. //			输出数据
    114. 

  114. 			Iterator<PCB> iterator = priorityArrayList.iterator();
    115. 

  115. 			System.out.println("-----------------------------------------------------------------------------------------");
    116. 

  116. 			System.out.println("ID      PRIORITY      CPUTIME      ALLTIME      STARTBLOCK      BLOCKTIME      STATE");
    117. 

  117. 			while(iterator.hasNext()){
    118. 

  118. 				PCB pcb = iterator.next();
    119. 

  119. 				System.out
    120. 

  120. 						.printf("%d %8d %12d %12d %13d %14d %18s\n", pcb.getId(),
    121. 

  121. 								pcb.getPriority(), pcb.getCputime(),
    122. 

  122. 								pcb.getAlltime(), pcb.getStartblock(),
    123. 

  123. 								pcb.getBlocktime(), pcb.getState());
    124. 

  124. 			}
    125. 

  125. 			System.out.println("-----------------------------------------------------------------------------------------");
    126. 

  126. 		}
    127. 

  127. 	}
    128. 

  128. 	
    129. 

  129. 	public static void main(String[] args) {
    130. 

  130. 		OrderImitate orderImitate = new OrderImitate();
    131. 

  131. 		orderImitate.init();
    132. 

  132. 		orderImitate.startRuning();
    133. 

  133. 	}
    134. 

  134. 	
    135. 

  135. //	优先级次序调整，优先级高且没有阻塞的进程在前面
    136. 

  136. 	class MyComprator implements Comparator<PCB> {
    137. 

  137. 	    public int compare(PCB o1, PCB o2) {
    138. 

  138. 	    	
    139. 

  139. 			if((o1.getState().equals(PCB.STATE_READY) && o2.getState().equals(PCB.STATE_READY)) || (o1.getState().equals(PCB.STATE_BLOCK) && o2.getState().equals(PCB.STATE_BLOCK))){
    140. 

  140. 				if(o1.getPriority() == o2.getPriority() ){
    141. 

  141. 					return 0;
    142. 

  142. 				}
    143. 

  143. 				else if(o1.getPriority() > o2.getPriority()){
    144. 

  144. 					return -1;
    145. 

  145. 				}else {
    146. 

  146. 					return 1;
    147. 

  147. 				}
    148. 

  148. 			}else if(o1.getState().equals(PCB.STATE_BLOCK) && o2.getState().equals(PCB.STATE_READY)){
    149. 

  149. 				return 1;
    150. 

  150. 			}else{
    151. 

  151. 				return -1; 
    152. 

  152. 			}
    153. 

  153. 			
    154. 

  154. 		}
    155. 

  155. 	}
    156. 

  156. 	
    157. 

  157. }
    158.

一开始是想用优先队列的，但是碰上个问题，如果有多个线程同时进入阻塞状态，那么就可能第二个到后面那个都无法运行，这样没有完全排好序的优先队列就没有办法使用了，而且优先队列碰上一个大的问题，不知道什么，中途修改了队列中的值没有触发队列的排序，导致后面的一系列次序无法进行。

好的，现在看看最后的结果：

    

  1. -----------------------------------------------------------------------------------------
    2. 

  2. ID      PRIORITY      CPUTIME      ALLTIME      STARTBLOCK      BLOCKTIME      STATE
    3. 

  3. 1       35            1            2            -1              0              READY
    4. 

  4. 2       31            0            6            -1              0              READY
    5. 

  5. 3       30            0            3            -1              0              READY
    6. 

  6. 0       10            0            3             2              3              READY
    7. 

  7. 4        1            0            4            -1              0              READY
    8. 

  8. -----------------------------------------------------------------------------------------
    9. 

  9. -----------------------------------------------------------------------------------------
    10. 

  10. ID      PRIORITY      CPUTIME      ALLTIME      STARTBLOCK      BLOCKTIME      STATE
    11. 

  11. 1       32            2            1            -1              0              READY
    12. 

  12. 2       32            0            6            -1              0              READY
    13. 

  13. 3       31            0            3            -1              0              READY
    14. 

  14. 0       11            0            3             2              3              READY
    15. 

  15. 4        2            0            4            -1              0              READY
    16. 

  16. -----------------------------------------------------------------------------------------
    17. 

  17. ----------------------------------------------
    18. 

  18. ID 1 have done !
    19. 

  19. ----------------------------------------------
    20. 

  20. -----------------------------------------------------------------------------------------
    21. 

  21. ID      PRIORITY      CPUTIME      ALLTIME      STARTBLOCK      BLOCKTIME      STATE
    22. 

  22. 2       32            0            6            -1              0              READY
    23. 

  23. 3       32            0            3            -1              0              READY
    24. 

  24. 0       12            0            3             2              3              READY
    25. 

  25. 4        3            0            4            -1              0              READY
    26. 

  26. -----------------------------------------------------------------------------------------
    27. 

  27. -----------------------------------------------------------------------------------------
    28. 

  28. ID      PRIORITY      CPUTIME      ALLTIME      STARTBLOCK      BLOCKTIME      STATE
    29. 

  29. 3       33            0            3            -1              0              READY
    30. 

  30. 2       29            1            5            -1              0              READY
    31. 

  31. 0       13            0            3             2              3              READY
    32. 

  32. 4        4            0            4            -1              0              READY
    33. 

  33. -----------------------------------------------------------------------------------------
    34. 

  34. -----------------------------------------------------------------------------------------
    35. 

  35. ID      PRIORITY      CPUTIME      ALLTIME      STARTBLOCK      BLOCKTIME      STATE
    36. 

  36. 3       30            1            2            -1              0              READY
    37. 

  37. 2       30            1            5            -1              0              READY
    38. 

  38. 0       14            0            3             2              3              READY
    39. 

  39. 4        5            0            4            -1              0              READY
    40. 

  40. -----------------------------------------------------------------------------------------
    41. 

  41. -----------------------------------------------------------------------------------------
    42. 

  42. ID      PRIORITY      CPUTIME      ALLTIME      STARTBLOCK      BLOCKTIME      STATE
    43. 

  43. 2       31            1            5            -1              0              READY
    44. 

  44. 3       27            2            1            -1              0              READY
    45. 

  45. 0       15            0            3             2              3              READY
    46. 

  46. 4        6            0            4            -1              0              READY
    47. 

  47. -----------------------------------------------------------------------------------------
    48. 

  48. -----------------------------------------------------------------------------------------
    49. 

  49. ID      PRIORITY      CPUTIME      ALLTIME      STARTBLOCK      BLOCKTIME      STATE
    50. 

  50. 2       28            2            4            -1              0              READY
    51. 

  51. 3       28            2            1            -1              0              READY
    52. 

  52. 0       16            0            3             2              3              READY
    53. 

  53. 4        7            0            4            -1              0              READY
    54. 

  54. -----------------------------------------------------------------------------------------
    55. 

  55. -----------------------------------------------------------------------------------------
    56. 

  56. ID      PRIORITY      CPUTIME      ALLTIME      STARTBLOCK      BLOCKTIME      STATE
    57. 

  57. 3       29            2            1            -1              0              READY
    58. 

  58. 2       25            3            3            -1              0              READY
    59. 

  59. 0       17            0            3             2              3              READY
    60. 

  60. 4        8            0            4            -1              0              READY
    61. 

  61. -----------------------------------------------------------------------------------------
    62. 

  62. ----------------------------------------------
    63. 

  63. ID 3 have done !
    64. 

  64. ----------------------------------------------
    65. 

  65. -----------------------------------------------------------------------------------------
    66. 

  66. ID      PRIORITY      CPUTIME      ALLTIME      STARTBLOCK      BLOCKTIME      STATE
    67. 

  67. 2       25            3            3            -1              0              READY
    68. 

  68. 0       18            0            3             2              3              READY
    69. 

  69. 4        9            0            4            -1              0              READY
    70. 

  70. -----------------------------------------------------------------------------------------
    71. 

  71. -----------------------------------------------------------------------------------------
    72. 

  72. ID      PRIORITY      CPUTIME      ALLTIME      STARTBLOCK      BLOCKTIME      STATE
    73. 

  73. 2       22            4            2            -1              0              READY
    74. 

  74. 0       19            0            3             2              3              READY
    75. 

  75. 4       10            0            4            -1              0              READY
    76. 

  76. -----------------------------------------------------------------------------------------
    77. 

  77. -----------------------------------------------------------------------------------------
    78. 

  78. ID      PRIORITY      CPUTIME      ALLTIME      STARTBLOCK      BLOCKTIME      STATE
    79. 

  79. 0       20            0            3             2              3              READY
    80. 

  80. 2       19            5            1            -1              0              READY
    81. 

  81. 4       11            0            4            -1              0              READY
    82. 

  82. -----------------------------------------------------------------------------------------
    83. 

  83. -----------------------------------------------------------------------------------------
    84. 

  84. ID      PRIORITY      CPUTIME      ALLTIME      STARTBLOCK      BLOCKTIME      STATE
    85. 

  85. 2       20            5            1            -1              0              READY
    86. 

  86. 0       17            1            2             1              3              READY
    87. 

  87. 4       12            0            4            -1              0              READY
    88. 

  88. -----------------------------------------------------------------------------------------
    89. 

  89. ----------------------------------------------
    90. 

  90. ID 2 have done !
    91. 

  91. ----------------------------------------------
    92. 

  92. -----------------------------------------------------------------------------------------
    93. 

  93. ID      PRIORITY      CPUTIME      ALLTIME      STARTBLOCK      BLOCKTIME      STATE
    94. 

  94. 0       17            1            2             1              3              READY
    95. 

  95. 4       13            0            4            -1              0              READY
    96. 

  96. -----------------------------------------------------------------------------------------
    97. 

  97. -----------------------------------------------------------------------------------------
    98. 

  98. ID      PRIORITY      CPUTIME      ALLTIME      STARTBLOCK      BLOCKTIME      STATE
    99. 

  99. 4       14            0            4            -1              0              READY
    100. 

  100. 0       14            2            1             0              3              BLOCK
    101. 

  101. -----------------------------------------------------------------------------------------
    102. 

  102. 可以看到这里因为线程阻塞产生了调度：
    103. 

  103. -----------------------------------------------------------------------------------------
    104. 

  104. ID      PRIORITY      CPUTIME      ALLTIME      STARTBLOCK      BLOCKTIME      STATE
    105. 

  105. 4       11            1            3            -1              0              READY
    106. 

  106. 0       15            2            1             0              2              BLOCK
    107. 

  107. -----------------------------------------------------------------------------------------
    108. 

  108. -----------------------------------------------------------------------------------------
    109. 

  109. ID      PRIORITY      CPUTIME      ALLTIME      STARTBLOCK      BLOCKTIME      STATE
    110. 

  110. 4        8            2            2            -1              0              READY
    111. 

  111. 0       16            2            1             0              1              BLOCK
    112. 

  112. -----------------------------------------------------------------------------------------
    113. 

  113. -----------------------------------------------------------------------------------------
    114. 

  114. ID      PRIORITY      CPUTIME      ALLTIME      STARTBLOCK      BLOCKTIME      STATE
    115. 

  115. 0       17            2            1             0              0              READY
    116. 

  116. 4        5            3            1            -1              0              READY
    117. 

  117. -----------------------------------------------------------------------------------------
    118. 

  118. ----------------------------------------------
    119. 

  119. ID 0 have done !
    120. 

  120. ----------------------------------------------
    121. 

  121. -----------------------------------------------------------------------------------------
    122. 

  122. ID      PRIORITY      CPUTIME      ALLTIME      STARTBLOCK      BLOCKTIME      STATE
    123. 

  123. 4        5            3            1            -1              0              READY
    124. 

  124. -----------------------------------------------------------------------------------------
    125. 

  125. ----------------------------------------------
    126. 

  126. ID 4 have done !
    127. 

  127. ----------------------------------------------
    128. 

  128. -----------------> ALL Works have done !
    129.

来自为知笔记(Wiz)

时间： 2024-10-10 17:57:47

使用Java模拟操作系统高优先级算法的相关文章

C程序模拟实现银行家算法

上周又做操作系统实验,题目是用程序模拟实现银行家算法,写了半天还真有点晕,主要是因为想尽可能符合课本上的描述,所以写出来的程序就比较恶心了,好了,银行家算法就不多说了,不了解的可以先看一下百度百科上的描述,分段上代码吧.完整代码包下载地址:http://files.cnblogs.com/pianoid/Banker.rar 首先要定义一些结构体,为了符合课本描述,我只定义了一个结构体: typedef struct { int A; int B; int C;}RESOURCE; 结构体里面的

java 与操作系统进程同步问题（二）————经典消费者生产者问题

http://www.cnblogs.com/zyp4614/p/6033757.html (java 与操作系统进程同步问题(一)----互斥问题) 今天写的是最经典的生产者消费者问题,最简单的版本,即只有一个缓冲区,缓冲区中只能放一个物品,即不考虑互斥关系. 问题简单分析: 生产者在缓冲区为空的时候可以往缓冲区中放产品,消费者可以在缓冲区不空(即缓冲区中有产品时)可以取一个产品. 首先可以确定有两个信号量 第一个信号量,是缓冲区是否空,当空的时候生产者可以放入产品,初值为1,因为默认缓冲区是

Java模拟生产者消费者问题

一.Syncronized方法详解 解决生产者消费这问题前,先来了解一下Java中的syncronized关键字. synchronized关键字用于保护共享数据.请大家注意"共享数据",你一定要分清哪些数据是共享数据,如下面程序中synchronized关键字保护的不是共享数据(其实在这个程序中synchronized关键字没有起到任何作用,此程序的运行结果是不可预先确定的).这个程序中的t1,t2是 两个对象(pp1,pp2)的线程.JAVA是面向对象的程序设计语言,不同的对象的数

java模拟而一个电话本操作

哈哈,大家平时都在使用电话本,下面使用java来模拟而一个简单的电话本吧... 首先给出联系人的抽象类 package net.itaem.po; /** * * 电话人的信息 * */ public class User { private String name; private String phoneNumber; private String companyName; private String email; private String address; private Strin

Java中的经典算法之冒泡排序(Bubble Sort)

Java中的经典算法之冒泡排序(Bubble Sort) 原理:比较两个相邻的元素,将值大的元素交换至右端. 思路:依次比较相邻的两个数,将小数放在前面,大数放在后面.即在第一趟:首先比较第1个和第2个数,将小数放前,大数放后.然后比较第2个数和第3个数,将小数放前,大数放后,如此继续,直至比较最后两个数,将小数放前,大数放后.重复第一趟步骤,直至全部排序完成. 举例说明:要排序数组:int[] arr={6,3,8,2,9,1}; 第一趟排序: 第一次排序:6和3比较,6大于3,交换位置:  

java模拟手动Telnet过程之需求说明和功能点说明

一.需求 (一)每五分钟查询一次交换机的连接情况: (二)每2.5分钟更新每栋楼的连接情况. 二.功能点 序号 功能点说明 待定 完成 未完成 完成时间 预计用时(min) 实际用时(min) 备注 1 登录口令加密以及解密         60     2 表的创建和IP以及口令写入数据库         10     3 java模拟手动Telnet交换机         90     4 获取目标字符串         30     5 表的创建与当前目标数据的写入         10

Lua中table内建排序与C/C++/Java/php/等内排序算法的排序效率比较

Lua这类脚本语言在处理业务逻辑作为配置文件的时候方便省事 但是在大量需要 运算的地方就显得略微不足   按照 Lua内建排序算法 对比C/C++ PHP Java等的快速排序算法进行一下比较. 快速排序算法是基于冒泡排序,优化而来,时间复杂度T(n)=O(nLog2n)  ,可见内部采用了二分策略 . 发现在LuaIDE LDT下直接运行效率要比 通过C++加载运行Lua脚本效率高的多  拿500W个数据排序 来说  ,脚本如下 同样的排序脚本Lua解释器的内置排序算法在LDT下,运行速度比通

java模拟面试 试题

java 四类八种基本数据类型 第一类:整型 byte short int long 第二类:浮点型 float double 第三类:逻辑型 Boolean(取值为 true false) 第四类:字符型 char & 与 运算符. | 或 是java中的位运算符,对二进制进行计算,两位都是1返回1,否则返回0. ^ 异或 是java中的位运算符,对二进制进行计算,两位不同返回1,否则返回0. == 可以用来比较引用类型(比较的是虚地址),也可以用来比较基本数据类型(比较的是二进制). 值得注

Jsoup实现java模拟登陆

Jsoup实现java模拟登陆 1:如何获取cookies. 1.1:由于需要登录,故先模拟登陆时的那一个<form>,这里用map来装载变量名称,变量值. Map<String, String> map = new HashMap<String, String>(); map.put("username", username); map.put("pwd", md5.getMD5ofStr(password)); map.put