亚洲综合色视频在线观看,中文字幕在线亚洲精品,亚洲AV无码国产精品色

Mon, 25 Feb 2008 14:40:00 GMT

摘要: 工序��d��指流水线式的工作场景�Q�下一�l�工人的工�g��是上一�l�工人的成品�Q�一个活做完自己的部分就往下传�Q�直到活完成为止�? ��Z��~�程方便��化了各个工序的工�Ӟ��把它们都当成一��L(f��ng)��了�? 代码�Q?package com.sitinspring.autotask.domain; import com.sitinspring.autotask.util.IdUtil; ... 阅读全文

junglesong的博�?/a> 2008-02-25 22:40 发表评论

��d��锁的使用

Fri, 22 Feb 2008 06:28:00 GMT

本文内容

何时该��用读写锁.
��d��锁的写法.
理解��d��锁和�U�程互斥的区别�?/p>

复习(f��n)-同步化的概念

当一个方法或代码块被声明成synchronized�Q�要执行此代码必��d��取得一个对象实例或this的锁定，�q�个锁定要在synchronized修饰的方法或代码块执行完后才能释放掉�Q�无��D�代码是怎样�q�回的，是正常运行还是异常运行）。每个对象只有一个锁定，如果有两个不同的�U�程试图同时调用同一对象的同步方法，最�l�只会有一个能�q�行此方法，另外一个要�{�待�W�一个线�E�释放掉锁定后才能运行此�Ҏ(gu��)��?/p>

��d��锁应用的场合

我们有时会遇到对同一个内存区域如数组或者链表进行多�U�程��d��的情�?一般来说有以下几种处理方式: 1.不加��M��限制,多见于读取写入都很快的情�?但有时也会出现问�? 2.对读写函数都加以同步互斥,�q�下问题是没�?但效率也下去�?比如说两个读取线�E�不是非要排队进入不�? 3.使用��d��?安全和效率都得到了解�?特别合适读�U�程多于写线�E�的情况.也就是下面将要展现的模式.

��d��锁的意图

��d��锁的本意是分别对��d��状态进行互斥区�?有互斥时才加�?否则放行.互斥的情冉|��: 1.��d��互斥. 2.写写互斥. 不互斥的情况�?读读,�q�种情况不该加以限制. �E�序��是要让锁对象知道当前读写状�?再根据情况对��d��的线�E�进行锁定和解锁�?/p>

��d��U�程都要操作的数据类

��d��U�程都要操作的数据是链表datas�?br /> 注意其中try...finally 的写�?它保证了加锁解锁�q�程是成对调用的

lpublic class DataLib {
     private List datas;

     private ReadWriteLock lock;

     public DataLib() {
         datas = new ArrayList();
         lock = new ReadWriteLock();
     }

     // 写入数据,�q�时不能��d��
     public void writeData(List newDatas) {
         try {
             lock.writeLock();
             Test.sleep(2);
             datas=newDatas;
         } finally {
             lock.writeUnlock();
         }
     }

     // ��d��数据,�q�时不能写入
     public List readData() {
         try {
             lock.readLock();
             Test.sleep(1);
             return datas;
         } finally {
             lock.readUnlock();
         }

     }

}

��d��锁ReadWriteLock�c?

public class ReadWriteLock{
    // �ȝ��?br />     private boolean isRead;

    // 写状�?br />     private boolean isWrite;

    public synchronized void readLock(){
        // 有写入时��d��U�程停止
        while(isWrite){
            try{
                System.out.println("有线�E�在�q�行写入,��d��U�程停止,�q�入�{�待状�?);
                wait();
            }
            catch(InterruptedException ex){
                ex.printStackTrace();
            }
        }

        System.out.println("讑֮�锁�ؓ��d��状�?);
        isRead=true;
    }

    public synchronized void readUnlock(){
        System.out.println("解除��d��?);
        isRead=false;
        notifyAll();
    }

     public synchronized void writeLock(){
        // 有读取时��d��U�程停止
        while(isRead){
            try{
                System.out.println("有线�E�在�q�行��d��,写入�U�程停止,�q�入�{�待状�?);
                wait();
            }
            catch(InterruptedException ex){
                ex.printStackTrace();
            }
        }

        // 有写入时写入�U�程也一栯��停止
        while(isWrite){
            try{
                System.out.println("有线�E�在�q�行写入,写入�U�程停止,�q�入�{�待状�?);
                wait();
            }
            catch(InterruptedException ex){
                ex.printStackTrace();
            }
        }

        System.out.println("讑֮�锁�ؓ写入状�?);
        isWrite=true;
    }

    public synchronized void writeUnlock(){
        System.out.println("解除写入�?);
        isWrite=false;
        notifyAll();
    }
}

写线�E�类Writer -它用于往DataLib�c�d��例中的datas字段写数�?/p>

分析其中dataLib字段的用意�?br /> 注意�q�记住其中持�l�调用及使用随机数的�Ҏ(gu��)��?/p>

lpublic class Writer implements Runnable{
     private DataLib dataLib;
     private static final Random random=new Random();
     private String[] mockDatas={"�?/span>","�?/span>","�?/span>","�?/span>","�?/span>","�?/span>","�?/span>","�?/span>","�?/span>","�?/span>"};

     public Writer(DataLib dataLib,String[] mockDatas){
         this.dataLib=dataLib;
         this.mockDatas=mockDatas;

         Thread thread=new Thread(this);
         thread.start();
     }

     public void run(){
         while(true){
             Test.sleep(random.nextInt(3));

             int startIndex=random.nextInt(mockDatas.length);

             ArrayList newDatas=new ArrayList();
             for(int i=startIndex;i                  newDatas.add(mockDatas[i]);
             }

             dataLib.writeData(newDatas);
         }
     }
}

�ȝ��E�类Reader -它用于从DataLib�c�d��例中的datas字段��d��数据

分析其中dataLib字段的用意�?br /> 注意�q�记住其中持�l�调用及使用随机数的�Ҏ(gu��)��?/p>

public class Reader implements Runnable{
    private DataLib dataLib;
    private static final Random random=new Random();

    public Reader(DataLib dataLib){
        this.dataLib=dataLib;

        Thread thread=new Thread(this);
        thread.start();
    }

    public void run(){
        while(true){
            Test.sleep(random.nextInt(2));
            List datas=dataLib.readData();

            System.out.print(">>取得数组�?");
            for(String data:datas){
                System.out.print(data+",");
            }
            System.out.print("\n");
        }
    }
}

��代码运行�v�?/p>

双��的代码创��Z��两个写线�E�和三个�ȝ��E�，它们都是对dataLib实例�q�行操作的�?br /> 五个�U�程都有一个dataLib字段�Q�都提供了一个带参构造函��C��l�datas字段赋��|��q�就保证了五个线�E�操作的都是一个实例的同一字段�Q�也��是同一片内存�?br /> ��d��锁就是对�q�五个线�E�进行控制的�?br /> 当有一个读�U�程在操作时�Q�其它的写线�E�无法进行操作，�ȝ��E�可以正常操作，互不�q�扰�?br /> 当有一个写�U�程在操作时�Q�其它的�ȝ��E�无法进行操作�?/p>

public class Test{
     public static void main(String[] args){
         DataLib dataLib=new DataLib();

         String[] mockDatas1={"�?/span>","�?/span>","�?/span>","�?/span>","�?/span>","�?/span>","�?/span>","�?/span>","�?/span>","�?/span>"};
         Writer writer1=new Writer(dataLib,mockDatas1);

         String[] mockDatas2={"�?/span>","�?/span>","�?/span>","�?/span>","�?/span>","�?/span>","�?/span>","�?/span>","�?/span>","�?/span>","�?/span>","�?/span>"};
         Writer writer2=new Writer(dataLib,mockDatas2);

         Reader reader1=new Reader(dataLib);
         Reader reader2=new Reader(dataLib);
         Reader reader3=new Reader(dataLib);
     }


     // 用于延时
     public static void sleep(int sleepSecond){
         try{
             Thread.sleep(sleepSecond*1000);
         }
         catch(Exception ex){
             ex.printStackTrace();
         }
     }
}

��结

当多个线�E�试囑֯�同一内容�q�行��d��操作旉��合使用��d��锁�?br /> ��L(f��ng)��解�ƈ��C��ReadWriteLock�c�读写锁的写�?
��d��锁相对于�U�程互斥的优势在于高效，它不会对两个�ȝ��E�进行盲目的互斥处理�Q�当�ȝ��E�数量多于写�U�程��其如此�Q�当全是写线�E�时两者等效�?/p>

junglesong的博�?/a> 2008-02-22 14:28 发表评论

�U�程锁的使用

Fri, 22 Feb 2008 06:20:00 GMT

本文内容

何时该��用线�E�锁.
�U�程锁的写法.
以线�E�锁的例子来理解�U�程的调度�?/p>

使用�U�程锁的场合

�E�序中经帔R��用多�U�程处理�Q�这可以充分利用�pȝ��资源�Q�羃短程序响应时��_��改善用户体验�Q�如果程序中只��用单�U�程�Q�那么程序的速度和响应无疑会大打折扣�?br /> 但是�Q�程序采用了多线�E�后�Q�你��必��认真考虑�U�程调度的问题，如果调度不当�Q�要么造成�E�序出错�Q�要么造成荒谬的结果�?/p>

一个讽刺僵化体制的�W�话

前苏联某官员去视察植�?w��i)造林的情况，现场他看��C��个�h在远处挖坑，其后不远另一个�h在把刚挖出的坑逐个填上�Q�官员很费解于是询问陪同人员�Q�当地管理�h员说“负责�U�树(w��i)的�h今天病了”�?br /> 上面�q�个�W�话如果发生在程序中��是�U�程调度的问题，�U�树(w��i)�q�个��d��有三个线�E�：挖坑�U�程�Q�种�?w��i)线�E�和填坑�U�程�Q�后面的�U�程必须�{�前一个线�E�完成才能进行，而不是按旉��序来进行，否则一旦一个线�E�出错就会出��C��面荒谬的�l�果�?/p>

用线�E�锁来处理两个线�E�先后执行的情况

在程序中�Q�和�U�树(w��i)一��P��很多��d��也必��M��定的先后秩序执行，对于两个�U�程必须以先后秩序执行的情况�Q�我们可以用�U�程锁来处理�?br /> �U�程锁的大致思想是：如果�U�程A和线�E�B会执行实例的两个函数a和b�Q�如果A必须在B之前�q�行�Q�那么可以在B�q�入b函数时让B�q�入wait set�Q�直到A执行完a函数再把B从wait set中激�z�R��这样就保证了B必定在A之后�q�行�Q�无论在之前它们的时间先后顺序是怎样的�?/p>

�U�程锁的代码

如右�Q�SwingComponentLock的实例就是一个线�E�锁�Q�lock函数用于锁定�U�程�Q�当完成状态isCompleted为false时进入的�U�程会进入SwingComponentLock的实例的wait set�Q�已完成则不会；要激�z�SwingComponentLock的实例的wait set中等待的�U�程需要执行unlock函数�?/p>

public class SwingComponentLock {
// 是否初始化完�?br /> boolean isCompleted = false;

/**
   * 锁定�U�程
   */
public synchronized void lock() {
    while (!isCompleted) {
      try {
        wait();
      } catch (Exception e) {
        e.printStackTrace();
        logger.error(e.getMessage());
      }
    }
}

/**
   * 解锁�U�程
   *
   */
public synchronized void unlock() {
    isCompleted = true;
    notifyAll();
}
}

�U�程锁的使用

public class TreeViewPanel extends BasePanel {
// 表空间和表树(w��i)
private JTree tree;

// �q�个是防�?w��i)还未初始化好就被刷新用�?br /> private SwingComponentLock treeLock;

protected void setupComponents() {
// 初始化锁
treeLock = new SwingComponentLock();

// 创徏根节�?br /> DefaultMutableTreeNode root = new DefaultMutableTreeNode("DB");
tree = new JTree(root);

    // 讄��布局�q�装入树(w��i)
    setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
    add(new JScrollPane(tree));

// 讄��?w��i)节点的图�?br /> setupTreeNodeIcons();

// 解除�Ҏ(gu��)��(w��i)的锁�?br /> treeLock.unlock();
}

/**
   * ��h��?w��i)视�?br />    *
   * @param schemas
   */
public synchronized void refreshTree(List schemas) {
    treeLock.lock();

DefaultTreeModel model = (DefaultTreeModel) tree.getModel();

DefaultMutableTreeNode root = (DefaultMutableTreeNode) model.getRoot();
root.removeAllChildren();

    for (SchemaTable schemaTable : schemas) {
      DefaultMutableTreeNode schemaNode = new DefaultMutableTreeNode(
          schemaTable.getSchema());

      for (String table : schemaTable.getTables()) {
        schemaNode.add(new DefaultMutableTreeNode(table));
      }

root.add(schemaNode);
}

model.reload();
}

讲解

上页中，setupComponents函数是Swing�ȝ��E�执行的�Q�而refreshTree函数是另外的�U�程执行�Q�初始化时程序开辟一个线�E�执行，其后执行��q��h��作决定）�?refreshTree函数必须要等setupComponents函数把tree初始化完毕后才能执行�Q�而tree初始化的旉��较长�Q�可能在初始化的�q�程中执行refreshTree的线�E�就�q�入了，�q�就会造成问题�?br /> �E�序使用了一个SwingComponentLock来解册��个问题，setupComponents一开始就创徏SwingComponentLock的实例treeLock�Q�然后执行refreshTree的线�E�以来就会进入treeLock的wait set�Q�变成等待状态，不会往下执行，�q�是不管tree是否初始化完毕都不会出错�Q�而setupComponents执行到底部会�Ȁ�z�treeLock的wait set中等待的�U�程�Q�这时再执行refreshTree剩下的代码就不会有�Q何问题，因�ؓsetupComponents执行完毕tree已经初始化好了�?br /> 让线�E�等待和�Ȁ�zȝ��E�的代码都在SwingComponentLock�c�M��Q�这��L(f��ng)��装对复用很有好处，如果其它复杂�l��g如table也要依此办理直接创徏SwingComponentLock�cȝ��实例��可以了。如果把wait和notifyAll写在TreeViewPanel�c�M��׃��会这��h��便了�?/p>

�ȝ��

�U�程锁用于必��M��固定��序执行的多个线�E�的调度�?br /> �U�程锁的思想是先锁定后序�U�程�Q�然后让�U�序�U�程完成��d��再接触对后序�U�程的锁定�?br /> �U�程锁的写法和��用一定要理解记忆下来�?/p>

junglesong的博�?/a> 2008-02-22 14:20 发表评论

�U�程调度实例

Fri, 22 Feb 2008 06:17:00 GMT

本文内容

本文��从一个现实例子来实际说明�U�程调度�Ҏ(gu��)��wait�Q�notify和notifyAll的��用�?/p>

工厂中�Q务的领受和执�?/strong>

某工厂执行这��L(f��ng)��机制�Q�当生��d��下达到�R间时会统一攑֜�一个地方，由工��Z��来取�z�R�?br /> 工�h取活如此执行�Q�一个工人手头只能有一个活�Q�如果没做完不能做下一个，如果做完了则可以到公��q��地方��d��一个；如果没有�z�d��取则闲着直到来活为止�?/p>
本文��是讲述怎样使用�U�程的调度三�Ҏ(gu��)��wait�Q�notify和notifyAll来实现这一现实�z�d��的�?/p>
��d��c�Task-它用来实��C��?#8221;�z?#8221;,其中关键的成员是完成需消耗的工时数manHour和已�l�完成的工时数completed

public class Task implements Comparable {
private String id;

private String name;

// 完成需消耗的工时�?br /> private int manHour;

// 已经完成的工时数
private int completed;

// 优先�U?br /> private int priority;

// 接受��d��?br /> private Worker worker;

public Task(String name, int manHour) {
    this(name, manHour, 0);
}

public Task(String name, int manHour, int priority) {
    id = IdUtil.generateId();
    this.name = name;
    this.manHour = manHour;
    this.priority = priority;
    this.completed = 0;
}
// ��d��是否完成
public boolean isCompleted() {
    return completed >= manHour;
}

// ��d��完成�?br /> public void addCompleted(int n) {
    completed += n;

    if (isCompleted()) {
      completed = manHour;

      if (worker != null) {
        System.out.println("��d��"+this+"处理完毕!");
      }
    }
}

public int compareTo(Object obj) {
    Task another = (Task) obj;
    return (another.priority) - this.priority;
}

public String toString() {
    return "��d��?" + name + " 工�h�?" + worker.getName() + " 完成�?" + completed
        * 100 / manHour + "%";
}

public String getCompletedRatio() {
    return " 完成�?" + completed * 100 / manHour + "%";
}
...getter/setter�Ҏ(gu��)��省略..

}

��d��库类TaskLibrary

�q�个�c�d��应现实中的取�zȝ��地方,每个�z�Task攑֜��q�个�cȝ��成员tasks�?有两个方法来��d��单个��d��和多个�Q�?�q�有一个fetchTask�Ҏ(gu��)��来供工�h领受��d��.

public class TaskLibrary {
private List tasks;

public TaskLibrary() {
    tasks = new LinkedList();
}

// ��d��单个��d��
public synchronized void addTask(Task task) {
    tasks.add(task);
    notifyAll();
}

// ��d��多个��d��
public synchronized void addTasks(List moreTasks) {
    tasks.addAll(moreTasks);
    notifyAll();
}

public int getTaskSize() {
    return tasks.size();
}

// 工�h领受��d��
public synchronized Task fetchTask(Worker worker) {
    while (tasks.size() == 0) {
      try {
        System.out.println("��d��告罄");
        System.out.println("工�h:" + worker.getName() + "�q�入闲置状�?);
        wait();
      } catch (InterruptedException ex1) {
        ex1.printStackTrace();
      }
    }

    Task task = tasks.get(0);
    System.out.println("工�h:" + worker.getName() + "取得��d��:" + task.getName());
    tasks.remove(task);
    return task;
}
}

工�h�c�Worker

public class Worker implements Runnable {
private String id;

private String name;

private Task currTask;

private TaskLibrary taskLibrary;

// 工作速度
private int speed;

public Worker(String name, int speed, TaskLibrary taskLibrary) {
    id = IdUtil.generateId();
    this.currTask = null;
    this.name = name;
    this.speed = speed;
    this.taskLibrary = taskLibrary;

    doWork();
}

// 开始干�z?br /> public void doWork() {
    Thread thread = new Thread(this);
    thread.start();
}
// 真正�q�活
public void run() {
    while (true) {
      if (currTask == null || currTask.isCompleted()) {
        currTask = taskLibrary.fetchTask(this);
        currTask.setWorker(this);
      }

      try {
        Thread.sleep(1000);
        System.out.println("正在处理的�Q�? + currTask + " 完成�?
            + currTask.getCompletedRatio() + "�?");
        currTask.addCompleted(speed);
      } catch (Exception ex) {
        ex.printStackTrace();
      }
    }
}
。。�?br /> }

�q�行代码

  TaskLibrary taskLibrary=new TaskLibrary();

  taskLibrary.addTask(new Task("培训",8));

  List moreTasks=new LinkedList();
  moreTasks.add(new Task("锻�?,4));
  moreTasks.add(new Task("打磨",5));
  moreTasks.add(new Task("车阶�?,6));
  moreTasks.add(new Task("热处�?,7));
  moreTasks.add(new Task("�ȝ��",8));
  moreTasks.add(new Task("镗孔",60));
  moreTasks.add(new Task("��d��",10));
  moreTasks.add(new Task("拉槽",11));

  taskLibrary.addTasks(moreTasks);

  Worker worker01=new Worker("王进�?,1,taskLibrary);
  Worker worker02=new Worker("时传�?,2,taskLibrary);
  Worker worker03=new Worker("张秉�?,3,taskLibrary);
  Worker worker04=new Worker("徐虎",3,taskLibrary);

  taskLibrary.addTask(new Task("铔R�?,8));
  sleep(1);
  taskLibrary.addTask(new Task("校验",9));
  sleep(2);
  taskLibrary.addTask(new Task("内务",10));
  sleep(3);

�q�行情况分析

一开始先初始化�Q务库,然后�q�行�l��Q务库中添加�Q�?初始化工人实例时会把��d��库实例的地址传入,工�h实例初始化完毕后会调用doWork函数��M�Q务库取�Q务开始做,�q�会�q�入TaskLibrary�cȝ��fetchTask函数,�q�时如果没有则会让工人等�?有则把第一个�Q务给�?然后周而复始进行这一�q�程.

�q�行�l�果�C�Z��

工�h:王进喜取得�Q�?培训工�h:时传详取得�Q�?锻�?工�h:张秉贵取得�Q�?打磨工�h:徐虎取得��d��:车阶�?正在处理的�Q务�Q务名:培训工�h�?王进�?nbsp;完成�?0% 完成�?nbsp;完成�?0%�? 正在处理的�Q务�Q务名:锻�?nbsp;工�h�?时传�?nbsp;完成�?0% 完成�?nbsp;完成�?0%�? 正在处理的�Q务�Q务名:打磨工�h�?张秉�?nbsp;完成�?0% 完成�?nbsp;完成�?0%�? 正在处理的�Q务�Q务名:车阶�?nbsp;工�h�?徐虎完成�?0% 完成�?nbsp;完成�?0%�? 正在处理的�Q务�Q务名:培训工�h�?王进�?nbsp;完成�?12% 完成�?nbsp;完成�?12%�? 正在处理的�Q务�Q务名:锻�?nbsp;工�h�?时传�?nbsp;完成�?50% 完成�?nbsp;完成�?50%�? ��d��d��?锻�?nbsp;工�h�?时传�?nbsp;完成�?100%处理完毕! 工�h:时传详取得�Q�?热处�?正在处理的�Q务�Q务名:打磨工�h�?张秉�?nbsp;完成�?60% 完成�?nbsp;完成�?60%�? ��d��d��?打磨工�h�?张秉�?nbsp;完成�?100%处理完毕! 正在处理的�Q务�Q务名:车阶�?nbsp;工�h�?徐虎完成�?50% 完成�?nbsp;完成�?50%�? ��d��d��?车阶�?nbsp;工�h�?徐虎完成�?100%处理完毕! 工�h:徐虎取得��d��:�ȝ�� 工�h:张秉贵取得�Q�?镗孔正在处理的�Q务�Q务名:培训工�h�?王进�?nbsp;完成�?25% 完成�?nbsp;完成�?25%�? 正在处理的�Q务�Q务名:热处�?nbsp;工�h�?时传�?nbsp;完成�?0% 完成�?nbsp;完成�?0%�? 正在处理的�Q务�Q务名:�ȝ�� 工�h�?徐虎完成�?0% 完成�?nbsp;完成�?0%�? 正在处理的�Q务�Q务名:镗孔工�h�?张秉�?nbsp;完成�?0% 完成�?nbsp;完成�?0%�? 正在处理的�Q务�Q务名:培训工�h�?王进�?nbsp;完成�?37% 完成�?nbsp;完成�?37%�? 正在处理的�Q务�Q务名:热处�?nbsp;工�h�?时传�?nbsp;完成�?28% 完成�?nbsp;完成�?28%�? 正在处理的�Q务�Q务名:�ȝ�� 工�h�?徐虎完成�?37% 完成�?nbsp;完成�?37%�? 正在处理的�Q务�Q务名:镗孔工�h�?张秉�?nbsp;完成�?5% 完成�?nbsp;完成�?5%�? 正在处理的�Q务�Q务名:培训工�h�?王进�?nbsp;完成�?50% 完成�?nbsp;完成�?50%�? 正在处理的�Q务�Q务名:热处�?nbsp;工�h�?时传�?nbsp;完成�?57% 完成�?nbsp;完成�?57%�? 正在处理的�Q务�Q务名:�ȝ�� 工�h�?徐虎完成�?75% 完成�?nbsp;完成�?75%�? ��d��d��?�ȝ�� 工�h�?徐虎完成�?100%处理完毕! 工�h:徐虎取得��d��:��d��

junglesong的博�?/a> 2008-02-22 14:17 发表评论

Fri, 22 Feb 2008 06:13:00 GMT

本文内容

Java�q�行�U�程调度的方�?
如何让线�E�进入等�?
wait set概念的理�?
如何�Ȁ�zȝ��待状态的�U�程.

�q�行�U�程协调的方�?/strong>

从上一章《线�E�的互斥》中我们知道�Q�当�Ҏ(gu��)��体或代码块被synchronized�Ҏ(gu��)��修饰�Ӟ��有一个线�E�在执行�q�部分代码时�Q�其它线�E�无法同时执行这部分代码。但如果我们惌��行更高效的处理如��d��调整�U�程而不是让�U�程被动�{�待和盲目竞争时该怎么处理呢？
在Java中，有三个方法可以对�U�程�q�行��d��高效的控�Ӟ��它们是wait�Q�notify和notifyAll�?br /> wait是主动让�U�程�{�待的方法，而notify和notifyAll则是�Ȁ�zȝ��待中的线�E�的�Ҏ(gu��)��。他们都是Object�cȝ��Ҏ(gu��)��Q�也��是说�Q何对象都可以使用�q�三个方法�?/p>
Wait Set-�U�程的休息室

在学�?f��n)��用wait�Q�notify和notifyAll�q�三个方法之前，我们可以先理解一下Wait Set的概念，它是一个在某实例执行wait�Ҏ(gu��)��Ӟ��停止操作的线�E�的集合�Q�类��g��U�程的休息室�Q�每个实例都拥有�q�样一个休息室�?br /> Wait�Ҏ(gu��)��是用来把�U�程请入�q�个休息室的�Q�而notify和notifyAll�q�两个方法是用来��进入休息室休息的线�E�激�zȝ��?br /> wait Set是一个虚拟的概念�Q�它既不是实例的字段,也不是可以获取在实例上wait中线�E�的列表的方�?它只是用来帮助我们理解线�E�的�{�待和激�zȝ��?/p>
Wait�Ҏ(gu��)��Q�将�U�程攑օ�Wait Set

使用Wait�Ҏ(gu��)��Ӟ��U�程卌��入Wait set。如�U�程在执行代码时遇到�q�样的语句：xxObj.wait();则目前的�U�程会暂时停止运�?�q�入实例xxObj的wait Set.
当线�E�进入Wait Set�?即释放了对该实例的锁�?也就是说,即��是被synchronized修饰的方法和代码�?当第一个线�E�进入实例的wait Set�{�待�?其它�U�程��可以再�q�入�q�部分代码了.
wait()前如果不写某对象表示其前面的对象是this, wait()=this.wait();

notify�Ҏ(gu��)��-从wait set中激�z�M��个线�E?/strong>

使用notify�Ҏ(gu��)��?�E�序会从处于�{�待的实例的休息室中�Ȁ�z�M��个线�E?代码如下:
xxObj.notify();�E�序��从xxObj的wait set中挑��Z��个激�z?�q�个�U�程卛_��备退出wait set.当当前线�E�释攑֯�xxObj的锁定后�Q�这个线�E�即获取�q�个锁定�Q�从上次的停止点-执行wait的地方开始运行�?br /> �U�程必须有调用的实例的锁�?才能执行notify�Ҏ(gu��)��.
Wait set中处于等待状态的�U�程有多�?具体�Ȁ�z�那一个依环境和系�l�而变,事先无法辩明.我们大致可理解�ؓ随机挑选了一�?

notifyAll�Ҏ(gu��)��-�Ȁ�z�wait set中所有等待的�U�程

当执行notifyAll�Ҏ(gu��)��?实例中所有处于等待状态的�U�程都会被激�z?代码�?
xxObj.notifyAll();执行此代码后xxObj的wait set中所有处于等待中的线�E�都会被�Ȁ�z?但具体那个线�E�获取执行wait�Ҏ(gu��)��旉��攄��锁定要靠竞争,最�l�只能有一个线�E�获得锁�?其它的线�E�只能��l�回�ȝ��?
notifyAll与notify的差异在于notifyAll�Ȁ�z�L��有wait set中等待的�U�程,而notify只激�z�d��中的一�?

该��用notify�q�是notifyAll

��:
1) 选择notifyAll比notify�E�_��安全,如果notify处理得不�?�E�序会有隐�?zh��n)?
2) 选择notifyAll比notify可靠,是大多数�E�序的首�?
3) 当你对代码已�l�很清楚,对线�E�理解也很透彻�?你可以选择使用notify,发挥其处理速度高的优势.

当前�U�程必须持有�Ʋ调用实例的锁定,才能调用wait,notify和notifyAll�q�三个方�?

如果代码是xxObj.notifyAll(或wait, notify)(),则这行代码必��d��于synchronized(xxObj){…}代码块中.
如果代码是this.notifyAll(或wait, notify)(),则这行代码必��d��于synchronized修饰的方法中.
前面说过, notifyAll和notify会激�zȝ��E�去获得�q�入wait旉��攄��锁定,但这个锁定要�{�刚才执行notifyAll或notify�Ҏ(gu��)��的线�E�释放这个锁定才能获�?

�ȝ��

1) wait,notify和notifyAll都是java.lang.Object的方�?它们用来对线�E�进行调�?
2) obj.wait()是把执行�q�句的线�E�放入obj的wait set�?
3) obj.notify()是从wait set中唤醒一个线�E?�q�个�U�程在当前线�E�释攑֯�obj的锁定后卌��取这个锁�?
4) obj.notifyAll()是唤醒所有在obj的wait set中的�U�程,�q�批�U�程在当前线�E�释放obj的锁定后�ȝ��争这个锁�?最�l�只有一个能获得,其它的又重新�q�回wait set�{�待下一�ơ激�z?
5) 执行�q�个wait,notify和notifyAll�q�三个方法前,当前�U�程(��x��行obj.wait(), obj.notify()和obj.notifyAll()代码的线�E?必须持有obj的锁�?

junglesong的博�?/a> 2008-02-22 14:13 发表评论

Fri, 22 Feb 2008 06:11:00 GMT

本文内容

同步不是改善�E�序安全性的灵丹妙药�?br /> 发生死锁的两�U�情况和解决�Ҏ(gu��)��?/p>
同步不是改善�E�序安全性的灵丹妙药

从《线�E�的同步》一节中我们可以知道�Q�synchronized能保证只有一个线�E�进入同步方法或同步块，但�ؓ了安全性盲目给多线�E�程序加上synchronized关键字�ƈ不是问题解决之道�Q�这不但会降低程序的效率�Q�还有可能带来严重的问题-死锁�?br /> 死锁发生在两个或以上的线�E�在�{�待对象锁被释放�Q�但�E�序的环境却让lock无法释放时。下面我们将看到两种�c�d��的死锁例子�?/p>
某线�E�不退出同步函数造成的死�?/strong>

public class PaintBoard extends Thread{
private boolean flag=true;

public void paint(){
    System.out.println("模拟�l�画");
}

public synchronized void run(){
    while(flag){
      try{
        paint();
        Thread.sleep(1000);
      }
      catch(InterruptedException ex){
        ex.printStackTrace();
      }
    }
}

public synchronized void stopDraw(){
    flag=false;
    System.out.println("��止�l�画");
}

public static void main(String[] args){
    PaintBoard paintBoard=new PaintBoard();
    paintBoard.start();
    new StopThread(paintBoard);
}
}

public class StopThread implements Runnable{
private PaintBoard paintBoard;

public StopThread(PaintBoard paintBoard){
    this.paintBoard=paintBoard;

    Thread th=new Thread(this);
    th.start();
}

public void run(){
    while(true){
      System.out.println("试图停止�l�画�q�程");
      paintBoard.stopDraw();
      System.out.println("停止�l�画�q�程完成");
    }
}
}

问题的发生和解决

刚才的死锁原因是run()函数中有一个无限��@环，一个线�E�进入后会在其中往复操作，�q��它永�q�不会放弃对this的锁定，�l�果��D��其它�U�程无法获得this的锁定而进入stopDraw函数�?br /> 我们把修饰run函数的synchronized取消��p��解决问题�?run函数中不会改变�Q何量�Q�这�U�函数是不该加上synchronized的�?/p>
两个�U�程争抢资源造成的死�?

public class Desk{
private Object fork=new Object();
private Object knife=new Object();

public void eatForLeft(){
    synchronized(fork){
      System.out.println("左撇子拿起叉");
      sleep(1);
      synchronized(knife){
        System.out.println("左撇子拿起刀");
        System.out.println("左撇子开始吃�?);
      }
    }
}

public void eatForRight(){
    synchronized(knife){
      System.out.println("��x��子拿起刀");
      sleep(1);
      synchronized(fork){
        System.out.println("��x��子拿起叉");
        System.out.println("��x��子开始吃�?);
      }
    }
}

private void sleep(int second){
    try{
      Thread.sleep(second*1000);
    }
    catch(InterruptedException ex){
      ex.printStackTrace();
    }
}

public static void main(String[] args){
    Desk desk=new Desk();
    new LeftHand(desk);
    new RightHand(desk);
}
}

public class LeftHand implements Runnable{
private Desk desk;

public LeftHand(Desk desk){
    this.desk=desk;

    Thread th=new Thread(this);
    th.start();
}

public void run(){
    while(true){
      desk.eatForLeft();
    }
}
}

public class RightHand implements Runnable{
private Desk desk;

public RightHand(Desk desk){
    this.desk=desk;

    Thread th=new Thread(this);
    th.start();
}

public void run(){
    while(true){
      desk.eatForRight();
    }
}
}

问题的发生和解决

�q�部分程序中于两个线�E�都要获得两个对象的锁定才能执行实质性操作，但运行�v来却发现其它�U�程持有了自己需要的另一个锁定，于是停在Wait Set中等待对斚w��放这个锁定，�l�果造成了死锁�?br /> 解决�q�个问题的方法是保证锁对象的持有��序�Q�如果两个加上了同步的函数都是先刀后叉的�Ş式则不会发生问题�?/p>
��结

同步不是改善�E�序安全性的灵丹妙药�Q�盲目同步也会导致严重的问题-死锁.
某线�E�持�l�不退出同步函��C��造成死锁.解决�Ҏ(gu��)��是去掉或更换不正��的同步�?br /> 两个�U�程都等待对斚w��放自己需要的资源也会造成死锁.�q�种情况的解��x��法是��保同步锁对象的持有��序�?/p>

junglesong的博�?/a> 2008-02-22 14:11 发表评论

Fri, 22 Feb 2008 04:43:00 GMT

多线�E�操作同一实例的问�?/strong>

在多�U�程环境中，�l�常有两个以上线�E�操作同一实例的问题，无论是�ƈ行Parallel环境�q�是�q�发Concurrent环境�Q�都有发生有多个�U�程修改同一变量的问题，如果�q�个变量是成员变量，多线�E�将会给�E�序带来破坏性的影响。请见以下代码�?/p>
资源库类

public class ResourceLib {
private long count1;

private long count2;

public ResourceLib(int count) {
    this.count1 = count;
    this.count2 = count;
}

/**
   * 取回资源
   * 加上synchronized才是�U�程安全
   *
   * @param count
   */
public void fetch(int count) {
    count1 += count;
    mockLongTimeProcess();
    count2 += count;
    checkTwoCount(count);
}

/**
   * 送出资源
   * 加上synchronized才是�U�程安全
   *
   * @param count
   * @return
   */
public void send(int count) {
    count1 -= count;
    mockLongTimeProcess();
    count2 -= count;
    checkTwoCount(count);
}

   /**
   * 模拟一个耗时�q�程
   *
   */
private void mockLongTimeProcess(){
    try{
      Thread.sleep(1000);
    }
    catch(Exception ex){
      ex.printStackTrace();
    }
}

private void checkTwoCount(int borrowCount) {
    if (count1 != count2) {
      System.out.println(count1 + "!= " + count2);
      System.exit(0);
    } else {
      System.out.println(count1 + "==" + count2);
    }

    if (Math.abs(count1) > 10000000 || Math.abs(count2) > 10000000) {
      count1 = 0;
      count2 = 0;
    }
}

public static void main(String[] args) {
    ResourceLib lib = new ResourceLib(10000);

    for (int i = 1; i < 20; i++) {
      new Supplier(String.valueOf(i), i, lib);
    }

    for (int i = 1; i < 10; i++) {
      new Comsumer(String.valueOf(i), i, lib);
    }
}
}

取资源和�l�资源的两个�U�程

public class Comsumer implements Runnable{
private ResourceLib resourceLib;
private int count;

public Comsumer(String name,int count,ResourceLib resourceLib){
    this.count=count;
    this.resourceLib=resourceLib;

    Thread thread=new Thread(this);
    thread.start();
}

public void run(){
    while(true){
      resourceLib.send(count);
    }
}
}

public class Supplier implements Runnable{
private ResourceLib resourceLib;
private int count;

public Supplier(String name,int count,ResourceLib resourceLib){
    this.count=count;
    this.resourceLib=resourceLib;

    Thread thread=new Thread(this);
    thread.start();
}

public void run(){
    while(true){
      resourceLib.fetch(count);
    }
}
}

�q�行�l�果

在main函数中，�E�序启动了多个消费者线�E�和生��者线�E�，消费者线�E�在不断减少count1和count2�Q�生产者线�E�在不断增加count1和count2�Q�在单线�E�环境中�Q�程序绝不会出现count1和count2不相�{�的情况�Q�而多�U�程环境中，可能有一个线�E�在��查count1和count2�Ӟ��其中一个已�l�被另一个线�E�所修改�?br /> 因此��D��了两个��g��相等的情况发生�?/p>
�q�行�l�果之一
10145!= 10001
10145!= 10003
10145!= 10006
10145!= 10010
10145!= 10015
10145!= 10021
10145!= 10028
10145!= 10036
10145!= 10045
10145!= 10055
10145!= 10066

另一个经典多�U�程实例�Q�银行取��?/strong>

package com.sitinspring.unsafebank;

public class Bank{
private int count;

public Bank(int count){
    this.count=count;
}

public void withdraw(int money){
    if(count>money){
      mockLongTimeProcess();// 模拟耗时�q�程
      count-=money;
      System.out.println("提走"+money+" 现有"+count);
    }
    else{
      System.out.println(" 现有数量"+count+"��于"+money+" 不能提取");
    }

    checkCount();
}

public void checkCount(){
    if(count<0){
      System.out.println(count + "< 0 ");
      System.exit(0);
    }
}

/**
   * 模拟一个耗时�q�程
   *
   */
private void mockLongTimeProcess(){
    try{
      Thread.sleep(1000);
    }
    catch(Exception ex){
      ex.printStackTrace();
    }
}

public static void main(String[] args){
    Bank bank=new Bank(1000);

    for(int i=1;i<10;i++){
      new Customer(i*i*i,bank);
    }
}
}

客户�c�d��讲述

public class Customer implements Runnable{
private Bank bank;
private int count;

public Customer(int count,Bank bank){
    this.count=count;
    this.bank=bank;

    Thread thread=new Thread(this);
    thread.start();
}

public void run(){
    while(true){
      bank.withdraw(count);
    }
}
}

在单�U�程环境中，提款旉��行的��L��l�不会是负数�Q�但在多�U�程环境中，有可能在一个线�E�A�W�合条�g在进行耗时�q�算和网�l�数据传递时�Q�另一个线�E�B已经把钱提走�Q��L��已经发生变化�Q�结果A�U�程再提�ƾ时总钱数已�l�减��了�Q�因此致佉K��行总钱数小于零�?/p>
解决�Ҏ(gu��)��Q�在�Ҏ(gu��)��员变量进行修改的函数前加上synchronized关键�?/strong>

synchronized�Ҏ(gu��)��又被成�ؓ”同步“�Ҏ(gu��)��。当一个方法加上关键字synchronized声明之后�Q�就可以让一个线�E�操作这个方法�?#8220;让一个线�E�操�?#8221;�q�不是说只能让某一个特定的�U�程操作而已�Q�而是指一�ơ只能让一个线�E�执行，也就是说,在一个线�E�没有退出同步方法前�Q�其它线�E�绝无可能进入这个同步方法和其它�q�列的同步方法，只能在外面排队等候�?br /> 一个实例的synchronized�Ҏ(gu��)��只能允许1�ơ一个线�E�执行。但是非synchronized�Ҏ(gu��)��没有这个限�Ӟ��它可以供2个以上的�U�程执行�?/p>
修改后的�U�程安全的Bank�c?/strong>

public class Bank{
private int count;

public Bank(int count){
    this.count=count;
}

public synchronized void withdraw(int money){
    if(count>money){
      mockLongTimeProcess();// 模拟耗时�q�程
      count-=money;
      System.out.println("提走"+money+" 现有"+count);
    }
    else{
      System.out.println(" 现有数量"+count+"��于"+money+" 不能提取");
    }

    checkCount();
}

public void checkCount(){
    if(count<0){
      System.out.println(count + "< 0 ");
      System.exit(0);
    }
}
。。。�?/ 部分代码省略
}

修改后的�U�程安全的ResourceLib�c?/strong>

public class ResourceLib {
private long count1;
private long count2;

public synchronized void fetch(int count) {
    count1 += count;
    mockLongTimeProcess();
    count2 += count;
    checkTwoCount(count);
}

public synchronized void send(int count) {
    count1 -= count;
    mockLongTimeProcess();
    count2 -= count;
    checkTwoCount(count);
}

public void checkTwoCount(int borrowCount) {
    if (count1 != count2) {
      System.out.println(count1 + "!= " + count2);
      System.exit(0);
    } else {
      System.out.println(count1 + "==" + count2);
    }

    if (Math.abs(count1) > 10000000 || Math.abs(count2) > 10000000) {
      count1 = 0;
      count2 = 0;
    }
}
}

�?部分代码省略

执行之后

在一个执行synchronized�Ҏ(gu��)��的线�E�执行结束后,锁定卌��释放, 其它不得光��而入的线�E�开始争抢锁�?一定会有一个线�E�获取锁�?没有抢到的线�E�只好再�l�箋�{��?
注意: 非静态的synchronized�Ҏ(gu��)��锁定的对象是实例�Q�静态的synchronized�Ҏ(gu��)��锁定的对象是�c�d��象�?/p>
同步�?/strong>

以下同步�Ҏ(gu��)��可用双��的同步块代替:
public synchronized void fun(){
    ………
}

与左边同步方法对�{�的同步块：
public void fun(){
   synchronized(this){
     ………
   }
}

同步块和同步�Ҏ(gu��)��的比�?/strong>

1�Q�同步方法锁定的�cȝ��实例或类对象�Q�同步块则可以换成�Q意实例，灉|��性更高�?br /> 2�Q�有旉��要多个锁定而不是一个，如函数A和函数B需要锁�?�Q�函数B和函数C需要锁�?�Q�这时如果��用同步方法无疑会锁定A和C�Q�造成�E�序效率的降低。这时最应该使用同步块�?/p>
什么时候该加同步synchronized

如果一个函数或代码块有可能被多个线�E�进入，而这个函数或代码块又修改了类的成员变量，则这个这个函数或代码块就应该加上同步synchronized�?br /> 如果一个函数或代码有可能被多个�U�程�q�入�Q�而这个函数或代码块只是读取类的成员变量，则这个这个函数或代码块就不该加上同步synchronized�?/p>

junglesong的博�?/a> 2008-02-22 12:43 发表评论

Fri, 22 Feb 2008 04:34:00 GMT

单线�E�程�?/strong>

一般来��_��在没有线�E�的帮助下，�E�序在一个时间段只能执行一�D�代码，其它代码�D�只有在�{�待它完成后才能执行。该�E�序的处理流�E�从头到��֏�有一条线�Q�这��L(f��ng)��E�序我们�U�C��为单�U�程�E�序�Q�Single Thread Program�Q?/p>
典型的单�U�程�E�序�Q?br /> public class SingleThreadProgram{
public static void main(String[] args){
    for(int i=0;i<1000;i++){
      System.out.print("SingleThreadProgram");
    }
}
}

多线�E�程�?/strong>

当程序由一个以上的�U�程所构成�Ӟ��U�此�E�序为多�U�程�E�序�Q�Multithread Program�Q�，java从设计伊始就把程序的多线�E�能力列入了考虑范围�?br /> 典型的多�U�程�E�序有：

1�Q�GUI应用�E�序�Q�我们目前做的Swing桌面�E�序��属于此�c�R�?br /> 2�Q�较��p��旉��的I/O处理,一般来�?文�g和网�l�的输入/输出处理比较��p��旉��,如果在这�D�|��法进行其它处�?则程序性能会大打折�?遇到�q�种情况首先要想到用多线�E�解决问�?
3�Q�多�q�接�|�络处理�?/p>
�q�发(Concurrent)与�ƈ�?Parallel)

当有多个�U�程在操作时,如果�pȝ��只有一个CPU,则它�Ҏ(gu��)��不可能真正同时进行一个以上的�U�程,它只能把CPU�q�行旉��划分成若�q�个旉��D?再将旉��D�分配给各个�U�程执行,在一个时间段的线�E�代码运行时,其它�U�程处于挂�v状�?�q�种方式我们�U�C��为�ƈ�?Concurrent).
当系�l�有一个以上CPU�?则线�E�的操作有可能非�q�发.当一个CPU执行一个线�E�时,另一个CPU可以执行另一个线�E?两个�U�程互不抢占CPU资源,可以同时�q�行,�q�种方式我们�U�C��为�ƈ�?Parallel)

多线�E�在�q�发和�ƈ行环境中的不同作�?/strong>

在�ƈ发环境时,多线�E�不可能真正充分利用CPU,节约�q�行旉��,它只是以”挂�v->执行->挂�v”的方式以很小的时间片分别�q�行各个�U�程,�l�用户以每个�U�程都在�q�行的错�?在这�U�环境中,多线�E�程序真正改善的是系�l�的响应性能和程序的友好�?
在�ƈ行环境中, 一个时��d��许多个线�E�运�?�q�时多线�E�程序才真正充分利用了多CPU的处理能�? 节省了整体的�q�行旉��.在这�U�环境中,多线�E�程序能体现出它的四大优�?充分利用CPU,节省旉��,改善响应和增加程序的友好�?

PS:在多核时代来临后,开发多�U�程�E�序的能力更是每个程序员都该具备�?

创徏多线�E�程�?/strong>

创徏多线�E�程序我们通常有两�U�方法：
1�Q�让�cȝ��承java.lang.Thread,�q�种�Ҏ(gu��)��优势在于调用�E�微方便,一般用于后台批处理�E�序的场�?但劣势是�c�L��法再�l�承别的�c�R�?br /> 2�Q�让�c�d��现接口java.lang.Runnable�Q�这�U�方法调用时需要借助Thread的帮助，�E�显�ȝ��Q�但优势在于对类�l�承体系没有影响�Q�这是��用线�E�时最常用的方法�?br /> 两种�Ҏ(gu��)��的线�E�执行部分都在run�Q�）函数中，它们的效率没有差别�?/p>
多线�E�程序创建和启动�C�Z��

创徏�U�程

// �l�承Thread�c?br /> public class Thread1 extends Thread{
public void run(){
    while(true){
      System.out.println("");
    }
}
}

// 实现Runnable接口
public class Thread2 implements Runnable{
public void run(){
    while(true){
      System.out.println("");
    }
}
}

启动�U�程

public class Main{
public static void main(String[] args){
    // 启动�U�程1,Thread1直接�l�承自java.lang.Thread�c?br />     Thread1 th1=new Thread1();
    th1.start();

    // 启动�U�程2�Q�thread2实现自java.lang.Runnable接口
    Thread2 thread2=new Thread2();
    Thread th2=new Thread(thread2);
    th2.start();

    while(true){
      System.out.println("
");
    }
}
}

概念解析Start和Run

public void run()
�q�个函数容纳�U�程启动后执行的代码�?�U�程启动��h��,run函数中的代码会得到执�?

Thead.start()
�q�是启动一个线�E�的�Ҏ(gu��)��,调用了这个方法后,�U�程才会得到执行.

取得�U�程执行的结�?/strong>

通过观察run函数的签名public void run()我们可以发现,它既没有输入参数,也没有返回�?那如何取得线�E�的�q�回值呢?一般来说我们有三种办法:
1)让线�E�修改公有变�?如某�cȝ��静态公有字�D?�q�种方式古老而危�?最好不要采�?
2)轮询�U�程执行�l�果,�U�程执行的结果放在线�E�类的一个字�D�中,外界不断通过轮询��L��看执行结�?�q�种方式会浪费很多时�?�l�果也不可靠,不徏议采�?
3)回调方式,把调用方的指针通过�U�程�cȝ��构造函��C��入线�E�类的一个字�D�中,当线�E�执行完取得�l�果后再通过�q�个字段反向调用调用方的函数.�q�是取得�U�程执行�l�果的最佌��x��?

下面��L(f��ng)��回调方式的实�?/strong>.

Boss�c?br /> �q�个�cȝ��于启动Secretary�U�程��L��找文�? findFile()是启动线�E��ƈ查找的函�? giveBossResult(String file,String reult)是供Secretary�c�d��调的函数.

public class Boss{
private String name;

public Boss(String name){
    this.name=name;
}

public void giveBossResult(String file,String reult){
    if(reult!=null){
      System.out.println("文�g"+file+"序列��L(f��ng)��于："+reult);
    }
    else{
      System.out.println("无法扑ֈ�文�g"+file);
    }
}

public void findFile(){
    Map files=new Hashtable();
    files.put("001", "员工花名�?);
    files.put("002", "企业收支");
    files.put("003", "客户花名�?);
    files.put("004", "�Ҏ(gu��)��状况分析");
    files.put("005", "当月收支");
    files.put("006", "市场份额分析");
    files.put("007", "大连酒店一�?);
    files.put("008", "�׃��场所名录");
    files.put("009", "关系单位联系名录");

    Secretary andy=new Secretary("Andy",this,"员工花名�?,files);
    Thread th1=new Thread(andy);
    th1.start();

    Secretary cindy=new Secretary("cindy",this,"上市情况分析",files);
    Thread th2=new Thread(cindy);
    th2.start();
}

public static void main(String[] args){
    Boss boss=new Boss("Bill");
    boss.findFile();
}
}

Secretary�c?/p>
�q�个�c�L��q�行多线�E�查找文件的�c?查找的结果通过回调�Ҏ(gu��)��告知Boss实例.
Boss实例,查找的文件名,查找的集合都通过Secretary�cȝ��构造函��C��q�来.

public class Secretary implements Runnable{
private String name;
private Boss boss;
private String file;
private Map files;

public Secretary(String name,Boss boss,String file,Map files){
    this.name=name;
    this.boss=boss;
    this.file=file;
    this.files=files;
}

public void run(){
    for(Map.Entry entry:files.entrySet()){
         if(entry.getValue().equals(file)){
           boss.giveBossResult(file,entry.getKey());
           return;
         }
    }

    boss.giveBossResult(file,null);
}
}

junglesong的博�?/a> 2008-02-22 12:34 发表评论