软件架构概念大观

软件架构对于每一个人的理解都是不同的，通过分类可以在包容细节差异的小基础上明确共性，达到“概念总体上的清晰”。

将软件架构概念分派别：

1.组成派

软件系统的架构将系统描述为计算组件及组件之间的交互。

计算组件是泛指的，可以进一步细分为处理组件，数据组件，连接组件可以是子系统，框架，模块，类等不同粒度的软件单元

特征：

(1.关注架构实践中的客体--软件，以软件本身为描述对象；

(2.分析了软件的组成，即软件由承担不同计算任务的组件组成，这些组件通过相互交互完成更高层次的计算。

2.决策派

软件架构包含了关于一下问题的重要决策，对关键问题进行决策：

×软件系统的组织

×选择组成系统的结构元素和他们之间的接口，以及当这些元素相互协作时所体现的行为；

×如何组成这些元素，使他们逐渐合成为更大的子系统

*用于指导这个系统组织的架构风格，这些元素以及他们的接口，协作和组合。

软件架构并不仅仅注重软件本身的结构和行为，还组中其他特性，使用，功能性，性能，弹性，重用，可理解性，经济和技术的限制的权衡。

特征：

（1关注架构实践中的主体--人，一人为决策为描述的对象；

（2归纳了架构决策的类型，指出架构决策不仅包括关于软件系统的组织，元素，子系统和架构风格等几类决策，还包括非功能性决策。

如前所述，将软件架构概念分类的好处是：包容细节差异、明确本质共性、促成概念总体上的清晰。下面我们再列举几个著名的软件架构定义，以期达到下列目的：

（1）体会和证明众多软件架构概念都是围绕“组成”和“决策”两个视角展开的；

（2）开阔视野，说不定和你合作的同事所接受的软件架构概念就是其中的一种。

具体而言，下面的定义1和定义2属于架构概念的“决策派”，而定义3、4、5、6、7属于架构概念的“组成派”。值得说明的是，定义7是来自SEI的Bass等人的相对比较新的定义，它将架构的多视图“本性”体现到了架构的定义当中，本书认为这种做法非常值得肯定。在第4章中，我们将专门讨论软件架构视图这一主题。

1.2.1 Booch、Rumbaugh和Jacobson的定义

架构是一系列重要决策的集合，这些决策与以下内容有关：软件的组织，构成系统的结构元素及其接口的选择，这些元素在相互协作中明确表现出的行为，这些结构元素和行为元素进一步组合所构成的更大规模的子系统，以及指导这一组织——包括这些元素及其接口、它们的协作和它们的组合——架构风格。

1.2.2 Woods的观点

Eoin Woods是这样认为的：软件架构是一系列设计决策，如果作了不正确的决策，你的项目可能最终会被取消（Software architecture is the set of design decisions which, if made incorrectly, may cause your project to be cancelled.）。

1.2.3 Garlan和Shaw的定义

Garlan和Shaw认为：架构包括组件（Component）、连接件（Connector）和约束（Constrain）三大要素。组件可以是一组代码（例如程序模块），也可以是独立的程序（例如数据库服务器）。连接件可以是过程调用、管道和消息等，用于表示组件之间的相互关系。“约束”一般为组件连接时的条件。

1.2.4 Perry和Wolf的定义

Perry和Wolf提出：软件架构是一组具有特定形式的架构元素，这些元素分为三类：负责完成数据加工的处理元素（Processing Elements）、作为被加工信息的数据元素（Data Elements）及用于把架构的不同部分组合在一起的连接元素（Connecting Elements）。

1.2.5 Boehm的定义

Barry Boehm和他的学生提出：软件架构包括系统组件、连接件和约束的集合，反应不同涉众需求的集合，以及原理（Rationale）的集合。其中的原理，用于说明由组件、连接件和约束所定义的系统在实现时，是如何满足不同涉众需求的。

1.2.6 IEEE的定义

IEEE 610.12-1990软件工程标准词汇中是这样定义架构的：架构是以组件、组件之间的关系、组件与环境之间的关系为内容的某一系统的基本组织结构，以及指导上述内容设计与演化的原理（Principle）。

1.2.7 Bass的定义

SEI（Software Engineering Institute, SEI，美国卡内基梅隆大学软件研究所）的Bass等人给架构的定义是：某个软件或计算机系统的软件架构是该系统的一个或多个结构，每个结构均由软件元素、这些元素的外部可见属性、这些元素之间的关系组成（The software architecture of a program or computing system is the structure or structures of the system, which comprise software elements, the externally visible properties of those elements, and the relationships among them.）。

标签 : architecture

发表评论

IT瘾于2010年8月15日上午09时56分13秒发布 #

java 线程超时中断实现

有一个需求,就是当一个方法执行超时的时候就中断该方法.
java的超时实现,在网上搜到的大部分是:
方法1.
　　中断线程最好的，最受推荐的方式是，使用共享变量（shared variable）发出信号，告诉线程必须停止正在运行的任务。线程必须周期性的核查这一变量（尤其在冗余操作期间），然后有秩序地中止任务。Listing B描述了这一方式。

Listing B
class Example2 extends Thread {

  volatile boolean stop = false;

  public static void main( String args[] ) throws Exception {

    Example2 thread = new Example2();

   System.out.println( "Starting thread..." );

   thread.start();

   Thread.sleep( 3000 );

   System.out.println( "Asking thread to stop..." );

   thread.stop = true;

   Thread.sleep( 3000 );

   System.out.println( "Stopping application..." );

   //System.exit( 0 );

  }

  public void run() {

    while ( !stop ) {

     System.out.println( "Thread is running..." );

      long time = System.currentTimeMillis();

      while ( (System.currentTimeMillis()-time < 1000) && (!stop) ) {

      }

    }

   System.out.println( "Thread exiting under request..." );

  }

}
另外，httpclient中就提供了这样一个class- timeoutcontroller（位于org.Apache.commons.httpclient.util包内）查看该class的源代码可知其实现细节：
public static void execute(thread task, long timeout) throws timeoutexception {
        task.start()；
        try {
       task.join(timeout)；
        } catch (interruptedexception e) {
       /* if somebody interrupts us he knows what he is doing */
        }
        if (task.isalive()) {
       task.interrupt()；
       throw new timeoutexception()；
        }
    }
其实就是通过join()和interrupt()方法实现这种功能，文档中强调了task的interrupt()方法必须重写(override)
方法2.
   用join,就是在主线程里开一个子线程(t),在子线程里去处理超时任务,主线程t.join(3000),3000为要等待的时间(ms),如果子线程没有超时则正常继续执行,如果超时了则中断该子线程t.interrupt();
   代码如下:

Java代码 
public class ThreadTest {   
   
    public static void main(String[] args) {   
      
        CounterThread ct = new CounterThread(5000);   
        
        System.out.println("start...");   
           
        System.out.println("ct start...");   
        ct.start();   
    
        System.out.println("ct join...");   
        try {   
            ct.join(2000);   
        } catch (InterruptedException e) {   
            e.printStackTrace();   
        }   
        System.out.println(ct.isAlive());   
        ct.interrupt();   
        System.out.println(ct.isAlive());   
           
        System.out.println("the result is " + ct.getResult());   
   
    }   
   
}   
   
class CounterThread extends Thread {   
    private int time;   
    public CounterThread(int time) {   
        this.time = time;   
    }   
   
    private int result;   
   
    public int getResult() {   
        return result;   
    }   
   
    public void run() {   
        try {   
              
            Thread.sleep(time);   
            System.out.println(Thread.currentThread().getName()   
                    + " is blocked for " + time + "ms");   
        } catch (InterruptedException ex) {   
   
        }   
        result = 5;   
    }   
}   

这种方式是可以的,其实还有另外一种方式,就是

Java代码 
public class TimeoutTest1 {   
   
    public static void main(String[] args) {   
        final ExecutorService service = Executors.newFixedThreadPool(1);   
   
        TaskThread taskThread = new TaskThread();   
   
        System.out.println("提交任务...begin");   
          
        Future<Object> taskFuture = service.submit(taskThread);   
        System.out.println("提交任务...end");   
        try {   
            System.out.println("get .... begin");   
            Object re = taskFuture.get(1000, TimeUnit.MILLISECONDS);   
            System.out.println(re);   
            System.out.println("get .... end");   
        } catch (InterruptedException e) {   
            e.printStackTrace();   
        } catch (ExecutionException e) {   
            e.printStackTrace();   
        } catch (TimeoutException e) {   
            System.out.println("超时 取消任务");   
            taskFuture.cancel(true);   
            System.out.println("超时 取消任务OK");   
        }finally{   
            System.out.println("关闭服务");   
            service.shutdown();   
            System.out.println("关闭服务OK");   
        }   
   
    }   
   
}   
class TaskThread implements Callable<Object> {   
          
   
    public Object call() throws Exception {   
        String result = "空结果";   
        try {   
            System.out.println("任务开始....");   
            Thread.sleep(5000);   
            result = "正确结果";   
            System.out.println("任务结束....");   
        } catch (Exception e) {       
            System.out.println("Task is interrupted!");   
        }   
        return result ;   
    }   
   
}   

标签 : java, thread

发表评论

IT瘾于2010年8月11日上午08时22分05秒发布 #

换一种态度看程序员

有这样一群人，他们经常孤独地工作到深夜，漆黑夜里的显示器成为房间中唯一的光源，手边残留着比萨饼和碳酸饮料。繁重的编码任务让他们很少离开座位，即便是周五的深夜，这些人依旧在办公室中奋战。
乍一听，这像是在描述黑客们的工作状态。但实际上，大多数普通的开发人员就是这样生活着。除了工作，他们有家庭、兴趣以及责任，但项目的压力让他们无暇顾及工作以外的事情。工时长、假期短以及与当前社会发展脱节等问题普遍存在于他们当中。

虽然现在社会大力倡导所谓的知识经济，但这群聪明且高度专业化的人员不被重视，因为经理们认为，程序员是替代性很强的群体。这样的观念导致这些潜在的社会精英不得不重新考虑他们的职业规划。最终，他们当中的大多数另谋高就，另一些则踏入到全新的行业之中。

你认为游戏行业真的是一片乐土吗?一名业内人士讲，游戏开发几乎会占据程序员生活的全部，因为产品质量总会有改进的余地。他们工作时间长，没有加班费以及应有的假期。有些员工甚至连续四年薪水都没有调整过。他身边不少同事都是因为工作而导致了离婚。

当工作条件变得无法忍受时，最聪明以及最有天分的员工通常是最先离开的。凭借他们的资质，他们可以在其他领域挖掘到更多的机会。这样势必导致开发团队整体水平的下降。经理对开发者施加的压力越大，长期来看团队的效率就越低。IT顾问布鲁斯·韦伯斯特将这种情况称为“死海效应”。如果公司发展每况愈下，它就更难得到真正的人才，也更难留住这些人，这样的恶性循环无疑会拖垮公司。离岸外包的出现则加剧了这种趋势：内部开发团队的效率越低，公司就越希望通过低成本外包取代这个团队。而内部开发者会强烈地感到他们即将被替代，因此无法集中精力工作。

员工的倦怠会毁掉公司的未来，而经理们是可以降低死海效应的。他们可以设定合理的工作时长并且提供加班费，可以规定公休日并严格地执行，可以设置合理的产品发布时间以减少过度的压力。他们甚至可以尝试调整项目的开发方法，比如采用敏捷开发等。但是，最重要的一点就是，他们必须重新审视开发人员的价值。在这样一个与互联网发展速度同步的领域，每一个员工都应该被公平、公正地对待，并且获得应有的尊重，即使他们真地喜欢比萨饼和碳酸饮料。　

《中国计算机报》

标签 : 程序员

发表评论

IT瘾于2010年8月9日下午06时15分56秒发布 #