话不多说，上题目：

19.进程和线程为实现比简单的串行程序复杂的多的程序提供了强大的构造工具,一个很有启发性的程序是早期结构的协同程序.本习题的目的是介绍协同程序.

   从文件中读以行为单位的字符串最多80个字符,并通过下列改变把它们打印在包含125个字符的行中，不足以“－”代替,在每行字符串最后插入一个额外的空格字符,并且每行中每对“你妹”字符用“*”代替

a. 开发关于该问题的一种普通的串行程序解决方案,为提高清晰度并减少可能的错误的一种方法是把该程序编写成三个独立的过程，第一个过程读取文件的行，在每一行的后面补充空格，第二个过程将字符流写入一个临时文件或内存中。第三个过程从第二个过程产生的临时文件中读取字符流，按每行125个字符进行处理和打印。

b. 串行方案之所以没有吸引力，是因为临时文件的开销。Conway提出了一种新的程序结构格式：协同程序，它允许把应用程序编写成通过一个字符缓冲区连接起来的三个程序，如例题：在传统的过程中，在调用过程和被调用过程间存在一个主/从的关系，有调用的程序和被调用的程序。协同程序显示出一种对称的关系，在每次进行调用时，从被调用的过程中上一次的活跃点开始执行。由于没有调用过程高于被调用过程的感觉，也就没有返回。相反，任何一个协同程序都可以通过恢复命令把控制传递给另一个协同程序。当一个协同程序第一次被调用时，它在入口被“恢复”，接下来，该协同程序在它拥有上一个恢复命令处被重新激活。注意，程序中一次只能有一个协同程序处于执行状态。

c. 使用同步来完成这个程序

d. 思考，如果过滤的字符串没有预先定下来，程序应该如何编写，试编写完成

1. /**
   
2. * 协同程序的伪代码
   
3. */
   
4. public class ConWork {
   
5. //读程序用处理字符
   
6. char rs;
   
7. //打印用处理字符
   
8. char sp;
   
9. char[] inbuff=new char[80];
   
10. char[] outbuff=new char[125];
    
11. /**
    
12. * 读方法
    
13. */
    
14. public void read(){
    
15. while(true){
    
16. //TODO 读内容到inbuff中
    
17. for (int i = 0; i < inbuff.length; i++) {
    
18.             rs=inbuff[i];
    
19.             //TODO　唤醒处理方法　停止运行等待被唤醒
    
20.             }
    
21. rs=' ';
    
22. //TODO　唤醒处理方法　停止运行等待被唤醒
    
23. }
    
24. }
    
25. /**
    
26. * 打印方法
    
27. */
    
28. public void print(){
    
29. while(true){
    
30. for(int j=0;j<125;j++){
    
31. outbuff[j]=sp;
    
32. //TODO　唤醒处理方法　停止运行等待被唤醒
    
33. }
    
34. }
    
35. //TODO 输出outbuff中的内容
    
36. }
    
37. /**
    
38. * 处理方法
    
39. */
    
40. public void squash(){
    
41. while(true){
    
42. if(rs!='你'){
    
43. sp=rs;
    
44. //TODO　唤醒打印方法　停止运行等待被唤醒
    
45. }else{
    
46. //TODO　唤醒读方法　停止运行等待被唤醒
    
47. if(rs=='妹'){
    
48. sp='*';
    
49. //TODO　唤醒打印方法　停止运行等待被唤醒
    
50. }else{
    
51. //这种情况是说明前一个字符是符合的，后一个不符合，所以要还原
    
52. sp='你';
    
53. //TODO　唤醒打印方法　停止运行等待被唤醒
    
54. sp=rs;
    
55. //TODO　唤醒打印方法　停止运行等待被唤醒
    
56. }
    
57. }
    
58. //TODO　唤醒读方法　停止运行等待被唤醒
    
59. }
    
60. }
    
61. }

复制代码

题目如上，回复主题可以看到我写的代码，欢迎指点！

做了一半，实在受不鸟，放弃了。
1. 这道题为什么要用多线程？我想不出理由。题目说串行程序”将字符流写入一个临时文件或内存“，开销大。可是题目提供的所谓协同程序依然用了inbuff数组，没比串行程序少用内存啊。如果说协同程序每次只读一个字符，可串行单线程程序同样可以一个一个字符处理。这题本身就是非常普通的面向过程的思路，三个方法按一定顺序互相调用。用多线程加上同步才是增加了无谓开销。
2. 题目提供的协同程序伪代码设计上有问题。题目说每行至多80个字符，那么如果不到80个字符就换行了怎么办？17行for (int i = 0; i < inbuff.length; i++) 没考虑到这一点，每次都遍历80个字符，不妥。

fantacyleo 发表于 2014-9-14 15:37
做了一半，实在受不鸟，放弃了。
1. 这道题为什么要用多线程？我想不出理由。题目说串行程序”将字符流写入 ...

这道题是以前的老师给的，主要目的是让 练习 信号量 控制线程， 很伤神呢，呵呵，之前也做了好久，

这题其实不难，主要是那个伪代码太坑爹。

1. class StringPrinter {
   
2.         public static void print(Reader r) throws IOException {
   
3.                 BufferedReader br = new BufferedReader(r);
   
4.                 String aLine = null;
   
5.                 while ((aLine = br.readLine()) != null) {
   
6.                         printString(aLine);
   
7.                         System.out.println();
   
8.                 }
   
9.         }
   
10.         private static void printString(String aLine) {
    
11.                         int count = 0;
    
12.                         char[] chars = aLine.toCharArray();
    
13.                         boolean keywordBegin = false;
    
14.                         // 打印字符串
    
15.                         for (char c : chars) {
    
16.                                 if (c == '你') {
    
17.                                         keywordBegin = true;
    
18.                                 }
    
19.                                 else if (c == '妹' && keywordBegin == true) {
    
20.                                         System.out.print("**");
    
21.                                         count += 2;
    
22.                                         keywordBegin = false;
    
23.                                 }
    
24.                                 else if (keywordBegin == true) {
    
25.                                         System.out.print('你');
    
26.                                         System.out.print(c);
    
27.                                         count += 2;
    
28.                                         keywordBegin = false;
    
29.                                 }
    
30.                                 else {
    
31.                                         System.out.print(c);
    
32.                                         count++;
    
33.                                 }
    
34.                         }
    
35.                         // 字符串末尾加空格
    
36.                                 System.out.print(' ');
    
37.                                 count++;
    
38.                         // 补足125
    
39.                         for (int i = count; i < 125; i++)
    
40.                                 System.out.print('-');
    
41.         }
    
42. 
    
43. }

复制代码