免费注册 查看新帖 |

Chinaunix

  平台 论坛 博客 文库
最近访问板块 发新帖
查看: 3743 | 回复: 8
打印 上一主题 下一主题

请教:线程监视器状态异常 [复制链接]

论坛徽章:
0
跳转到指定楼层
1 [收藏(0)] [报告]
发表于 2004-11-29 19:10 |只看该作者 |倒序浏览
请教:线程监视器状态异常.谢谢!

Exception :java.lang.IllegalMonitorStateException: current thread not owner


  1. public class TestArea extends JPanel implements Runnable {

  2. JComboBox jcb1;
  3. //计时器线程
  4. Thread t1;
  5. //关闭计时器开关,暂停开关
  6. boolean b1,b2;
  7. //计时时间
  8. long l1=3600000;

  9. public TestArea() {
  10.     jcb1.addItemListener(new jcb1ItemListener(this));      
  11.     b1=false;
  12.     b2=false;
  13.     t1=new Thread(this);
  14. }
  15.    
  16. public synchronized void run() {
  17.     while(true) {
  18.        if(l1<=0) {
  19.            b1=true;
  20.            t1.interrupt();
  21.        }            
  22.        else {            
  23.            l1=l1-1000;
  24.       }
  25.       
  26.       try {
  27.            Thread.sleep(1000);
  28.       } catch(InterruptedException ie) {
  29.            if (b1==true) {
  30.                 return ;
  31.          }
  32.       }
  33.       
  34.       while(b2==true) {
  35.          try {
  36.             wait();
  37.          } catch(InterruptedException ie) {
  38.             if(b2==false) {
  39.                //Exception :java.lang.IllegalMonitorStateException: current thread not owner
  40.                notifyAll();
  41.             }
  42.          }
  43.       }
  44.    }
  45.    
  46. //inner class
  47. class jcb1ItemListener implements ItemListener {
  48.    TestArea ta1;
  49.    public jcb1ItemListener(TestArea ta1) {
  50.       this.ta1=ta1;
  51.    }
  52.    public void itemStateChanged(ItemEvent ie) {
  53.       if(t1.isAlive()) {
  54.          t1.interrupt();
  55.          b1=true;
  56.       }
  57.             
  58.       //实例化计时器线程
  59.       t1=new Thread(ta1);               
  60.    }         
  61. }

  62. //inner class
  63. class thisActionListener implements ActionListener {
  64.     TestArea ta1;
  65.     public thisActionListener(TestArea ta1) {
  66.         this.ta1=ta1;
  67.     }
  68.     public void actionPerformed(ActionEvent ae) {
  69.         try {
  70.             t1.start();
  71.         }catch(Exception e) {
  72.         }
  73.       
  74.        //暂停或继续计时
  75.        if(ae.getSource()==jb2) {
  76.            if(b2==false) {
  77.                           b2=true;
  78.               t1.interrupt();
  79.            }
  80.            else {
  81.                               if (b2==true){
  82.                                         try{
  83.                                                 t1.notifyAll();
  84.                     }catch (Exception e) {         
  85.                     }
  86.                 }
  87.             }
  88.         }
  89. }

  90. }
  91.        

复制代码

论坛徽章:
0
2 [报告]
发表于 2004-11-29 19:43 |只看该作者

请教:线程监视器状态异常

因为没有完整代码,不能重现你的错误。
你把Exception的Stack Trace贴出来吧。

论坛徽章:
0
3 [报告]
发表于 2004-11-30 00:17 |只看该作者

请教:线程监视器状态异常

java.lang.IllegalMonitorStateException: current thread not owner
        at java.lang.Object.notifyAll(Native Method)
        at TestArea$thisActionListener.actionPerformed(TestArea.java:290)
        at javax.swing.AbstractButton.fireActionPerformed(AbstractButton.java:17
86)
        at javax.swing.AbstractButton$ForwardActionEvents.actionPerformed(Abstra
ctButton.java:1839)
        at javax.swing.DefaultButtonModel.fireActionPerformed(DefaultButtonModel
.java:420)
        at javax.swing.DefaultButtonModel.setPressed(DefaultButtonModel.java:258
)
        at javax.swing.plaf.basic.BasicButtonListener.mouseReleased(BasicButtonL
istener.java:245)
        at java.awt.AWTEventMulticaster.mouseReleased(AWTEventMulticaster.java:2
31)
        at java.awt.Component.processMouseEvent(Component.java:5100)
        at java.awt.Component.processEvent(Component.java:4897)
        at java.awt.Container.processEvent(Container.java:1569)
        at java.awt.Component.dispatchEventImpl(Component.java:3615)
        at java.awt.Container.dispatchEventImpl(Container.java:1627)
        at java.awt.Component.dispatchEvent(Component.java:3477)
        at java.awt.LightweightDispatcher.retargetMouseEvent(Container.java:3483
)
        at java.awt.LightweightDispatcher.processMouseEvent(Container.java:319

        at java.awt.LightweightDispatcher.dispatchEvent(Container.java:312
        at java.awt.Container.dispatchEventImpl(Container.java:1613)
        at java.awt.Window.dispatchEventImpl(Window.java:1606)
        at java.awt.Component.dispatchEvent(Component.java:3477)
        at java.awt.EventQueue.dispatchEvent(EventQueue.java:456)
        at java.awt.EventDispatchThread.pumpOneEventForHierarchy(EventDispatchTh
read.java:201)
        at java.awt.EventDispatchThread.pumpEventsForHierarchy(EventDispatchThre
ad.java:151)
        at java.awt.EventDispatchThread.pumpEvents(EventDispatchThread.java:145)

        at java.awt.EventDispatchThread.pumpEvents(EventDispatchThread.java:137)

        at java.awt.EventDispatchThread.run(EventDispatchThread.java:100)

这里是一个计时器:
面板上有个按钮“暂停或继续”
按下后暂停计时已经实现,
在按继续时,不能恢复计时,抛出异常

论坛徽章:
0
4 [报告]
发表于 2004-11-30 00:22 |只看该作者

请教:线程监视器状态异常


  1. import java.awt.*;
  2. import java.awt.event.*;
  3. //import java.applet.*;
  4. import javax.swing.*;
  5. import java.io.*;

  6. public class TestArea extends JPanel implements Runnable {
  7.         Box bx1,bx2,bx3;       
  8.        
  9.         JLabel jl1,jl2,jl3,jl4;       
  10.         //Choice ch1;       
  11.         JComboBox jcb1;
  12.         JTextArea jta1,jta2;       
  13.         JScrollPane jsp1,jsp2;       
  14.         JButton jb1,jb2,jb3,jb4;       
  15.         JTextField jtf1;       
  16.         ButtonGroup bg1;
  17.         JRadioButton[] jrb1;
  18.        
  19.         JPanel jp1,jp2;
  20.                
  21.         //计时器线程
  22.         Thread t1;
  23.         //计时器开关,暂停开关
  24.         boolean b1,b2;       
  25.         //时间
  26.         long l1;

  27.         //含有试题和结果信息
  28.         ReadTestQuestion rtq1;
  29.        
  30.         public TestArea() {               
  31.                 bx1=Box.createVerticalBox();
  32.                 bx2=Box.createVerticalBox();
  33.                 bx3=Box.createHorizontalBox();
  34.                
  35.                 jl1=new JLabel("参加考试 提高水平");
  36.                 jl1.setFont(new Font("幼圆",Font.BOLD,18));
  37.                
  38.                 jl2=new JLabel("选择试题文件");
  39.                 jl2.setFont(new Font("幼圆",Font.PLAIN,16));
  40.                 jl3=new JLabel("剩余时间");
  41.                 jl3.setFont(new Font("幼圆",Font.PLAIN,16));
  42.                 jl4=new JLabel("试题显示");
  43.                 jl4.setFont(new Font("幼圆",Font.PLAIN,16));
  44.                
  45.                
  46.                 String s1=System.getProperty("user.dir");
  47.                 File f1=new File(s1);
  48.                 FileLastName fln1=new FileLastName("txt");
  49.                 String[] s2=f1.list(fln1);
  50.                                
  51.                 jcb1=new JComboBox();
  52.                 jcb1.setFont(new Font("幼圆",Font.PLAIN,16));
  53.                 jcb1.addItem("单击选择试题文件");
  54.                 for(int i=0;i<s2.length;i++) {
  55.                         jcb1.addItem(s2[i]);
  56.                 }
  57.                                
  58.                 jcb1.addItemListener(new jcb1ItemListener(this));
  59.                                
  60.                 jta1=new JTextArea(8,4);
  61.                 jta2=new JTextArea(12,6);
  62.                 jta1.setLineWrap(true);
  63.                 jta2.setLineWrap(true);
  64.                 jta1.setWrapStyleWord(true);
  65.                 jta2.setWrapStyleWord(true);
  66.                
  67.                 jsp1=new JScrollPane(jta1);
  68.                 jsp2=new JScrollPane(jta2);               
  69.                
  70.                 jb1=new JButton("查看分数");
  71.                 jb1.setFont(new Font("幼圆",Font.PLAIN,16));
  72.                 jb1.addActionListener(new thisActionListener(this));
  73.                 jb1.setToolTipText("可以看到你的测试结果");
  74.                 jb2=new JButton("暂停或继续计时");
  75.                 jb2.setFont(new Font("幼圆",Font.PLAIN,16));
  76.                 jb2.addActionListener(new thisActionListener(this));
  77.                 jb2.setToolTipText("你可以暂时休息一下");
  78.                 jb3=new JButton("提交答案");
  79.                 jb3.setFont(new Font("幼圆",Font.PLAIN,16));
  80.                 jb3.addActionListener(new thisActionListener(this));
  81.                 jb3.setToolTipText("提交后点击查分按钮");
  82.                 jb4=new JButton("读取首题");
  83.                 jb4.setFont(new Font("幼圆",Font.PLAIN,16));
  84.                 jb4.addActionListener(new thisActionListener(this));
  85.                 jb4.setToolTipText("看看后面的题目");

  86.                
  87.                 jtf1=new JTextField(20);
  88.                 jtf1.setEditable(false);
  89.                
  90.                 bg1=new ButtonGroup();
  91.                 jrb1=new JRadioButton[4];
  92.                 String[] jrb1S={"A","B","C","D"};
  93.                 for(int i=0;i<jrb1S.length;i++) {
  94.                         jrb1[i]=new JRadioButton(jrb1S[i]);               
  95.                         bg1.add(jrb1[i]);               
  96.                 }
  97.                
  98.                 jp1=new JPanel();               
  99.                 jp2=new JPanel();               
  100.                
  101.                 jp1.add(jb1);
  102.                 jp1.add(jb2);

  103.                 bx1.add(jl2);
  104.                 bx1.add(jcb1);
  105.                 bx1.add(jsp1);
  106.                 bx1.add(jp1);               
  107.                 bx1.add(jl3);
  108.                 bx1.add(jtf1);
  109.                
  110.                 for(int i=0;i<jrb1S.length;i++) {                       
  111.                         jp2.add(jrb1[i]);               
  112.                 }
  113.                 jp2.add(jb3);
  114.                 jp2.add(jb4);
  115.                
  116.                 bx2.add(jl4);
  117.                 bx2.add(jsp2);
  118.                 bx2.add(jp2);
  119.        
  120.                 bx3.add(bx1);
  121.                 bx3.add(bx2);
  122.                
  123.                 setLayout(new BorderLayout());
  124.                 add(jl1,BorderLayout.NORTH);
  125.                 add(bx3,BorderLayout.CENTER);
  126.                
  127.                 //计时器初始化,默认为null,即为没有计时器
  128.                 //计时器暂停开关,初始化为关闭
  129.                 b1=false;
  130.                 b2=false;
  131.                 t1=new Thread(this);
  132.                 rtq1=new ReadTestQuestion();
  133.         }
  134.        
  135.         public synchronized void run() {
  136.                 while(true) {
  137.                         if(l1<=0) {
  138.                                 jb3.setEnabled(false);
  139.                                 jb4.setEnabled(true);
  140.                                 b1=true;
  141.                                 t1.interrupt();
  142.                                 jtf1.setText("时间用完 测试结束");
  143.                         }
  144.                         else if(rtq1.getFinsh()) {
  145.                                 b1=true;
  146.                                 jtf1.setText("测试结果:"+rtq1.getSorce()+" 考试剩余时间:"+l1);
  147.                         }
  148.                         else {                               
  149.                                 long TS=l1/1000;                               
  150.                                 long H=TS/3600;TS=TS%3600;                               
  151.                                 long M=TS/60;TS=TS%60;
  152.                                 long S=TS;                               
  153.                                 jtf1.setText("还有 "+H+" 时 "+M+" 分 "+S+" 秒 ");
  154.                                
  155.                                 //时间减少
  156.                                 l1=l1-1000;
  157.                         }
  158.                        
  159.                         try {
  160.                                 Thread.sleep(1000);
  161.                         } catch(InterruptedException ie) {
  162.                                 if (b1==true) {
  163.                                         return ;
  164.                                 }
  165.                         }
  166.                        
  167.                         while(b2==true) {
  168.                                 try {
  169.                                         wait();
  170.                                 } catch(InterruptedException ie) {
  171.                                         if(b2==false) {
  172.                                                 notifyAll();
  173.                                         }
  174.                                 }
  175.                         }
  176.                 }               
  177.         }
  178.        
  179.         class jcb1ItemListener implements ItemListener {
  180.                 TestArea ta1;
  181.                
  182.                 public jcb1ItemListener(TestArea ta1) {
  183.                         this.ta1=ta1;
  184.                 }
  185.                 public void itemStateChanged(ItemEvent ie) {
  186.                         jtf1.setText("");
  187.                         jta1.setText("");
  188.                         jta2.setText("");
  189.                         for(int i=0;i<4;i++) {
  190.                                 jrb1[i].setSelected(false);       
  191.                         }
  192.                         jb3.setEnabled(false);
  193.                         jb4.setEnabled(true);       

  194.                         //获取选择的试题文件
  195.                         String s1=jcb1.getSelectedItem().toString().trim();
  196.                        
  197.                         if(s1.equals("单击选择试题文件")) {
  198.                                 jl1.setText("重新选择");
  199.                                 return ;
  200.                         }
  201.                         else {
  202.                                 jl1.setText("试题 "+s1+" 认真作答 祝福通关");
  203.                                
  204.                                 //设置要读取的文件名根据选择了的文件名
  205.                                 rtq1.setFilename(s1);
  206.                                 //初始化尚未完成考试
  207.                                 rtq1.setFinsh(false);
  208.                                 //获取本次考试的时间,根据试题文件的规定
  209.                                 l1=rtq1.getTestTime();
  210.                                
  211.                                 //关闭已经开启的计时器,同时把计时器置为中断状态
  212.                                 if(t1.isAlive()) {
  213.                                         t1.interrupt();
  214.                                         b1=true;
  215.                                 }
  216.                                
  217.                                 //实例化计时器线程
  218.                                 t1=new Thread(ta1);                                               
  219.                         }                       
  220.                 }
  221.         }
  222.        
  223.         class thisActionListener implements ActionListener {
  224.                 TestArea ta1;
  225.                 public thisActionListener(TestArea ta1) {
  226.                         this.ta1=ta2;
  227.                 }
  228.                 public void actionPerformed(ActionEvent ae) {
  229.                        
  230.                         //读取试题
  231.                         if(ae.getSource()==jb4) {
  232.                                 String s1=rtq1.getTestContent();
  233.                                 for(int i=0;i<4;i++) {
  234.                                         jrb1[i].setSelected(false);       
  235.                                 }       

  236.                                 try {
  237.                                         t1.start();
  238.                                 }catch(Exception e) {
  239.                                 }
  240.                                
  241.                                 jta1.setText("");
  242.                                 jta2.setText(s1);
  243.                                 jb3.setEnabled(true);
  244.                                 jb4.setEnabled(false);
  245.                         }

  246.                         //查看分数
  247.                         if(ae.getSource()==jb1) {
  248.                                 int i1=rtq1.getSorce();
  249.                                 String s1=rtq1.getMessage();
  250.                                 jta1.setText("你的测试得分:"+i1+"\n\n测试情况:\n"+s1);
  251.                         }
  252.                        
  253.                         //暂停或继续计时
  254.                         if(ae.getSource()==jb2) {
  255.                                 if(b2==false) {
  256.                                         b2=true;
  257.                                         jb2.setText("继续计时");                                       
  258.                                         t1.interrupt();                                                                                                                                       
  259.                                 }
  260.                                 else {                                       
  261.                                         jb2.setText("暂停计时");
  262.                                         if (b2==true){                                               
  263.                                                         t1.notifyAll();                                                                                       
  264.                                         }                                               
  265.                                 }
  266.                         }
  267.                        
  268.                         //提交答案
  269.                         if(ae.getSource()==jb3) {
  270.                                 jb3.setEnabled(false);
  271.                                 jb4.setEnabled(true);
  272.                                
  273.                                 String s1="?";
  274.                                 for(int i=0;i<4;i++) {
  275.                                         if(jrb1[i].isSelected()) {
  276.                                                 s1=jrb1[i].getText();
  277.                                                 break;
  278.                                         }
  279.                                 }
  280.                                 jb4.setText("读取下题");
  281.                                 rtq1.setSelect(s1);                       
  282.                         }
  283.                 }
  284.         }
  285. }

  286. //文件后缀过滤
  287. class FileLastName implements FilenameFilter {
  288.         String s1;
  289.         public FileLastName(String s1) {
  290.                 this.s1="."+s1;
  291.         }
  292.         //这里f1是目录;s2是文件名
  293.         public boolean accept(File f1,String s2) {
  294.                 return s2.endsWith(s1);
  295.         }
  296. }
复制代码

论坛徽章:
0
5 [报告]
发表于 2004-11-30 10:16 |只看该作者

请教:线程监视器状态异常

http://java.sun.com/j2se/1.5.0/docs/guide/misc/threadPrimitiveDeprecation.html
建议看一下这个文档,你的对线程的处理有些问题。
〔1〕不建议使用interrupt
〔2〕notifyAll()的用法不对。

论坛徽章:
0
6 [报告]
发表于 2004-12-02 16:45 |只看该作者

请教:线程监视器状态异常

谢谢你提供的参考!!

这是之前发现的线程控制变量b2的一些想法:

  1. /*
  2. * 创建日期 2004-11-25
  3. *
  4. * TODO 要更改此生成的文件的模板,请转至
  5. * 窗口 - 首选项 - Java - 代码样式 - 代码模板
  6. */

  7. /**
  8. * @author ttl_web
  9. *
  10. * TODO 要更改此生成的类型注释的模板,请转至
  11. * 窗口 - 首选项 - Java - 代码样式 - 代码模板
  12. */
  13. import java.awt.*;
  14. import java.awt.event.*;
  15. //import java.applet.*;
  16. import javax.swing.*;
  17. import java.io.*;

  18. //采用线程为计时器,实现Runnable接口run()
  19. public class TestArea extends JPanel implements Runnable {
  20.         Box bx1,bx2,bx3;       
  21.        
  22.         JLabel jl1,jl2,jl3,jl4;       
  23.         //Choice ch1;       
  24.         JComboBox jcb1;
  25.         JTextArea jta1,jta2;       
  26.         JScrollPane jsp1,jsp2;       
  27.         JButton jb1,jb2,jb3,jb4;       
  28.         JTextField jtf1;       
  29.         ButtonGroup bg1;
  30.         JRadioButton[] jrb1;
  31.        
  32.         JPanel jp1,jp2;
  33.                
  34.         //计时器线程
  35.         Thread t1;
  36.         //计时器开关,暂停开关
  37.         boolean b1,b2;       
  38.         //本次考试时间
  39.         long l1;

  40.         //含有试题和结果信息
  41.         ReadTestQuestion rtq1;
  42.        
  43.         public TestArea() {
  44.                 //使用盒子来布局框架;2个水平盒子和1个垂直盒子
  45.                 bx1=Box.createVerticalBox();
  46.                 bx2=Box.createVerticalBox();
  47.                 bx3=Box.createHorizontalBox();
  48.                
  49.                 jl1=new JLabel("参加考试 提高水平");
  50.                 jl1.setFont(new Font("幼圆",Font.BOLD,18));
  51.                
  52.                 jl2=new JLabel("选择试题文件");
  53.                 jl2.setFont(new Font("幼圆",Font.PLAIN,16));
  54.                 jl3=new JLabel("剩余时间");
  55.                 jl3.setFont(new Font("幼圆",Font.PLAIN,16));
  56.                 jl4=new JLabel("试题显示");
  57.                 jl4.setFont(new Font("幼圆",Font.PLAIN,16));
  58.                
  59.                 //文件读写:
  60.                 //1.文件目录根据System属性;
  61.                 //2.后缀根据实现了文件过滤的FileLastName确定;
  62.                 //3.同目录下的多个文件名由文件类根据后缀动态加载到文件名字符串数组实现;
  63.                 String s1=System.getProperty("user.dir");
  64.                 File f1=new File(s1);
  65.                 FileLastName fln1=new FileLastName("txt");
  66.                 String[] s2=f1.list(fln1);
  67.                
  68.                 //加载到JComboBox
  69.                 jcb1=new JComboBox();
  70.                 jcb1.setFont(new Font("幼圆",Font.PLAIN,16));
  71.                 jcb1.addItem("单击选择试题文件");
  72.                 for(int i=0;i<s2.length;i++) {
  73.                         jcb1.addItem(s2[i]);
  74.                 }
  75.                                
  76.                 //监听jcb1下拉列表的状态变化
  77.                 jcb1.addItemListener(new jcb1ItemListener(this));
  78.                                
  79.                 jta1=new JTextArea(8,4);
  80.                 jta2=new JTextArea(12,6);
  81.                 jta1.setLineWrap(true);
  82.                 jta2.setLineWrap(true);
  83.                 jta1.setWrapStyleWord(true);
  84.                 jta2.setWrapStyleWord(true);
  85.                
  86.                 jsp1=new JScrollPane(jta1);
  87.                 jsp2=new JScrollPane(jta2);               
  88.                
  89.                 jb1=new JButton("查看分数");
  90.                 jb1.setFont(new Font("幼圆",Font.PLAIN,16));
  91.                 jb1.addActionListener(new thisActionListener(this));
  92.                 jb1.setToolTipText("可以看到你的测试结果");
  93.                 jb2=new JButton("暂停或继续计时");
  94.                 jb2.setFont(new Font("幼圆",Font.PLAIN,16));
  95.                 jb2.addActionListener(new thisActionListener(this));
  96.                 jb2.setToolTipText("你可以暂时休息一下");
  97.                 jb3=new JButton("提交答案");
  98.                 jb3.setFont(new Font("幼圆",Font.PLAIN,16));
  99.                 jb3.addActionListener(new thisActionListener(this));
  100.                 jb3.setToolTipText("提交后点击查分按钮");
  101.                 jb4=new JButton("读取首题");
  102.                 jb4.setFont(new Font("幼圆",Font.PLAIN,16));
  103.                 jb4.addActionListener(new thisActionListener(this));
  104.                 jb4.setToolTipText("看看后面的题目");

  105.                
  106.                 jtf1=new JTextField(20);
  107.                 jtf1.setEditable(false);
  108.                
  109.                 bg1=new ButtonGroup();
  110.                 jrb1=new JRadioButton[4];
  111.                 String[] jrb1S={"A","B","C","D"};
  112.                 for(int i=0;i<jrb1S.length;i++) {
  113.                         jrb1[i]=new JRadioButton(jrb1S[i]);               
  114.                         bg1.add(jrb1[i]);               
  115.                 }
  116.                
  117.                 jp1=new JPanel();               
  118.                 jp2=new JPanel();               
  119.                
  120.                 jp1.add(jb1);
  121.                 jp1.add(jb2);

  122.                 bx1.add(jl2);
  123.                 bx1.add(jcb1);
  124.                 bx1.add(jsp1);
  125.                 bx1.add(jp1);               
  126.                 bx1.add(jl3);
  127.                 bx1.add(jtf1);
  128.                
  129.                 for(int i=0;i<jrb1S.length;i++) {                       
  130.                         jp2.add(jrb1[i]);               
  131.                 }
  132.                 jp2.add(jb3);
  133.                 jp2.add(jb4);
  134.                
  135.                 bx2.add(jl4);
  136.                 bx2.add(jsp2);
  137.                 bx2.add(jp2);
  138.        
  139.                 bx3.add(bx1);
  140.                 bx3.add(bx2);
  141.                
  142.                 setLayout(new BorderLayout());
  143.                 add(jl1,BorderLayout.NORTH);
  144.                 add(bx3,BorderLayout.CENTER);
  145.                
  146.                 //计时器初始化,默认为null,即为没有计时器
  147.                 //计时器暂停开关,初始化为关闭
  148.                 b1=false;
  149.                 b2=false;
  150.                 t1=new Thread(this);
  151.                 rtq1=new ReadTestQuestion();
  152.         }
  153.        
  154.         public synchronized void run() {
  155.                 while(true) {
  156.                         if(l1<=0) {
  157.                                 jb3.setEnabled(false);
  158.                                 jb4.setEnabled(true);
  159.                                 b1=true;
  160.                                 t1.interrupt();
  161.                                 jtf1.setText("时间用完 测试结束");
  162.                         }
  163.                         else if(rtq1.getFinsh()) {
  164.                                 b1=true;
  165.                                 jtf1.setText("测试结果:"+rtq1.getSorce()+" 考试剩余时间:"+l1);
  166.                         }
  167.                         else {                               
  168.                                 long TS=l1/1000;                               
  169.                                 long H=TS/3600;TS=TS%3600;                               
  170.                                 long M=TS/60;TS=TS%60;
  171.                                 long S=TS;                               
  172.                                 jtf1.setText("还有 "+H+" 时 "+M+" 分 "+S+" 秒 ");
  173.                                
  174.                                 //时间减少
  175.                                 l1=l1-1000;
  176.                         }
  177.                        
  178.                         try {
  179.                                 Thread.sleep(1000);
  180.                         } catch(InterruptedException ie) {
  181.                                 if (b1==true) {
  182.                                         return ;
  183.                                 }
  184.                         }
  185.                        
  186.                         while(b2==true) {
  187.                                 try {
  188.                                         wait();
  189.                                 } catch(InterruptedException ie) {
  190.                                         if(b2==false) {
  191.                                                 notifyAll();
  192.                                         }
  193.                                 }
  194.                         }
  195.                 }               
  196.         }
  197.        
  198.         class jcb1ItemListener implements ItemListener {
  199.                 TestArea ta1;
  200.                
  201.                 public jcb1ItemListener(TestArea ta1) {
  202.                         this.ta1=ta1;
  203.                 }
  204.                 public void itemStateChanged(ItemEvent ie) {
  205.                         jtf1.setText("");
  206.                         jta1.setText("");
  207.                         jta2.setText("");
  208.                         for(int i=0;i<4;i++) {
  209.                                 jrb1[i].setSelected(false);       
  210.                         }
  211.                         jb3.setEnabled(false);
  212.                         jb4.setEnabled(true);       

  213.                         //获取选择的试题文件
  214.                         String s1=jcb1.getSelectedItem().toString().trim();
  215.                        
  216.                         if(s1.equals("单击选择试题文件")) {
  217.                                 jl1.setText("重新选择");
  218.                                 return ;
  219.                         }
  220.                         else {
  221.                                 jl1.setText("试题 "+s1+" 认真作答 祝福通关");
  222.                                
  223.                                 //设置要读取的文件名根据选择了的文件名
  224.                                 rtq1.setFilename(s1);
  225.                                 //初始化尚未完成考试
  226.                                 rtq1.setFinsh(false);
  227.                                 //获取本次考试的时间,根据试题文件的规定
  228.                                 l1=rtq1.getTestTime();
  229.                                
  230.                                 //关闭已经开启的计时器,同时把计时器置为中断状态
  231.                                 if(t1.isAlive()) {
  232.                                         t1.interrupt();
  233.                                         b1=true;
  234.                                 }
  235.                                
  236.                                 //实例化计时器线程
  237.                                 t1=new Thread(ta1);                                               
  238.                         }                       
  239.                 }
  240.         }
  241.        
  242.         class thisActionListener implements ActionListener {
  243.                 TestArea ta1;
  244.                 public thisActionListener(TestArea ta1) {
  245.                         this.ta1=ta1;
  246.                 }
  247.                 public void actionPerformed(ActionEvent ae) {
  248.                        
  249.                         //读取试题
  250.                         if(ae.getSource()==jb4) {
  251.                                 String s1=rtq1.getTestContent();
  252.                                 for(int i=0;i<4;i++) {
  253.                                         jrb1[i].setSelected(false);       
  254.                                 }       

  255.                                 try {
  256.                                         t1.start();
  257.                                 }catch(Exception e) {
  258.                                 }
  259.                                
  260.                                 jta1.setText("");
  261.                                 jta2.setText(s1);
  262.                                 jb3.setEnabled(true);
  263.                                 jb4.setEnabled(false);
  264.                         }

  265.                         //查看分数
  266.                         if(ae.getSource()==jb1) {
  267.                                 int i1=rtq1.getSorce();
  268.                                 String s1=rtq1.getMessage();
  269.                                 jta1.setText("你的测试得分:"+i1+"\n\n测试情况:\n"+s1);
  270.                         }
  271.                        
  272.                         //暂停或继续计时
  273.                         if(ae.getSource()==jb2) {
  274.                                 if(b2==false) {
  275.                                         b2=true;
  276.                                         jb2.setText("继续计时");                                       
  277.                                         //t1.interrupt();                                                                                                                                       
  278.                                 }
  279.                                 else {                                       
  280.                                         jb2.setText("暂停计时");
  281.                                         //if (b2==true){                                               
  282.                                         //                t1.notifyAll();                                                                                       
  283.                                         //}
  284.                                         b2=false;
  285.                                         t1.interrupt();
  286.                                 }
  287.                         }
  288.                        
  289.                         //提交答案
  290.                         if(ae.getSource()==jb3) {
  291.                                 jb3.setEnabled(false);
  292.                                 jb4.setEnabled(true);
  293.                                
  294.                                 String s1="?";
  295.                                 for(int i=0;i<4;i++) {
  296.                                         if(jrb1[i].isSelected()) {
  297.                                                 s1=jrb1[i].getText();
  298.                                                 break;
  299.                                         }
  300.                                 }
  301.                                 jb4.setText("读取下题");
  302.                                 rtq1.setSelect(s1);                       
  303.                         }
  304.                 }
  305.         }
  306. }

  307. //文件后缀过滤
  308. class FileLastName implements FilenameFilter {
  309.         String s1;
  310.         public FileLastName(String s1) {
  311.                 this.s1="."+s1;
  312.         }
  313.         //这里f1是目录;s2是文件名
  314.         public boolean accept(File f1,String s2) {
  315.                 return s2.endsWith(s1);
  316.         }
  317. }

复制代码


采用局部变量来控制线程的运行和退出
b1,b2默认是false:关闭计时器,暂停开关没有打开

run()中时间用尽时,中断线程cT.interrupt(),结束run();
如果还有时间time>;=1,每次while减少1000毫秒,同时捕获休眠异常,检查b1,b2(计时器关闭时退出;暂停打开时,等待唤醒,捕获等待异常);
这里的b2 来自TextArea对象中的局部变量

论坛徽章:
0
7 [报告]
发表于 2004-12-02 18:28 |只看该作者

请教:线程监视器状态异常

核心思想就是通过于线程的交互(修改标志变量),而不是硬性停止对线程的调度来停止线程运行。

论坛徽章:
0
8 [报告]
发表于 2004-12-03 01:13 |只看该作者

请教:线程监视器状态异常

就这个例子中要实现的功能:
一个计时器开关,一个暂停开关;
计时开关开启计时器;
暂停开关中断和恢复计时器计时。

请求  给出线程标志变量代码,当然相关提示也可以,谢谢。

论坛徽章:
0
9 [报告]
发表于 2004-12-03 08:28 |只看该作者

请教:线程监视器状态异常

没有什么特殊的变量了。就是你的程序里的做法就比较常见了。我只是看程序太长,就总结了一句
您需要登录后才可以回帖 登录 | 注册

本版积分规则 发表回复

  

北京盛拓优讯信息技术有限公司. 版权所有 京ICP备16024965号-6 北京市公安局海淀分局网监中心备案编号:11010802020122 niuxiaotong@pcpop.com 17352615567
未成年举报专区
中国互联网协会会员  联系我们:huangweiwei@itpub.net
感谢所有关心和支持过ChinaUnix的朋友们 转载本站内容请注明原作者名及出处

清除 Cookies - ChinaUnix - Archiver - WAP - TOP