Java实现读者写者问题(读者优先)(进程同步)

╰半夏微凉° 2022-05-24 02:55 272阅读 0赞

读者-写者问题的读写操作限制(包括读者优先和写者优先):

1) 写-写互斥,即不能有两个写者同时进行写操作。

2) 读-写互斥,即不能同时有一个线程在读,而另一个线程在写。

3) 读-读允许,即可以有一个或多个读者在读。

读者优先的附加限制:如果一个读者申请进行读操作时已有另一个读者正在进行读操作,则该读者可直接开始读操作。

写者优先的附加限制:如果一个读者申请进行读操作时已有另一写者在等待访问共享资源,则该读者必须等到没有写者处于等待状态后才能开始读操作。

运行结果显示要求:要求在每个线程创建、发出读写操作申请、开始读写操作和结束读写操作时分别显示一行提示信息,以确定所有处理都遵守相应的读写操作限制。

测试数据简介:数据数据包括n行测试数据,分别描述创建的n个线程是读者还是写者,以及读写操作的开始时间和持续时间。每行测试数据包括四个字段,各个字段间用空格分隔。第一字段为一个正整数,表示线程序号。第二字段表示相应线程角色,R表示读者,w表示写者。第三字段为一个正数,表示读写操作的开始时间:线程创建后,延迟相应时间(单位为秒)后发出对共享资源的读写申请。第四字段为一个正数,表示读写操作的持续时间。

  1. package 进程同步;
  2. public class Jinchengtongbu {
  3. public static void main(String[] args) {
  4. // TODO Auto-generated method stub
  5. String name[]={" 进程序号", " 读写者", " ", "开始时间"," 运行时间"};
  6. for(int i=0;i<name.length;i++){
  7. System.out.print(name[i]);
  8. }
  9. System.out.println();
  10. String arr[][]= {
  11. {"1","r","3"
  12. ,"5"}, {"2","w","5","5"},{"3","r","4","2"},{"4","w","10","1"}};
  13. int j,i;
  14. for(j=0;j<arr.length;j++){
  15. for(i=0;i<arr[j].length;i++){
  16. System.out.print( " "+ arr[j][i]);
  17. }
  18. System.out.println();
  19. }
  20. int a = Integer.parseInt(arr[0][2]);//从0开始最好
  21. int b = Integer.parseInt(arr[1][2]);
  22. int c = Integer.parseInt(arr[2][2]);
  23. int d = Integer.parseInt(arr[3][2]);
  24. int sort[]={a,b,c,d};
  25. // Arrays.sort(sort);
  26. System.out.println();
  27. for(int k=0;k<sort.length;k++){
  28. for(int o=k+1;o<sort.length;o++){
  29. if(sort[o]<sort[k]){
  30. String f= arr[k][2];
  31. String s= arr[k][0];
  32. String m= arr[k][1];
  33. String n= arr[k][3];
  34. int su = sort[o];
  35. arr[k][2]=arr[o][2];
  36. arr[k][0]=arr[o][0];
  37. arr[k][1]=arr[o][1];
  38. arr[k][3]=arr[o][3];
  39. sort[o]=sort[k];
  40. arr[o][2]= f;
  41. arr[o][0]= s;
  42. arr[o][1]= m;
  43. arr[o][3]= n;
  44. sort[k] = su;
  45. }
  46. }
  47. }
  48. for( i=0;i<name.length;i++){
  49. System.out.print(name[i]);
  50. }
  51. System.out.println();
  52. for(j=0;j<arr.length;j++){
  53. for(i=0;i<arr[j].length;i++){
  54. System.out.print( " "+ arr[j][i]);
  55. }
  56. System.out.println();
  57. }
  58. int a1 = Integer.parseInt(arr[0][2]);//第三列
  59. int a2 = Integer.parseInt(arr[0][3]);//第四列
  60. int a3 = Integer.parseInt(arr[0][0]);//第一列
  61. int a4 = 0;//用来结束程序
  62. int t1= 0;//程序开始后计时
  63. int b1 = Integer.parseInt(arr[1][2]);
  64. int b2 = Integer.parseInt(arr[1][3]);
  65. int b3 = Integer.parseInt(arr[1][0]);
  66. int b4 = 0;
  67. int t2= 0;
  68. int c1 = Integer.parseInt(arr[2][2]);
  69. int c2 = Integer.parseInt(arr[2][3]);
  70. int c3 = Integer.parseInt(arr[2][0]);
  71. int c4 = 0;
  72. int t3= 0;
  73. int d1 = Integer.parseInt(arr[3][2]);
  74. int d2 = Integer.parseInt(arr[3][3]);
  75. int d3 = Integer.parseInt(arr[3][0]);
  76. int d4 = 0;
  77. int t4= 0;
  78. int ci1 = 0,ci2 = 0,ci3 = 0,ci4 = 0;
  79. int sam = 0;//空闲
  80. int num = 0;
  81. for(int t=0;t<30;t++) {
  82. System.out.println("时间:"+num);
  83. num=num+1;
  84. if((a1==t && arr[0][1]=="r" ||( a1<=t && arr[0][1]=="w" && sam==0 )) && ci1==0){
  85. System.out.println("开始"+a3+"号程序");
  86. ci1=ci1+1;//为了只输出一次
  87. a4 = a2;
  88. }
  89. if(arr[0][1]=="w" && ci1==1 ){//ci1表示开始
  90. t1=t1+1;
  91. if(t1==a4) {
  92. a4=0;
  93. System.out.println(a3+"号程序结束");
  94. arr[0][1]="ch";
  95. t=t-t1+1;//把写者踢出
  96. sam = 0;
  97. }
  98. continue;
  99. }
  100. if(a4!=0) {
  101. t1=t1+1;
  102. sam = sam+1;
  103. if(t1==a4) {
  104. System.out.println(a3+"号程序结束");
  105. sam = sam-a4;
  106. a4=0;
  107. }
  108. }
  109. if((b1==t && arr[1][1]=="r" ||( b1<=t && arr[1][1]=="w" && sam==0 ))&&ci2==0){
  110. System.out.println("开始"+b3+"号程序");
  111. ci2=ci2+1;
  112. b4 = b2;
  113. }
  114. if(arr[1][1]=="w" && ci2==1 ){
  115. t2=t2+1;
  116. if(t2==b4) {
  117. b4=0;
  118. System.out.println(b3+"号程序结束");
  119. arr[1][1]="ch";
  120. t=t-t2+1;
  121. sam = 0;
  122. }
  123. continue;
  124. }
  125. if(b4!=0) {
  126. t2=t2+1;
  127. sam = sam+1;
  128. if(t2==b4) {
  129. System.out.println(b3+"号程序结束");
  130. sam = sam-b4;
  131. b4=0;
  132. }
  133. }
  134. if((c1==t && arr[2][1]=="r" ||( c1<=t && arr[2][1]=="w" && sam==0 ))&&ci3==0){
  135. System.out.println("开始"+c3+"号程序");
  136. ci3=ci3+1;
  137. c4 = c2;
  138. }
  139. if(arr[2][1]=="w" && ci3==1 ){
  140. t3=t3+1;
  141. if(t3==c4) {
  142. c4=0;
  143. System.out.println(c3+"号程序结束");
  144. arr[2][1]="ch";
  145. t=t-t3+1;
  146. sam = 0;
  147. }
  148. continue;
  149. }
  150. if(c4!=0) {
  151. t3=t3+1;
  152. sam = sam+1;
  153. if(t3==c4) {
  154. System.out.println(c3+"号程序结束");
  155. sam = sam-c4;
  156. c4=0;
  157. }
  158. }
  159. if((d1==t && arr[3][1]=="r" ||( d1<=t && arr[3][1]=="w" && sam==0 )) && ci4==0){
  160. System.out.println("开始"+d3+"号程序");
  161. ci4=ci4+1;//为了只输出一次
  162. d4 = d2;
  163. }
  164. if(arr[3][1]=="w" && ci4==1 ){//ci1表示开始
  165. t4=t4+1;
  166. if(t4==d4) {
  167. d4=0;
  168. System.out.println(d3+"号程序结束");
  169. arr[3][1]="ch";
  170. t=t-t4+1;//把写者踢出
  171. sam = 0;
  172. break;
  173. }
  174. continue;
  175. }
  176. if(d4!=0) {
  177. t4=t4+1;
  178. sam = sam+1;
  179. if(t4==d4) {
  180. System.out.println(d3+"号程序结束");
  181. sam = sam-d4;
  182. d4=0;
  183. break;
  184. }
  185. }
  186. }
  187. System.out.println();
  188. }
  189. }

发表评论

表情:
评论列表 (有 0 条评论,272人围观)

还没有评论,来说两句吧...

相关阅读

    相关 读者--问题

    读者--写者问题 问题描述 问题分析 如何实现 总结 问题描述 有读者和写者两组并发进程,共享一个文件,当两个或两个以上的读进程同时访问共

    相关 同步机制—读者问题

    【实验目的】 理解临界区和进程互斥的概念,掌握用信号量和PV操作实现进程互斥的方法。 【实验内容】 在windows或者linux环境下编写一个控制台应用程序,该程序运行