当前位置:天才代写 > tutorial > JAVA 教程 > Java如何共享资源

Java如何共享资源

2017-11-13 08:00 星期一 所属: JAVA 教程 浏览:479

对一种非凡的资源——工具中的内存——Java提供了内建的机制来防备它们的斗嘴。由于我们凡是将数据元素设为从属于private(私有)类,然后只通过要了解见那些内存,所以只需将一个特定的要领设为synchronized(同步的),便可有效地防备斗嘴。在任何时刻,只可有一个线程挪用特定工具的一个synchronized要领(尽量谁人线程可以挪用多个工具的同步要领)。下面列出简朴的synchronized要领:
synchronized void f() { /* … */ }
synchronized void g() { /* … */ }
每个工具都包括了一把锁(也叫作“监督器”),它自动成为工具的一部门(不必为此写任何非凡的代码)。挪用任何synchronized要领时,工具就会被锁定,不行再挪用谁人工具的其他任何synchronized要领,除非第一个要领完成了本身的事情,并清除锁定。在上面的例子中,假如为一个工具挪用f(),便不能再为同样的工具挪用g(),除非f()完成并清除锁定。因此,一个特定工具的所有synchronized要领都共享着一把锁,并且这把锁能防备多个要领对通用内存同时举办写操纵(好比同时有多个线程)。
每个类也有本身的一把锁(作为类的Class工具的一部门),所以synchronized static要领可在一个类的范畴内被彼此间锁定起来,防备与static数据的打仗。
留意假如想掩护其他某些资源不被多个线程同时会见,可以强制通过synchronized方会见那些资源。

1. 计数器的同步
装备了这个新要害字后,我们可以或许采纳的方案就更机动了:可以只为TwoCounter中的要领简朴地利用synchronized要害字。下面这个例子是对前例的改版,个中插手了新的要害字:
 

//: Sharing2.java
// Using the synchronized keyword to prevent
// multiple access to a particular resource.
import java.awt.*;
import java.awt.event.*;
import java.applet.*;

class TwoCounter2 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;
  public TwoCounter2(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 synchronized void run() {
    while (true) {
      t1.setText(Integer.toString(count1++));
      t2.setText(Integer.toString(count2++));
      try {
        sleep(500);
      } catch (InterruptedException e){}
    }
  }
  public synchronized void synchTest() {
    Sharing2.incrementAccess();
    if(count1 != count2)
      l.setText("Unsynched");
  }
}

class Watcher2 extends Thread {
  private Sharing2 p;
  public Watcher2(Sharing2 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 Sharing2 extends Applet {
  TwoCounter2[] 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 TwoCounter2[numCounters];
    for(int i = 0; i < s.length; i++)
      s[i] = new TwoCounter2(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 Watcher2(Sharing2.this);
    }
  }
  public static void main(String[] args) {
    Sharing2 applet = new Sharing2();
    // 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("Sharing2");
    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);
  }
} ///:~

#p#分页标题#e#

我们留意到无论run()照旧synchTest()都是“同步的”。假如只同步个中的一个要领,那么另一个就可以自由忽视工具的锁定,并可无碍地挪用。所以必需记着一个重要的法则:对付会见某个要害共享资源的所有要领,都必需把它们设为synchronized,不然就不能正常地事情。
此刻又碰着了一个新问题。Watcher2永远都不能看到正在举办的工作,因为整个run()要领已设为“同步”。并且由于必定要为每个工具运行run(),所以锁永远不能打开,而synchTest()永远不会获得挪用。之所以能看到这一功效,是因为accessCount基础没有变革。
为办理这个问题,我们能采纳的一个步伐是只将run()中的一部门代码断绝出来。想用这个步伐断绝出来的那部门代码叫作“要害区域”,并且要用差异的方法来利用synchronized要害字,以配置一个要害区域。Java通过“同步块”提供对要害区域的支持;这一次,我们用synchronized要害字指出工具的锁用于对个中关闭的代码举办同步。如下所示:
 

synchronized(syncObject) {
  // This code can be accessed by only
  // one thread at a time, assuming all
  // threads respect syncObject's lock
}

在能进入同步块之前,必需在synchObject上取得锁。假如已有其他线程取得了这把锁,块便不能进入,必需等待那把锁被释放。
可从整个run()中删除synchronized要害字,换成用一个同步块困绕两个要害行,从而完成对Sharing2例子的修改。但什么工具应作为锁来利用呢?谁人工具已由synchTest()标志出来了——也就是当前工具(this)!所以修悔改的run()要领象下面这个样子:
 

  public void run() {
    while (true) {
      synchronized(this) {
        t1.setText(Integer.toString(count1++));
        t2.setText(Integer.toString(count2++));
      }
      try {
        sleep(500);
      } catch (InterruptedException e){}
    }
  }

这是必需对Sharing2.java作出的独一修改,我们会看到尽量两个计数器永远不会离开同步(取决于答允Watcher什么时候查抄它们),但在run()执行期间,仍然向Watcher提供了足够的会见权限。
虽然,所有同步都取决于措施员是否勤奋:要会见共享资源的每一部门代码都必需封装到一个适当的同步块里。

2. 同步的效率
由于要为同样的数据编写两个要领,所以无论如何都不会给人留下效率很高的印象。看来好像更好的一种做法是将所有要领都设为自动同步,并完全消除synchronized要害字(虽然,含有synchronized run()的例子显示出这样做是很不通的)。但它也展现出获取一把锁并非一种“便宜”方案——为一次要领挪用支付的价钱(进入和退出要领,不执行要领主体)至少要累加到四倍,并且按照我们的具浮现方案,这一价钱尚有大概变得更高。所以如果已知一个要领不会造成斗嘴,最明智的做法即是除掉个中的synchronized要害字。

 

    关键字:

[contact-form-7 id="17097" title="form2"]天才代写-代写联系方式