当前位置:七道奇文章资讯编程技术Java编程
日期:2011-03-22 16:16:00  来源:本站整理

java资源访谒的错误办法[Java编程]

赞助商链接



  本文“java资源访谒的错误办法[Java编程]”是由七道奇为您精心收集,来源于网络转载,文章版权归文章作者所有,本站不对其观点以及内容做任何评价,请读者自行判断,以下是其具体内容:
目前考虑换成另一种方法来利用本章频繁见到的计数器.在下面的例子中,每个线程都包含了两个计数器,它们在run()里增值以及显示.除此以外,我们利用了Watcher类的另一个线程.它的作用是监督计数器,查抄它们能否保持相等.这表面是一项无意义的行动,因为假如查看代码,就会发现计数器必定是相同的.但实际情形却不一定如此.下面是程序的第一个版本:
//: Sharing1.java
// Problems with resource sharing while threading
import java.awt.*;
import java.awt.event.*;
import java.applet.*;

class TwoCounter extends Thread {
  private boolean started = false;
  private TextField 
    t1 = new TextField(5),
    t2 = new TextField(5);
  private Label l = 
    new Label("count1 == count2");
  private int count1 = 0, count2 = 0;
  // Add the display components as a panel
  // to the given container:
  public TwoCounter(Container c) {
    Panel p = new Panel();
    p.add(t1);
    p.add(t2);
    p.add(l);
    c.add(p);
  }
  public void start() {
    if(!started) {
      started = true;
      super.start();
    }
  }
  public void run() {
    while (true) {
      t1.setText(Integer.toString(count1++));
      t2.setText(Integer.toString(count2++));
      try {
        sleep(500);
      } catch (InterruptedException e){}
    }
  }
  public void synchTest() {
    Sharing1.incrementAccess();
    if(count1 != count2)
      l.setText("Unsynched");
  }
}

class Watcher extends Thread {
  private Sharing1 p;
  public Watcher(Sharing1 p) { 
    this.p = p;
    start();
  }
  public void run() {
    while(true) {
      for(int i = 0; i < p.s.length; i++)
        p.s[i].synchTest();
      try {
        sleep(500);
      } catch (InterruptedException e){}
    }
  }
}

public class Sharing1 extends Applet {
  TwoCounter[] s;
  private static int accessCount = 0;
  private static TextField aCount = 
    new TextField("0", 10);
  public static void incrementAccess() {
    accessCount++;
    aCount.setText(Integer.toString(accessCount));
  }
  private Button 
    start = new Button("Start"),
    observer = new Button("Observe");
  private boolean isApplet = true;
  private int numCounters = 0;
  private int numObservers = 0;
  public void init() {
    if(isApplet) {
      numCounters = 
        Integer.parseInt(getParameter("size"));
      numObservers = 
        Integer.parseInt(
          getParameter("observers"));
    }
    s = new TwoCounter[numCounters];
    for(int i = 0; i < s.length; i++)
      s[i] = new TwoCounter(this);
    Panel p = new Panel();
    start.addActionListener(new StartL());
    p.add(start);
    observer.addActionListener(new ObserverL());
    p.add(observer);
    p.add(new Label("Access Count"));
    p.add(aCount);
    add(p);
  }
  class StartL implements ActionListener {
    public void actionPerformed(ActionEvent e) {
      for(int i = 0; i < s.length; i++)
        s[i].start();
    }
  }
  class ObserverL implements ActionListener {
    public void actionPerformed(ActionEvent e) {
      for(int i = 0; i < numObservers; i++)
        new Watcher(Sharing1.this);
    }
  }
  public static void main(String[] args) {
    Sharing1 applet = new Sharing1();
    // This isn't an applet, so set the flag and
    // produce the parameter values from args:
    applet.isApplet = false;
    applet.numCounters = 
      (args.length == 0 ? 5 :
        Integer.parseInt(args[0]));
    applet.numObservers =
      (args.length < 2 ? 5 :
        Integer.parseInt(args[1]));
    Frame aFrame = new Frame("Sharing1");
    aFrame.addWindowListener(
      new WindowAdapter() {
        public void windowClosing(WindowEvent e){
          System.exit(0);
        }
      });
    aFrame.add(applet, BorderLayout.CENTER);
    aFrame.setSize(350, applet.numCounters *100);
    applet.init();
    applet.start();
    aFrame.setVisible(true);
  }
} ///:~

和平常一样,每个计数器都包含了自己的显示组件:两个文本字段以及一个标签.按照它们的初始值,可知道计数是相同的.这些组件在TwoCounter构建器加入Container.由于这个线程是通过用户的一个“按下按钮”操作启动的,所以start()大概被多次调用.但对一个线程来说,对Thread.start()的多次调用是不法的(会产生违例).在started标志和过载的start()办法中,大家可看到针对这一情形采纳的防备办法.
在run()中,count1和count2的增值与显示方法表面上仿佛能保持它们完好一致.随后会调用sleep();若没有这个调用,程序便会出错,因为那会造成CPU难于交换任务.
synchTest()办法采纳的仿佛是没有意义的行动,它查抄count1能否等于count2;假如不等,就把标签设为“Unsynched”(差别步).但是首先,它调用的是类Sharing1的一个静态成员,以便增值和显示一个拜候计数器,指出这种查抄已成功举行了多少次(这样做的来由会在本例的其他版本中变得十清楚显).
Watcher类是一个线程,它的作用是为处于活动状况的全部TwoCounter对象都调用synchTest().其间,它会对Sharing1对象中包容的数组举行遍历.可将Watcher想象成它擦过TwoCounter对象的肩膀不断地“偷看”.
Sharing1包含了TwoCounter对象的一个数组,它通过init()举行初始化,并在我们按下“start”按钮后作为线程启动.今后若按下“Observe”(察看)按钮,就会成立一个大概多个察看器,并对毫不设防的TwoCounter举行调查.
注意为了让它作为一个程序片在浏览器中运行,Web页需求包含下面这几行:
<applet code=Sharing1 width=650 height=500>
<param name=size value="20">
<param name=observers value="1">
</applet>

可自行改变宽度、高度以及参数,按照自己的志愿举行试验.若改变了size和observers,程序的行为也会发生改变.我们也注意到,通过从号令行承受参数(大概利用默许值),它被计划成作为一个独立的利用程序运行.
下面才是最让人“难以想象”的.在TwoCounter.run()中,无限循环只是不断地反复相邻的行:
t1.setText(Integer.toString(count1++));
t2.setText(Integer.toString(count2++));
(和“就寝”一样,不过在这里并不重要).但在程序运行的时刻,你会发现count1和count2被“察看”(用Watcher察看)的次数是不相等的!这是由线程的本质造成的——它们可在任什么时刻候挂起(暂停).所以在上述两行的履行时刻之间,有时会呈现履行暂停现象.同时,Watcher线程也恰好跟随着进来,并恰好在这个时刻举行对比,造成计数器呈现不相等的情形.
本例揭露了利用线程时一个非常基本的问题.我们跟无从知道一个线程什么时刻运行.想象自己坐在一张桌子前面,桌上放有一把叉子,预备叉起自己的最后一块食物.当叉子要碰到食物时,食物却忽然消逝了(因为这个线程已被挂起,同时另一个线程进来“偷”走了食物).这就是我们要办理的问题.
有的时刻,我们并不介意一个资源在尝试利用它的时刻能否正被拜候(食物在另一些盘子里).但为了让多线程机制可以正常运转,需求采纳一些办法来避免两个线程拜候相同的资源——至少在关键的期间.
为避免呈现这样的冲突,只需在线程利用一个资源时为其加锁便可.拜候资源的第一个线程会其加上锁今后,其他线程便不能再利用那个资源,除非被解锁.假如车子的前座是有限的资源,高喊“这是我的!”的孩子会主张把它锁起来.
  以上是“java资源访谒的错误办法[Java编程]”的内容,如果你对以上该文章内容感兴趣,你可以看看七道奇为您推荐以下文章:
  • 利用Javascript实现网页水印(非图片水印)
  • Java开辟环境的搭建
  • Ubuntu java安装与配置
  • 办理Ubuntu 10.04 Firefox3.6 Java浏览器插件不工作的问
  • Ubuntu重装后Java环境的设置
  • Sun Java进入Ubuntu 10.10软件中央
  • Ubuntu 10.10配置Java开辟环境
  • 在Ubuntu 10.10中配置Java环境变量的办法
  • Ubuntu下Java环境的搭建
  • Ubuntu 10.04 下安装 Java, JRE
  • Ubuntu 10.04下的搭建SUN JAVA开辟环境
  • Ubuntu 12.04安装java7
  • 本文地址: 与您的QQ/BBS好友分享!
    • 好的评价 如果您觉得此文章好,就请您
        0%(0)
    • 差的评价 如果您觉得此文章差,就请您
        0%(0)

    文章评论评论内容只代表网友观点,与本站立场无关!

       评论摘要(共 0 条,得分 0 分,平均 0 分) 查看完整评论
    Copyright © 2020-2022 www.xiamiku.com. All Rights Reserved .