睫晋姬

2010年7月29日 #

如何获取Sun推出的Java认证指南

  Sun推出的专业认证包括下列三种:

  ◆JAVA认证考试

  对于JAVA程序设计员,Sun推出两项认证:

  Sun Certified JAVA Programmer(SCJP)

  Sun Certified JAVA Developer(SCJD)

  Java程序员的认证Sun Certified JAVA Programmer(SCJP)课程:SL-275JAVA语言编程,考试号为310-025.

  java开发员认证Sun Certified JAVA Deverloper(SCJD),认证考试以Sun指定的javaSL-285为教材,机考部分的考试号为310-027。

  SCJP测验JAVA程序设计概念及能力,内容偏重于JAVA语法及JDK的内容;SCJD则进一步测试用JAVA开发应用程序的能力,考试者必须先完成一个程序的设计方案,再回答与此方案相关的一些问题。

  ◆Solaris系统管理认证考试

  对Solaris/SunOS系统管理员,Sun推出Certified Solaris Administrator(CSA)。CSA分别为两个等级(PartI和PartII),测试对Solaris系统管理的了解程度。

  ◆Solaris网络管理认证考试

  为了测试使用者对于Solaris网络管理能力,Sun推出Certified Network Administrator(CNA)。内容包括基本网络概念、RoutingandSubnet、Security、Performance、DNS、NIS+等。

  SunJava认证是业界唯一经Sun授权Java认证培训。Sun认证Java开发员考试内容包括完整的Java应用程序开发,涉及数据库、图形用户界面、网络通信、平台移植等各方面内容,要求学员已通过Java程序员认证。学习结束后,可参加全球连网考试。考试合格则由Sun公司颁发国际通用的Java开发员证书。

  Java语言在1995年发布以来,因其具有简单性、跨平台、面向对象等特点,受到程序员们的欢迎,经过这几年的迅速发展,现在已经成为和C++语言并列的主流开发语言。Java语言的广泛使用,使得越来越多的人加入到Java语言的学习和应用中来。

  在这些人当中,许多人选择了经过Sun公司授权的Sun教育中心(ASEC)来学习,因为和一些非授权的中心相比,只有ASEC受到Sun组合机床公司的关注和支持,他们可以提供最新的培训材料和Sun需要的精深技术资源。学员在那里可以学习到最新的Java技术,更顺利地通过SunJava的认证考试。

  了解SunJava认证课程

  Java不仅仅是一种编程语言,同时它也是一个开发和运行的平台,有自己完整的体系结构。SunJava认证课程从中选择了最具有代表性的一些方面。

  SCJP(Sun Certified Java Programmer)可以说是各种Java认证的基础,其对应的最主要的学习课程是一门Java的基础课程,也就是Java Programming Language(SL-275),这也是国内的SCJP培训的标准课程。而SCJD(Sun Certified Java Developer)则可以看做是高级的Java技术培训认证,其要求和难度都要高于SCJP,而且,如果你计划获得SCJD认证,则要先获得SCJP认证资格。SCEA(Sun Certified Enterprise Architect for J2EE Technology)认证的难度也不小,其学习课程主要有两个:00-226O bject-Oriented Analysisand Design以及SL-425 Architectingand Designing J2EE Applications。SCWD(Sun Certified WebComponent Developer for Java2 Platform Enterprise Edition)是Sun新推出的Java认证考试,主要面向使用JavaServlet以及JSP技术开发Web应用程序的相关技术认证。

  如何获取Java认证

  首先,你需要有充分的心理准备,因为SunJava认证考试非常严谨,需要你具备充足的实践经验才可能通过。

posted @ 2010-07-29 16:10 睫晋姬 阅读(155) | 评论 (0)编辑 收藏

spring连接池配置详解

  数据库连接池概述:

  数据库连接是一种关键的有限的昂贵的资源,这一点在多用户的网页应用程序中体现得尤为突出。对数据库连接的管理能显著影响到整个应用程序的伸缩性和健壮性,影响到程序的性能指标。数据库连接池正是针对这个问题提出来的。

  数据库连接池负责分配、管理和释放数据库连接,它允许应用程序重复使用一个现有的数据库连接,而再不是重新建立一个;释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏。这项技术能明显提高对数据库操作的性能。

  数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中,这些数据库连接的数量是由最小数据库连接数来设定的。无论这些数据库连接是否被使用,连接池都将一直保证至少拥有这么多的连接数量。连接池的最大数据库连接干洗设备数量限定了这个连接池能占有的最大连接数,当应用程序向连接池请求的连接数超过最大连接数量时,这些请求将被加入到等待队列中。数据库连接池的最小连接数和最大连接数的设置要考虑到下列几个因素:

  1) 最小连接数是连接池一直保持的数据库连接,所以如果应用程序对数据库连接的使用量不大,将会有大量的数据库连接资源被浪费;

  2) 最大连接数是连接池能申请的最大连接数,如果数据库连接请求超过此数,后面的数据库连接请求将被加入到等待队列中,这会影响之后的数据库操作。

  3) 如果最小连接数与最大连接数相差太大,那么最先的连接请求将会获利,之后超过最小连接数量的连接请求等价于建立一个新的数据库连接。不过,这些大于最小连接数的数据库连接在使用完不会马上被释放,它将被放到连接池中等待重复使用或是空闲超时后被释放。

  目前常用的连接池有:C3P0、DBCP、Proxool

  网上的评价是:

  C3P0比较耗费资源,效率方面可能要低一点。

  DBCP在实践中存在BUG,在某些种情会产生很多空连接不能释放,Hibernate3.0已经放弃了对其的支持。

  Proxool的负面评价较少,现在比较推荐它,而且它还提供即时监控连接池状态的功能,便于发现连接泄漏的情况。

  配置如下:

  1、在spring配置文件中,一般在applicationContext.xml中

  <bean id="DataSource" class="org.logicalcobwebs.proxool.ProxoolDataSource" destroy-method="shutdown">

  <property name="driver">

  <value>oracle.jdbc.driver.OracleDriver</value>

  </property>

  <property name="driverUrl">

  <value>jdbc:oracle:thin:xxxx/xxxx@192.168.0.XX:1521:server</value>

  </property>

  <property name="user">

  <value>xxxx</value>

  </property>

  <property name="password">

  <value>xxxx</value>

  </property>

  <property name="alias">

  <value>server</value>

  </property>

  <property name="houseKeepingSleepTime">

  <value>30000</value>

  </property>

  <property name="houseKeepingTestSql">

  <value>select 1 from dual</value>

  </property>

  <property name="testBeforeUse">

  <value>true</value>

  </property>

  <property name="testAfterUse">

  <value>true</value>

  </property>

  <property name="prototypeCount">

  <value>5</value>

  </property>

  <property name="maximumConnectionCount">

  <value>400</value>

  </property>

  <property name="minimumConnectionCount">

  <value>10</value>

  </property>

  <property name="statistics">

  <value>1m,15m,1d</value>

  </property>

  <property name="statisticsLogLevel">

  <value>ERROR</value>

  </property>

  <property name="trace">

  <value>true</value>

  </property>

  <property name="verbose">

  <value>false</value>

  </property>

  <property name="simultaneousBuildThrottle">

  <value>1600</value>

  </property>

  <property name="maximumActiveTime">

  <value>600000</value>

  </property>

  <property name="jmx">

  <value>false</value>

  </property>

  </bean>

  然后注入到sessionFactory中

  <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

  <property name="dataSource" ref="DataSource"/>

  </bean>

  属性列表说明:

  fatal-sql-exception: 它是一个逗号分割的信息片段.当一个SQL异常发生时,他的异常信息将与这个信息片段进行比较.如果在片段中存在,那么这个异常将被认为是个致命错误(Fatal SQL Exception ).这种情况下,数据库连接将要被放弃.无论发生什么,这个异常将会被重掷以提供给消费者.用户最好自己配置一个不同的异常来抛出.

  fatal-sql-exception-wrapper-class:正如上面所说,你最好配置一个不同的异常来重掷.利用这个属性,用户可以包装SQLException,使他变成另外一个异常.这个异常或者继承QLException或者继承字RuntimeException.proxool自带了2个实现:'org.logicalcobwebs.proxool.FatalSQLException'和'org.logicalcobwebs.proxool.FatalRuntimeException'.后者更合适.

  house-keeping-sleep-time: house keeper 保留线程处于睡眠状态的最长时间,house keeper 的职责就是检查各个连接的状态,并判断是否需要销毁或者创建.

  house-keeping-test-sql:  如果发现了空闲的数据库连接.house keeper 将会用这个语句来测试.这个语句最好非常快的被执行.如果没有定义,测试过程将会被忽略。

  injectable-connection-interface: 允许proxool实现被代理的connection对象的方法.

  injectable-statement-interface: 允许proxool实现被代理的Statement 对象方法.

  injectable-prepared-statement-interface: 允许proxool实现被代理的PreparedStatement 对象方法.

  injectable-callable-statement-interface: 允许proxool实现被代理的CallableStatement 对象方法.

  jmx: 如果属性为true,就会注册一个消息Bean到jms服务,消息Bean对象名: "Proxool:type=Pool, name=<alias>". 默认值为false.

  jmx-agent-id: 一个逗号分隔的JMX代理列表(如使用MBeanServerFactory.findMBeanServer(String agentId)注册的连接池。)这个属性是仅当"jmx"属性设置为"true"才有效。所有注册jmx服务器使用这个属性是不确定的

  jndi-name: 数据源的名称

  maximum-active-time: 如果housekeeper 检测到某个线程的活动时间大于这个数值.它将会杀掉这个线程.所以确认一下你的服务器的带宽.然后定一个合适的值.默认是5分钟.

  maximum-connection-count: 最大的数据库连接数.

  maximum-connection-lifetime: 一个线程的最大寿命.

  minimum-connection-count: 最小的数据库连接数

  overload-without-refusal-lifetime: 这可以帮助我们确定连接池的状态。如果我们已经拒绝了一个连接在这个设定值(毫秒),然后被认为是超载。默认为60秒。

  prototype-count: 连接池中可用的连接数量.如果当前的连接池中的连接少于这个数值.新的连接将被建立(假设没有超过最大可用数).例如.我们有3个活动连接2个可用连接,而我们的prototype-count是4,那么数据库连接池将试图建立另外2个连接.这和 minimum-connection-count不同. minimum-connection-count把活动的连接也计算在内.prototype-count 是spare connections 的数量.

  recently-started-threshold: 这可以帮助我们确定连接池的状态,连接数少还是多或超载。只要至少有一个连接已开始在此值(毫秒)内,或者有一些多余的可用连接,那么我们假设连接池是开启的。默认为60秒

  simultaneous-build-throttle: 这是我们可一次建立的最大连接数。那就是新增的连接请求,但还没有可供使用的连接。由于连接可以使用多线程,在有限的时间之间建立联系从而带来可用连接,但是我们需要通过一些方式确认一些线程并不是立即响应连接请求的,默认是10。

  statistics:  连接池使用状况统计。 参数“10s,1m,1d”

  statistics-log-level: 日志统计跟踪类型。 参数“ERROR”或 “INFO”

  test-before-use: 如果为true,在每个连接被测试前都会服务这个连接,如果一个连接失败,那么将被丢弃,另一个连接将会被处理,如果所有连接都失败,一个新的连接将会被建立。否则将会抛出一个SQLException异常。

  test-after-use: 如果为true,在每个连接被测试后都会服务这个连接,使其回到连接池中,如果连接失败,那么将被废弃。

  trace: 如果为true,那么每个被执行的SQL语句将会在执行期被log记录(DEBUG LEVEL).你也可以注册一个ConnectionListener (参看ProxoolFacade)得到这些信息.

  verbose: 详细信息设置。 参数 bool 值

posted @ 2010-07-29 16:03 睫晋姬 阅读(417) | 评论 (0)编辑 收藏

Java中的LookAndFeel

  1、Metal风格 (默认)

  String lookAndFeel = "javax.swing.plaf.metal.MetalLookAndFeel";

  UIManager.setLookAndFeel(lookAndFeel);

  2、Windows风格

  String lookAndFeel = "com.sun.java.swing.plaf.windows.WindowsLookAndFeel";

  UIManager.setLookAndFeel(lookAndFeel);

  3、Windows Classic风格

  String lookAndFeel = "com.sun.java.swing.plaf.windows.WindowsClassicLookAndFeel";

  UIManager.setLookAndFeel(lookAndFeel);

  4、Motif风格

  String lookAndFeel = "com.sun.java.swing.plaf.motif.MotifLookAndFeel";

  UIManager.setLookAndFeel(lookAndFeel);

  5、Mac风格 (需要在相关的操作系统上方可实现)

  String lookAndFeel = "com.sun.java.swing.plaf.mac.MacLookAndFeel";

  UIManager.setLookAndFeel(lookAndFeel);

  6、GTK风格 (需要在相关的操作系统上方可实现)

  String lookAndFeel = "com.sun.java.swing.plaf.gtk.GTKLookAndFeel";

  UIManager.setLookAndFeel(lookAndFeel);

  7、可跨平台的默认风格

  String lookAndFeel = UIManager.getCrossPlatformLookAndFeelClassName();

  UIManager.setLookAndFeel(lookAndFeel);

  8、当前系统的风格

  String lookAndFeel = UIManager.getSystemLookAndFeelClassName();

  UIManager.setLookAndFeel(lookAndFeel);

  在Java中让用户能够动态地更改应用的外观,可以给用户更好地体验,具体的实现方式是:

  1,先使用UIManager.setLookAndFeel(String s)方法设定对应的外观

  2,再使用SwingUtilities.updateComponentTreeUI(Component c)方法立刻更新应用的外观

  这两个类均在javax.swing包中
相关文章博客:睫晋姬 睫晋姬 睫晋姬 睫晋姬 睫晋姬 睫晋姬 睫晋姬 睫晋姬

posted @ 2010-07-29 16:00 睫晋姬 阅读(154) | 评论 (0)编辑 收藏

Java多线程支持如何才能解决接口问题

  Java多线程支持需要我们不断的进行相关问题的解决,下面我们就来看看在接口问题上的相关问题解决方案,这样才能更好的进行不断的干洗机创新和学习。希望大家有所了解。

  Java多线程支持,所有实现Runnable接口的类都可被启动一个新线程,新线程会执行该实例的run()方法,当run()方法执行完毕后,线程就结束了。一旦一个线程执行完毕,这个实例就不能再重新启动,只能重新生成一个新实例,再启动一个新线程。

  Thread类是实现了Runnable接口的一个实例,它代表一个线程的实例,并且,启动线程的唯一方法就是通过Thread类的start()实例方法:

  1.Thread t = new Thread();

  2.t.start();

  start()方法是一个native方法,它将启动一个新线程,并执行run()方法。Thread类默认的run()方法什么也不做就退出了。注意:直接调用run()方法并不会启动一个新线程,它和调用一个普通的java多线程支持方法没有什么区别。

  因此,有两个方法可以实现自己的线程:

  方法1:自己的类extend Thread,并复写run()方法,就可以启动新线程并执行自己定义的run()方法。例如:

  3.public class MyThread extends Thread {

  4.public run() {

  5.System.out.println("MyThread.run()");

  6.}

  7.}

  在合适的地方启动线程:new MyThread().start();

  方法2:如果自己的类已经extends另一个类,就无法直接extends Thread,此时,必须实现一个Runnable接口:

  8.public class MyThread extends OtherClass implements Runnable {

  9.public run() {

  10.System.out.println("MyThread.run()");

  11.}

  12.}

  为了启动MyThread,需要首先实例化一个Thread,并传入自己的MyThread实例:

  13.MyThread myt = new MyThread();

  14.Thread t = new Thread(myt);

  15.t.start();

  事实上,当传入一个Runnable target参数给Thread后,Thread的run()方法就会调用target.run(),参考JDK源代码:

  16.public void run() {

  17.if (target != null) {

  18.target.run();

  19.}

  20.}

  Java多线程支持还有一些Name, ThreadGroup, isDaemon等设置,由于和线程设计模式关联很少,这里就不多说了。

posted @ 2010-07-29 15:59 睫晋姬 阅读(207) | 评论 (0)编辑 收藏

多线程开发的捷径:构建Java并发模型框架

  Java多线程特性为构建高性能的应用提供了极大的方便,但是也带来了不少的麻烦。线程间同步、数据一致性等烦琐的问题需要细心的考虑,一不小心就会出现一些微妙的,难以调试的错误。

  另外,应用逻辑和线程逻辑纠缠在一起,会导致程序的逻辑结构混乱,难以复用和维护。本文试图给出一个解决这个问题的方案,通过构建一个并发模型框架(framework),使得开发多线程的应用变得容易。

  基础知识

  Java语言提供了对于线程很好的支持,实现方法小巧、优雅。对于方法重入的保护,信号量(semaphore)和临界区(critical section)机制的实现都非常简洁。可以很容易的实现多线程间的同步操作从而保护关键数据的一致性。这些特点使得Java成为面向对象语言中对于多线程特性支持方面的佼佼者(C++正在试图把boost库中的对于线程的支持部分纳入语言标准)。

  Java中内置了对于对象并发访问的支持,每一个对象都有一个监视器(monitor),同时只允许一个线程持有监视器从而进行对对象的访问,那些没有获得监视器的线程必须等待直到持有监视器的线程释放监视器。对象通过synchronized关键字来声明线程必须获得监视器才能进行对自己的访问。

  synchronized声明仅仅对于一些较为简单的线程间同步问题比较有效,对于哪些复杂的同步问题,比如带有条件的同步问题,Java提供了另外的解决方法,wait/notify/notifyAll。

  获得对象监视器的线程可以通过调用该对象的wait方法主动释放监视器,等待在该对象的线程等待队列上,此时其他线程可以得到中频点焊机监视器从而访问该对象,之后可以通过调用notify/notifyAll方法来唤醒先前因调用wait方法而等待的线程。

  一般情况下,对于wait/notify/notifyAll方法的调用都是根据一定的条件来进行的,比如:经典的生产者/消费者问题中对于队列空、满的判断。熟悉POSIX的读者会发现,使用wait/notify/notifyAll可以很容易的实现POSIX中的一个线程间的高级同步技术:条件变量。

  简单例子

  本文将围绕一个简单的例子展开论述,这样可以更容易突出我们解决问题的思路、方法。本文想向读者展现的正是这些思路、方法。这些思路、方法更加适用于解决大规模、复杂应用中的并发问题。考虑一个简单的例子,我们有一个服务提供者,它通过一个接口对外提供服务,服务内容非常简单,就是在标准输出上打印Hello World。类结构图如下:

类结构图

  代码如下:

  1.interface Service

  2.{

  3.    public void sayHello();

  4.}

  5.class ServiceImp implements Service

  6.{

  7.    public void sayHello() {

  8.        System.out.println("Hello World!");

  9.    }

  10.}

  11.class Client

  12.{

  13.    public Client(Service s) {

  14.        _service = s;

  15.}

  16.    public void requestService() {

  17.        _service.sayHello();

  18.    }

  19.    private Service _service;

  20.}

  如果现在有新的需求,要求该服务必须支持Client的并发访问。一种简单的方法就是在ServicImp类中的每个方法前面加上synchronized声明,来保证自己内部数据的一致性(当然对于本例来说,目前是没有必要的,因为ServiceImp没有需要保护的数据,但是随着需求的变化,以后可能会有的)。但是这样做至少会存在以下几个问题:

  1.现在要维护ServiceImp的两个版本:多线程版本和单线程版本(有些地方,比如其他项目,可能没有并发的问题),容易带来点凸焊机同步更新和正确选择版本的问题,给维护带来麻烦。

  2.如果多个并发的Client频繁调用该服务,由于是直接同步调用,会造成Client阻塞,降低服务质量。

  3.很难进行一些灵活的控制,比如:根据Client的优先级进行排队等等。

  4.这些问题对于大型的多线程应用服务器尤为突出,对于一些简单的应用(如本文中的例子)可能根本不用考虑。本文正是要讨论这些问题的解决方案,文中的简单的例子只是提供了一个说明问题,展示思路、方法的平台。

  5.如何才能较好的解决这些问题,有没有一个可以重用的解决方案呢?让我们先把这些问题放一放,先来谈谈和框架有关的一些问题。

  框架概述

  熟悉面向对象的读者一定知道面向对象的最大的优势之一就是:软件复用。通过复用,可以减少很多的工作量,提高软件开发生产率。复用本身也是分层次的,代码级的复用和设计架构的复用。

  大家可能非常熟悉C语言中的一些标准库,它们提供了一些通用的功能让你的程序使用。但是这些标准库并不能影响你的程序结构和设计思路,仅仅是提供一些机能,帮助你的程序完成工作。它们使你不必重头编写一般性的通用功能(比如printf),它们强调的是程序代码本身的复用性,而不是设计架构的复用性。

  那么什么是框架呢?所谓框架,它不同于一般的标准库,是指一组紧密关联的(类)classes,强调彼此的配合以完成某种可以重复运用的设计概念。这些类之间以特定的方式合作,彼此不可或缺。它们相当程度的影响了你的程序的形貌。框架本身规划了应用程序的骨干,让程序遵循一定的流程和动线,展现一定的风貌和功能。这样就使程序员不必费力于通用性的功能的繁文缛节,集中精力于专业领域。

  有一点必须要强调,放之四海而皆准的框架是不存在的,也是最没有用处的。框架往往都是针对某个特定应用领域的,是在对这个应用领域进行深刻理解的基础上,抽象出该应用的概念模型,在这些抽象的概念上搭建的一个模型,是一个有形无体的框架。不同的具体应用根据自身的特点对框架中的抽象概念进行实现,从而赋予框架生命,完成应用的功能。

  基于框架的应用都有两部分构成:框架部分和特定应用部分。要想达到框架复用的目标,必须要做到框架部分和特定应用部分的隔离。使用面向对象的一个强大功能:多态,可以实现这一点。在框架中完成抽象概念之间的交互、关联,把具体的实现交给特定的应用来完成。其中一般都会大量使用了Template Method设计模式。Java中的Collection Framework以及微软的MFC都是框架方面很好的例子。有兴趣的读者可以自行研究。

 

  构建框架

  如何构建一个Java并发模型框架呢?让我们先回到原来的问题,先来分析一下原因。造成要维护多线程和单线程两个版本的原因是由于把应用逻辑和并发逻辑混在一起,如果能够做到把应用逻辑和并发模型进行很好的隔离,那么应用逻辑本身就可以很好的被复用,而且也很容易把并发逻辑添加进来而不会对应用逻辑造成任何影响。造成Client阻塞,性能降低以及无法进行额外的控制的原因是由于所有的服务调用都是同步的,解决方案很简单,改为异步调用方式,把服务的调用和服务的执行分离。

  首先来介绍一个概念,活动对象(Active Object)。所谓活动对象是相对于被动对象(passive object)而言的,被动对象的方法的调用和执行都是在同一个线程中的,被动对象方法的调用是同步的、阻塞的,一般的对象都属于被动对象;主动对象的方法的调用和执行是分离的,主动对象有自己独立的执行线程,主动对象的上海保洁公司方法的调用是由其他线程发起的,但是方法是在自己的线程中执行的,主动对象方法的调用是异步的,非阻塞的。

  本框架的核心就是使用主动对象来封装并发逻辑,然后把Client的请求转发给实际的服务提供者(应用逻辑),这样无论是Client还是实际的服务提供者都不用关心并发的存在,不用考虑并发所带来的数据一致性问题。从而实现应用逻辑和并发逻辑的隔离,服务调用和服务执行的隔离。下面给出关键的实现细节。

  本框架有如下几部分构成:

  1.一个ActiveObject类,从Thread继承,封装了并发逻辑的活动对象;

  2.一个ActiveQueue类,主要用来存放调用者请求;

  3.一个MethodRequest接口,主要用来封装调用者的请求,Command设计模式的一种实现方式。它们的一个简单的实现如下:

  1. //MethodRequest接口定义

  2.  interface MethodRequest

  3.{

  4.    public void call();

  5.}

  6.//ActiveQueue定义,其实就是一个producer/consumer队列

  7.    class ActiveQueue

  8.{

  9.      public ActiveQueue() {

  10.        _queue = new Stack();

  11.      }

  12.    public synchronized void enqueue(MethodRequest mr) {

  13.        while(_queue.size() > QUEUE_SIZE) {

  14.            try {

  15.                   wait();

  16.            }catch (InterruptedException e) {

  17.                   e.printStackTrace();

  18.            }

  19.        }

  20.

  21.        _queue.push(mr);

  22.        notifyAll();

  23.        System.out.println("Leave Queue");

  24.    }

  25.    public synchronized MethodRequest dequeue() {

  26.        MethodRequest mr;

  27.

  28.        while(_queue.empty()) {

  29.            try {

  30.                wait();

  31.            }catch (InterruptedException e) {

  32.                e.printStackTrace();

  33.            }

  34.        }

  35.        mr = (MethodRequest)_queue.pop();

  36.        notifyAll();

  37.

  38. return mr;

  39.    }

  40.    private Stack _queue;

  41.    private final static int QUEUE_SIZE = 20;

  42.}

  43.//ActiveObject的定义

  44.class ActiveObject extends Thread

  45.{

  46.    public ActiveObject() {

  47.        _queue = new ActiveQueue();

  48.        start();

  49.    }

  50.    public void enqueue(MethodRequest mr) {

  51.        _queue.enqueue(mr);

  52.    }

  53.    public void run() {

  54.        while(true) {

  55.            MethodRequest mr = _queue.dequeue();

  56.            mr.call();

  57.        }

  58.    }

  59.    private ActiveQueue _queue;

  60.}

  通过上面的代码可以看出正是这些类相互合作完成了对并发逻辑的封装。开发者只需要根据需要实现MethodRequest接口,另外再定义一个服务代理类提供给使用者,在服务代理者类中把服务调用者的请求转化为MethodRequest实现,交给活动对象即可。

  使用该框架,可以较好的做到应用逻辑和并发模型的分离,从而使开发者集中精力于应用领域,然后平滑的和并发模型结合起来,并且可以针对ActiveQueue定制排队机制,比如基于优先级等。

 

  基于框架的解决方案

  本小节将使用上述的框架重新实现前面的例子,提供对于并发的支持。第一步先完成对于MethodRequest的实现,对于我们的例子来说实现如下:

  1.class SayHello implements MethodRequest

  2.{

  3.    public SayHello(Service s) {

  4.        _service = s;

  5.    }

  6.    public void call() {

  7.        _service.sayHello();

  8.    }

  9.    private Service _service;

  10.}

  该类完成了对于服务提供接口sayHello方法的封装。接下来定义一个服务代理类,来完成请求的封装、排队功能,当然为了做到对Client透明,该类必须实现Service接口。定义如下:

  11.class ServiceProxy implements Service

  12.{

  13.    public ServiceProxy() {

  14.        _service = new ServiceImp();

  15.        _active_object = new ActiveObject();

  16.    }

  17.

  18.    public void sayHello() {

  19.        MethodRequest mr = new SayHello(_service);

  20.        _active_object.enqueue(mr);

  21.    }

  22.    private Service _service;

  23.    private ActiveObject _active_object;

  24.}

  其他的类和接口定义不变,下面对比一下并发逻辑增加前后的服务调用的变化,并发逻辑增加前,对于sayHello服务的调用方法:

  25.Service s = new ServiceImp();

  26.Client c = new Client(s);

  27.c.requestService();

  并发逻辑增加后,对于sayHello服务的调用方法:

  28.Service s = new  ServiceProxy();

  29.Client c = new Client(s);

  30.c.requestService();

  可以看出并发逻辑增加前后对于Client的ServiceImp都无需作任何改变,使用方式也非常一致,ServiceImp也能够独立的进行重用。类结构图如下:

类结构图

  读者容易看出,使用框架也增加了一些复杂性,对于一些简单的应用来说可能根本就没有必要使用本框架。希望读者能够根据自己的实际情况进行判断。

  结论

  本文围绕一个简单的例子论述了如何构架一个Java并发模型框架,其中使用了一些构建框架的常用技术,当然所构建的框架和一些成熟的商用框架相比,显得非常稚嫩,比如没有考虑服务调用有返回值的情况,但是其思想方法是一致的,希望读者能够深加领会,这样无论对于构建自己的框架还是理解一些其他的框架都是很有帮助的。读者可以对本文中的框架进行扩充,直接应用到自己的工作中。

  优点:

  1.增强了应用的并发性,简化了同步控制的复杂性;

  2.服务的请求和服务的执行分离,使得可以对服务请求排队,进行灵活的控制;

  3.应用逻辑和并发模型分离,使得程序结构清晰,易于维护、重用;

  4.可以使开发者集中精力于应用领域。

  缺点:

  1.由于框架所需类的存在,在一定程度上增加了程序的复杂性;

  2.如果应用需要过多的活动对象,由于线程切换开销会造成性能下降;

  3.可能会造成调试困难。

posted @ 2010-07-29 15:55 睫晋姬 阅读(165) | 评论 (0)编辑 收藏

Java多线程程序设计初步

  在Java语言产生前,传统的程序设计语言的程序同一时刻只能单任务操作,效率非常低,例如程序往往在接收数据输入时发生阻塞,只有等到程序获得数据后才能继续运行。随着Internet的迅猛发展,这种状况越来越不能让人们忍受:如果网络接收热合机数据阻塞,后台程序就处于等待状态而不继续任何操作,而这种阻塞是经常会碰到的,此时CPU资源被白白的闲置起来。如果在后台程序中能够同时处理多个任务,该多好啊!应Internet技术而生的Java语言解决了这个问题,多线程程序是Java语言的一个很重要的特点。在一个Java程序中,我们可以同时并行运行多个相对独立的线程,例如,我们如果创建一个线程来进行数据输入输出,而创建另一个线程在后台进行其它的数据处理,如果输入输出线程在接收数据时阻塞,而处理数据的线程仍然在运行。多线程程序设计大大提高了程序执行效率和处理能力。

   线程的创建

  我们知道Java是面向对象的程序语言,用Java进行程序设计就是设计和使用类,Java为我们提供了线程类Thread来创建线程,创建线程与创建普通的类的对象的操作是一样的,而线程就是Thread类或其子类的实例对象。下面是一个创建启动一个线程的语句:

  Thread thread1=new Thread(); file://声明一个对象实例,即创建一个线程;

  Thread1.run(); file://用Thread类中的run()方法启动线程;

  从这个例子,我们可以通过Thread()构造方法创建一个线程,并启动该线程。事实上,启动线程,也就是启动线程的run()方法,而Thread类中的run()方法没有任何操作语句,所以这个线程没有任何操作。要使线程实现预定功能,必须定义自己的run()方法。Java中通常有两种方式定义 run()方法:

  通过定义一个Thread类的子类,在该子类中重写run()方法。Thread子类的实例对象就是一个线程,显然,该线程有我们自己设计的线程体run()方法,启动线程就启动了子类中重写的run()方法。

  通过Runnable接口,在该接口中定义run()方法的接口。所谓接口跟类非常类似,主要用来实现特殊功能,如复杂关系的多重继承功能。在此,我们定义一个实现Runnable() 接口的类,在该类中定义自己的run()方法,然后以该类的实例对象为参数调用Thread类的构造方法来创建一个线程。

  线程被实际创建后处于待命状态,激活(启动)线程就是启动线程的run()方法,这是通过调用线程的start()方法来实现的。

  下面一个例子实践了如何通过上述两种方法创建线程并启动它们:

  // 通过Thread类的子类创建的线程;

    { file://自定义线程的run()方法;

   file://通过Runnable接口创建的另外一个线程;

   { file://自定义线程的run()方法;

   file://程序的主类'

   class Multi_Thread file://声明主类;
     plubic static void mail(String args[]) file://声明主方法;

       thread1 threadone=new thread1(); file://用Thread类的子类创建线程;

       Thread threadtwo=new Thread(new thread2()); file://用Runnable接口类的对象创建线程;

       threadone.start(); threadtwo.start(); file://strat()方法启动线程;


  运行该程序就可以看出,线程threadone和threadtwo交替占用CPU,处于并行运行状态。可以看出,启动线程的run()方法是通过调用线程的start()方法来实现的(见上例中主类),调用start()方法启动线程的run()方法不同于一般的调用方法,调用一般方法时,必须等到一般方法执行完毕才能够返回start()方法,而启动线程的run()方法后,start()告诉系统该线程准备就绪可以启动run()方法后,就返回 start()方法执行调用start()方法语句下面的语句,这时run()方法可能还在运行,这样,线程的启动和运行并行进行,实现了多任务操作。

  线程的优先级

  对于多线程程序,每个线程的重要程度是不尽相同,如多个线程在等待获得CPU时间时,往往我们需要优先级高的线程优先抢占到CPU时间得以执行;又如多个线程交替执行时,优先级决定了级别高的线程得到CPU的次数多一些且时间多长一些;这样,高优先级的线程处理的任务效率就高一些。

  Java中线程的优先级从低到高以整数1~10表示,共分为10级,设置优先级是通过调用线程对象的setPriority()方法,如上例中,设置优先级的语句为:

  thread1 threadone=new thread1(); file://用Thread类的子类创建线程;

  Thread threadtwo=new Thread(new thread2()); file://用Runnable接口类的对象创建线程;

  threadone.setPriority(6); file://设置threadone的优先级6;

  threadtwo.setPriority(3); file://设置threadtwo的优先级3;

  threadone.start(); threadtwo.start(); file://strat()方法启动线程;

  这样,线程threadone将会优先于线程threadtwo执行,并将占有更多的CPU时间。该例中,优先级设置放在线程启动前,也可以在启动后进行设置,以满足不同的优先级需求。
 线程的(同步)控制

  一个Java程序的多线程之间可以共享数据。当线程以异步方式访问共享数据时,有时候是不安全的或者不和逻辑的。比如,同一时刻一个线程在读取数据,另外一个线程在处理数据,当处理数据的线程没有等到读取收缩机数据的线程读取完毕就去处理数据,必然得到错误的处理结果。这和我们前面提到的读取数据和处理数据并行多任务并不矛盾,这儿指的是处理数据的线程不能处理当前还没有读取结束的数据,但是可以处理其它的数据。

  如果我们采用多线程同步控制机制,等到第一个线程读取完数据,第二个线程才能处理该数据,就会避免错误。可见,线程同步是多线程编程的一个相当重要的技术。

  在讲线程的同步控制前我们需要交代如下概念:

  1 用Java关键字synchonized同步对共享数据操作的方法

  在一个对象中,用synchonized声明的方法为同步方法。Java中有一个同步模型-监视器,负责管理线程对对象中的同步方法的访问,它的原理是:赋予该对象唯一一把'钥匙',当多个线程进入对象,只有取得该对象钥匙的线程才可以访问同步方法,其它线程在该对象中等待,直到该线程用wait() 方法放弃这把钥匙,其它等待的线程抢占该钥匙,抢占到钥匙的线程后才可得以执行,而没有取得钥匙的线程仍被阻塞在该对象中等待。

  file://声明同步的一种方式:将方法声明同步

  class store

  public synchonized void store_in()

  public synchonized void store_out(){

  2 利用wait()、notify()及notifyAll()方法发送消息实现线程间的相互联系

  Java程序中多个线程通过消息来实现互动联系的,这几种方法实现了线程间的消息发送。例如定义一个对象的synchonized 方法,同一时刻只能够有一个线程访问该对象中的同步方法,其它线程被阻塞。通常可以用notify()或notifyAll()方法唤醒其它一个或所有线程。而使用wait()方法来使该线程处于阻塞状态,等待其它的线程用notify()唤醒。

  一个实际的例子就是生产和销售,生产单元将产品生产出来放在仓库中,销售单元则从仓库中提走产品,在这个过程中,销售单元必须在仓库中有产品时才能提货;如果仓库中没有产品,则销售单元必须等待。

  程序中,假如我们定义一个仓库类store,该类的实例对象就相当于仓库,在store类中定义两个成员方法:store_in(),用来模拟产品制造者往仓库中添加产品;strore_out()方法则用来模拟销售者从仓库中取走产品。然后定义两个线程类:customer类,其中的run()方法通过调用仓库类中的store_out()从仓库中取走产品,模拟销售者;另外一个线程类producer中的run()方法通过调用仓库类中的 store_in()方法向仓库添加产品,模拟产品制造者。在主类中创建并启动线程,实现向仓库中添加产品或取走产品。

  如果仓库类中的store_in() 和store_out()方法不声明同步,这就是个一般的多线程,我们知道,一个程序中的多线程是交替执行的,运行也是无序的,这样,就可能存在这样的问题:

  仓库中没有产品了,销售者还在不断光顾,而且还不停的在'取'产品,这在现实中是不可思义的,在程序中就表现为负值;如果将仓库类中的stroe_in ()和store_out()方法声明同步,如上例所示:就控制了同一时刻只能有一个线程访问仓库对象中的同步方法;即一个生产类线程访问被声明为同步的 store_in()方法时,其它线程将不能够访问对象中的store_out()同步方法,当然也不能访问store_in()方法。必须等到该线程调用wait()方法放弃钥匙,其它线程才有机会访问同步方法。

posted @ 2010-07-29 15:50 睫晋姬 阅读(136) | 评论 (0)编辑 收藏

Java List遍历方法及其效率对比

  Java代码

  1.package com.zbalpha.test;

  2.

  3.import java.util.ArrayList;

  4.import java.util.Iterator;

  5.import java.util.List;

  6.

  7.public class ListTest {

  8.    public static void main(String args[]){

  9.        List<Long> lists = new ArrayList<Long>();

  10.

  11.        for(Long i=0l;i<1000000l;i++){

  12.            lists.add(i);

  13.        }

  14.

  15.        Long oneOk = oneMethod(lists);

  16.        Long twoOk = twoMethod(lists);

  17.        Long threeOk = threeMethod(lists);

  18.        Long fourOk = fourMethod(lists);

  19.

  20.        System.out.println("One:" + oneOk);

  21.        System.out.println("Two:" + twoOk);

  22.        System.out.println("Three:" + threeOk);

  23.        System.out.println("four:" + fourOk);

  24.

  25.    }

  26.

  27.    public static Long oneMethod(List<Long> lists){

  28.

  29.        Long timeStart = System.currentTimeMillis();

  30.        for(int i=0;i<lists.size();i++)    {

  31.            System.out.println(lists.get(i));

  32.        }

  33.        Long timeStop = System.currentTimeMillis();

  34.

  35.        return timeStop -timeStart ;

  36.    }

  37.

  38.    public static Long twoMethod(List<Long> lists){

  39.

  40.        Long timeStart = System.currentTimeMillis();

  41.        for(Long string : lists)    {

  42.            System.out.println(string);

  43.        }

  44.        Long timeStop = System.currentTimeMillis();

  45.

  46.        return timeStop -timeStart ;

  47.    }

  48.

  49.    public static Long threeMethod(List<Long> lists){

  50.

  51.        Long timeStart = System.currentTimeMillis();

  52.        Iterator<Long> it = lists.iterator();

  53.        while (it.hasNext())

  54.        {

  55.                System.out.println(it.next());

  56.        }

  57.        Long timeStop = System.currentTimeMillis();

  58.

  59.        return timeStop -timeStart ;

  60.    }

  61.

  62.

  63.

  64.    public static Long fourMethod(List<Long> lists){

  65.

  66.        Long timeStart = System.currentTimeMillis();

  67.        for(Iterator<Long> i = lists.iterator(); i.hasNext();)    {

  68.            System.out.println(i.next());

  69.        }

  70.        Long timeStop = System.currentTimeMillis();

  71.

  72.        return timeStop -timeStart ;

  73.    }

  74.}

  容器类可以大大提高编程效率和编程能力,在Java2中,所有的容器都由SUN公司的Joshua Bloch进行了重新设计,丰富了容器类库的功能。

  Java2容器类类库的用途是“保存对象”,它分为两类:

  Collection----一组独立的元素,通常这些元素都服从某种规则。List必须保持元素特定的顺序,而Set不能有重复元素。

  Map----一组成对的“键值对”对象,即其元素是成对的对象,最典型的应用就是数据字典,并且还有其它广泛的应用。另外,Map可以返回其所有键丰胸组成的Set和其所有值组成的Collection,或其键值对组成的Set,并且还可以像数组一样扩展多维Map,只要让Map中键值对的每个 “值”是一个Map即可。

  1.迭代器

  迭代器是一种设计模式,它是一个对象,它可以遍历并选择序列中的对象,而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象,因为创建它的代价小。

  Java中的Iterator功能比较简单,并且只能单向移动:

  (1) 使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时,它返回序列的第一个元素。

  (2) 使用next()获得序列中的下一个元素。

  (3) 使用hasNext()检查序列中是否还有元素。

  (4) 使用remove()将迭代器新返回的元素删除。

  Iterator是Java迭代器最简单的实现,为List设计的ListIterator具有更多的功能,它可以从两个方向遍历List,也可以从List中插入和删除元素。

  2.List的功能方法

  List(interface): 次序是List最重要的特点;它确保维护元素特定的顺序。List为Collection添加了许多方法,使得能够向List中间插入与移除元素(只推荐 LinkedList使用)。一个List可以生成ListIterator,使用它可以从两个方向遍历List,也可以从List中间插入和删除元素。

  ArrayList: 由数组实现的List。它允许对元素进行快速随机访问,但是向List中间插入与移除元素的速度很慢。ListIterator只应该用来由后向前遍历ArrayList,而不是用来插入和删除元素,因为这比LinkedList开销要大很多。

  LinkedList: 对顺序访问进行了优化,向List中间插入与删除得开销不大,随机访问则相对较慢(可用ArrayList代替)。它具有方法addFirst()、 addLast()、getFirst()、getLast()、removeFirst()、removeLast(),这些方法(没有在任何接口或基类中定义过)使得LinkedList可以当作堆栈、队列和双向队列使用。

  3.Set的功能方法

  Set(interface): 存入Set的每个元素必须是唯一的,因为Set不保存重复元素。加入Set的Object必须定义equals()方法以确保对象的唯一性。Set与Collection有完全一样的接口。Set接口不保证维护元素的次序。

  HashSet: 为快速查找而设计的Set。存入HashSet的对象必须定义hashCode()。

  TreeSet: 保持次序的Set,底层为树结构。使用它可以从Set中提取有序的序列。

  LinkedHashSet: 具有HashSet的查询速度,且内部使用链表维护元素的顺序(插入的次序)。于是在使用迭代器遍历Set时,结果会按元素插入的次序显示。

  HashSet采用散列函数对元素进行排序,这是专门为快速查询而设计的;TreeSet采用红黑树的数据结构进行排序元素;LinkedHashSet内部使用散列以加快查询速度,同时使用链表维护元素的次序,使得看起来元素是以插入的顺序保存的。需要注意的是,生成自己的类时,Set需要维护元素的存储顺序,因此要实现Comparable接口并定义compareTo()方法。

posted @ 2010-07-29 15:37 睫晋姬 阅读(11342) | 评论 (1)编辑 收藏

Java中synchronized用法

  在java编程思想中对synchronized的一点解释:

  1、synchronized关键字的作用域有二种:

  1)是某个对象实例内,synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法(如果一个对象有多个synchronized方法,只要一个线程访问了其中的一个synchronized方法,其它线程不能同时访问这个对象中任何一个synchronized方法)。这时,不同的对象实例的synchronized方法是不相干扰的。也就是说,其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法;

  2)是某个类的范围,synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。

  2、除了方法前用synchronized关键字,synchronized关键字还可以用于方法中的某个区块中,表示只对这个区块的资源实行互斥访问。用法是: synchronized(this){/*区块*/},它的作用域是当前对象;

  3、synchronized关键字是不能继承的,也就是说,基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){},而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法;

  ----------------------------------------------------------------------------

  java里面synchronized用法

  synchronized的一个简单例子

  public class TextThread

  {

  /**

  * @param args

  */

  public static void main(String[] args)

  {

  // TODO 自动生成方法存根

  TxtThread tt = new TxtThread();

  new Thread(tt).start();

  new Thread(tt).start();

  new Thread(tt).start();

  new Thread(tt).start();

  }

  }

  class TxtThread implements Runnable

  {

  int num = 100;

  String str = new String();

  public void run()

  {

  while (true)

  {

  synchronized(str)

  {

  if (num>0)

  {

  try

  {

  Thread.sleep(10);

  }

  catch(Exception e)

  {

  e.getMessage();

  }

  System.out.println(Thread.currentThread().getName()+ "this is "+ num--);

  }

  }

  }

  }

  }

  上面的例子中为了制造一个时间差,也就是出错的机会,使用了Thread.sleep(10)

  Java对多线程的支持与卫星电视同步机制深受大家的喜爱,似乎看起来使用了synchronized关键字就可以轻松地解决多线程共享数据同步问题。到底如何?――还得对synchronized关键字的作用进行深入了解才可定论。

  总的说来,synchronized关键字可以作为函数的修饰符,也可作为函数内的语句,也就是平时说的同步方法和同步语句块。如果再细的分类,synchronized可作用于instance变量、object reference(对象引用)、static函数和class literals(类名称字面常量)身上。

  在进一步阐述之前,我们需要明确几点:

  A.无论synchronized关键字加在方法上还是对象上,它取得的锁都是对象,而不是把一段代码或函数当作锁――而且同步方法很可能还会被其他线程的对象访问。

  B.每个对象只有一个锁(lock)与之相关联。

  C.实现同步是要很大的系统开销作为代价的,甚至可能造成死锁,所以尽量避免无谓的同步控制。

  接着来讨论synchronized用到不同地方对代码产生的影响:

  假设P1、P2是同一个类的不同对象,这个类中定义了以下几种情况的同步块或同步方法,P1、P2就都可以调用它们。

  1.  把synchronized当作函数修饰符时,示例代码如下:

  Public synchronized void methodAAA()

  {

  //….

  }

  这也就是同步方法,那这时synchronized锁定的是哪个对象呢?它锁定的是调用这个同步方法对象。也就是说,当一个对象P1在不同的线程中执行这个同步方法时,它们之间会形成互斥,达到同步的效果。但是这个对象所属的Class所产生的另一对象P2却可以任意调用这个被加了synchronized关键字的方法。

  上边的示例代码等同于如下代码:

  public void methodAAA()

  {

  synchronized (this)      //  (1)

  {

  //…..

  }

  }

  (1)处的this指的是什么呢?它指的就是调用这个方法的对象,如P1。可见同步方法实质是将synchronized作用于object reference。――那个拿到了P1对象锁的线程,才可以调用P1的同步方法,而对P2而言,P1这个锁与它毫不相干,程序也可能在这种情形下摆脱同步机制的控制,造成数据混乱:(

  2.同步块,示例代码如下:

  public void method3(SomeObject so)

  {

  synchronized(so)

  {

  //…..

  }

  }

  这时,锁就是so这个对象,谁拿到这个锁谁就可以运行它所控制的那段代码。当有一个明确的对象作为锁时,就可以这样写程序,但当没有明确的对象作为锁,只是想让一段代码同步时,可以创建一个特殊的instance变量(它得是一个对象)来充当锁:

  class Foo implements Runnable

  {

  private byte[] lock = new byte[0];  // 特殊的instance变量

  Public void methodA()

  {

  synchronized(lock) { //… }

  }

  //…..

  }

  注:零长度的byte数组对象创建起来将比任何对象都经济――查看编译后的字节码:生成零长度的byte[]对象只需3条操作码,而Object lock = new Object()则需要7行操作码。

  3.将synchronized作用于static 函数,示例代码如下:

  Class Foo

  {

  public synchronized static void methodAAA()   // 同步的static 函数

  {

  //….

  }

  public void methodBBB()

  {

  synchronized(Foo.class)   //  class literal(类名称字面常量)

  }

  }

  代码中的methodBBB()方法是把class literal作为锁的情况,它和同步的static函数产生的效果是一样的,取得的锁很特别,是当前调用这个方法的卫星电视对象所属的类(Class,而不再是由这个Class产生的某个具体对象了)。

  记得在《Effective Java》一书中看到过将 Foo.class和 P1.getClass()用于作同步锁还不一样,不能用P1.getClass()来达到锁这个Class的目的。P1指的是由Foo类产生的对象。

  可以推断:如果一个类中定义了一个synchronized的static函数A,也定义了一个synchronized 的instance函数B,那么这个类的同一对象Obj在多线程中分别访问A和B两个方法时,不会构成同步,因为它们的锁都不一样。A方法的锁是Obj这个对象,而B的锁是Obj所属的那个Class。

  小结如下:

  搞清楚synchronized锁定的是哪个对象,就能帮助我们设计更安全的多线程程序。

  还有一些技巧可以让我们对共享资源的同步访问更加安全:

  1.  定义private 的instance变量+它的 get方法,而不要定义public/protected的instance变量。如果将变量定义为public,对象在外界可以绕过同步方法的控制而直接取得它,并改动它。这也是JavaBean的标准实现方式之一。

  2.  如果instance变量是一个对象,如数组或ArrayList什么的,那上述方法仍然不安全,因为当外界对象通过get方法拿到这个instance对象的引用后,又将其指向另一个对象,那么这个private变量也就变了,岂不是很危险。 这个时候就需要将get方法也加上synchronized同步,并且,只返回这个private对象的clone()――这样,调用端得到的就是对象副本的引用了。

posted @ 2010-07-29 15:31 睫晋姬 阅读(121) | 评论 (0)编辑 收藏

JDK 5.0中的泛型类型学习

  JDK 5.0 中增加的泛型类型,是 Java 语言中类型安全的一次重要改进。但是,对于初次使用泛型类型的用户来说,泛型的某些方面看起来可能不容易明白,甚至非常奇怪。在本月的“Java 理论和实践”中,Brian Goetz 分析了束缚第一次使用泛型的用户的常见陷阱。您可以通过讨论论坛与作者和其他读者分享您对本文的看法。(也可以单击本文顶端或底端的讨论来访问这个论坛。)

  表面上看起来,无论语法还是应用的环境(比如容器类),泛型类型(或者泛型)都类似于 C++ 中的模板。但是这种相似性仅限于表面,Java 语言中的泛型基本上完全在编译器中实现,由编译器执行类型检查和类型推断,然后生成普通的非泛型的字节码。这种实现技术称为擦除(erasure)(编译器使用泛型类型信息保证类型安全,然后在生成字节码之前将其清除),这项技术有一些奇怪,并且有时会带来一些令人迷惑的后果。虽然范型是 Java 类走向类型安全的一大步,但是在学习使用泛型的过程中几乎肯定会遇到头痛(有时候让人无法忍受)的问题。

  注意:本文假设您对 JDK 5.0 中的范型有基本的了解。

  泛型不是协变的

  虽然将集合看作是数组的抽象会有所帮助,但是数组还有一些集合不具备的特殊性质。Java 语言中的数组是协变的(covariant),也就是说,如果 Integer 扩展了 Number(事实也是如此),那么不仅 Integer 是 Number,而且 Integer[] 也是 Number[],在要求 Number[] 的地方完全可以传递或者赋予 Integer[]。(更正式地说,如果 Number 是 Integer 的超类型,那么 Number[] 也是 Integer[] 的超类型)。您也许认为这一原理同样适用于泛型类型 —— List<Number> 是 List<Integer> 的超类型,那么可以在需要 List<Number> 的地方传递 List<Integer>。不幸的是,情况并非如此。

  不允许这样做有一个很充分的理由:这样做将破坏要提供的类型安全泛型。如果能够将 List<Integer> 赋给 List<Number>。那么下面的代码就允许将非 Integer 的内容放入 List<Integer>:

  List<Integer> li = new ArrayList<Integer nike jordan 2010>();

  List<Number> ln = li; // illegal

  ln.add(new Float(3.1415));

  因为 ln 是 List<Number>,所以向其添加 Float 似乎是完全合法的。但是如果 ln 是 li 的别名,那么这就破坏了蕴含在 li 定义中的类型安全承诺 —— 它是一个整数列表,这就是泛型类型不能协变的原因。

  其他的协变问题

  数组能够协变而泛型不能协变的另一个后果是,不能实例化泛型类型的数组(new List<String>[3] 是不合法的),除非类型参数是一个未绑定的通配符(new List<?>[3] 是合法的)。让我们看看如果允许声明泛型类型数组会造成什么后果:

  List<String>[] lsa = new List<String>[10]; // illegal

  Object[] oa = lsa;  // OK because List<String> is a subtype of Object

  List<Integer> li = new ArrayList<Integer>();

  li.add(new Integer(3));

  oa[0] = li;

  String s = lsa[0].get(0);

  最后一行将抛出 ClassCastException,因为这样将把 List<Integer> 填入本应是 List<String> 的位置。因为数组协变会破坏泛型的类型安全,所以不允许实例化泛型类型的数组(除非类型参数是未绑定的通配符,比如 List<?>)。

  构造延迟

  因为可以擦除功能,所以 List<Integer> 和 List<String> 是同一个类,编译器在编译 List<V> 时只生成一个类(和 C++ 不同)。因此,在编译 List<V> 类时,编译器不知道 V 所表示的类型,所以它就不能像知道类所表示的具体类型那样处理 List<V> 类定义中的类型参数(List<V> 中的 V)。

  因为运行时不能区分 List<String> 和 List<Integer>(运行时都是 List),用泛型类型参数标识类型的变量的构造就成了问题。运行时缺乏类型信息,这给泛型容器类和希望创建保护性副本的泛型类提出了难题。

  比如泛型类 Foo:

  class Foo<T> {

  public void doSomething(T param) { ... }

  }

  在这里可以看到一种模式 —— 与泛型有关的很多问题或者折衷并非来自泛型本身,而是保持和已有代码兼容的要求带来的副作用。

  泛化已有的类

  在转化现有的库类来使用泛型方面没有多少技巧,但与平常的情况相同,向后兼容性不会凭空而来。我已经讨论了两个例子,其中向后兼容性限制了类库的泛化。

  另一种不同的泛化方法可能不存在向后兼容问题,这就是 Collections.toArray nike shox r4(Object[])。传入 toArray() 的数组有两个目的 —— 如果集合足够小,那么可以将其内容直接放在提供的数组中。否则,利用反射(reflection)创建相同类型的新数组来接受结果。如果从头开始重写 Collections 框架,那么很可能传递给 Collections.toArray() 的参数不是一个数组,而是一个类文字:

  interface Collection<E> {

  public T[] toArray(Class<T super E> elementClass);

  }

  因为 Collections 框架作为良好类设计的例子被广泛效仿,但是它的设计受到向后兼容性约束,所以这些地方值得您注意,不要盲目效仿。

  首先,常常被混淆的泛型 Collections API 的一个重要方面是 containsAll()、removeAll() 和 retainAll() 的签名。您可能认为 remove() 和 removeAll() 的签名应该是:

  interface Collection<E> {

  public boolean remove(E e);  // not really

  public void removeAll(Collection<? extends E> c);  // not really

  }

  但实际上却是:

  interface Collection<E> {

  public boolean remove(Object o);

  public void removeAll(Collection<?> c);

  }

  为什么呢?答案同样是因为向后兼容性。x.remove(o) 的接口表明“如果 o 包含在 x 中,则删除它,否则什么也不做。”如果 x 是一个泛型集合,那么 o 不一定与 x 的类型参数兼容。如果 removeAll() 被泛化为只有类型兼容时才能调用(Collection<? extends E>),那么在泛化之前,合法的代码序列就会变得不合法,比如:

  // a collection of Integers

  Collection c = new HashSet();

  // a collection of Objects

  Collection r = new HashSet();

  c.removeAll(r);

  如果上述片段用直观的方法泛化(将 c 设为 Collection<Integer>,r 设为 Collection<Object>),如果 removeAll() 的签名要求其参数为 Collection<? extends E> 而不是 no-op,那么就无法编译上面的代码。泛型类库的一个主要目标就是不打破或者改变已有代码的语义,因此,必须用比从头重新设计泛型所使用类型约束更弱的类型约束来定义 remove()、removeAll()、retainAll() 和 containsAll()。

  在泛型之前设计的类可能阻碍了“显然的”泛型化方法。这种情况下就要像上例这样进行折衷,但是如果从头设计新的泛型类,理解 Java 类库中的哪些东西是向后兼容的结果很有意义,这样可以避免不适当的模仿。

  擦除的实现

  因为泛型基本上都是在 Java 编译器中而不是运行库中实现的,所以在生成字节码的时候,差不多所有关于泛型类型的类型信息都被“擦掉”了。换句话说,编译器生成的代码与您手工编写的不用泛型、检查程序的类型安全后进行强制类型转换所得到的代码基本相同。与 C++ 不同,List<Integer> 和 List<String> 是同一个类(虽然是不同的类型但都是 List<?> 的子类型,与以前的版本相比,在 JDK 5.0 中这是一个更重要的区别)。

  擦除意味着一个类不能同时实现 Comparable<String> 和 Comparable<Number>,因为事实上两者都在同一个接口中,指定同一个 compareTo() 方法。声明 DecimalString 类以便与 String 与 Number 比较似乎是明智的,但对于 Java 编译器来说,这相当于对同一个方法进行了两次声明:

  public class DecimalString implements Comparable fashion cap<Number>, Comparable<String> { ... } // nope

  擦除的另一个后果是,对泛型类型参数是用强制类型转换或者 instanceof 毫无意义。下面的代码完全不会改善代码的类型安全性:

  public <T> T naiveCast(T t, Object o) { return (T) o; }

  编译器仅仅发出一个类型未检查转换警告,因为它不知道这种转换是否安全。naiveCast() 方法实际上根本不作任何转换,T 直接被替换为 Object,与期望的相反,传入的对象被强制转换为 Object。

  擦除也是造成上述构造问题的原因,即不能创建泛型类型的对象,因为编译器不知道要调用什么构造函数。如果泛型类需要构造用泛型类型参数来指定类型的对象,那么构造函数应该接受类文字(Foo.class)并将它们保存起来,以便通过反射创建实例。

  结束语

  泛型是 Java 语言走向类型安全的一大步,但是泛型设施的设计和类库的泛化并非未经过妥协。扩展虚拟机指令集来支持泛型被认为是无法接受的,因为这会为 Java 厂商升级其 JVM 造成难以逾越的障碍。因此采用了可以完全在编译器中实现的擦除方法。类似地,在泛型 Java 类库时,保持向后兼容也为类库的泛化方式设置了很多限制,产生了一些混乱的、令人沮丧的结构(如 Array.newInstance())。这并非泛型本身的问题,而是与语言的演化与兼容有关。但这些也使得泛型学习和应用起来更让人迷惑,更加困难。

posted @ 2010-07-29 15:23 睫晋姬 阅读(125) | 评论 (0)编辑 收藏

2009年12月5日 #

JBoss Web和Tomcat的区别

  在Web2.0的浪潮中,各种页面技术和框架不断涌现,为服务器端的基础架构提出了更高的稳定性和可扩展性的要求。近年来,作为开源中间件的全球领导者,JBoss在J2EE应用服务器领域已成为发展最为迅速的应用服务器。在市场占有率和服务满意度上取得了巨大的成功,丝毫不逊色于其它的非开源竞争对手,如WebSphere、WebLogic、Application Server。JBoss Web的诸多优越性能,正是其广为流行的原因。

  基于Tomcat内核,青胜于蓝

  Tomcat 服务器是一个免费的开放源代码的Web 应用服务器,技术先进、性能稳定,而且免费,因而深受Java 爱好者的喜爱并得到了部分软件开发商的认可。其运行时占用的系统资源小,扩展性好,且支持负载平衡与邮件服务等开发应用系统常用的功能。作为一个小型的轻量级应用服务器,Tomcat在中小型系统和并发访问用户不是很多的场合下被普遍使用,成为目前比较流行的Web 应用服务器。

  而JBoss Web采用业界最优的开源Java Web引擎, 将Java社区中下载量最大,用户数最多,标准支持最完备的Tomcat内核作为其Servlet容器引擎,并加以审核和调优。单纯的Tomcat性能有限,在很多地方表现有欠缺,如活动连接支持、静态内容、大文件和HTTPS等。除了性能问题,Tomcat的另一大缺点是它是一个受限的集成平台,仅能运行Java应用程序。企业在使用时Tomcat,往往还需同时部署Apache Web Server以与之整合。此配置较为繁琐,且不能保证性能的优越性。

  JBoss在Tomcat的基础上,对其进行本地化,将Tomcat 以内嵌的方式集成到 JBoss 中。JBoss Web通过使用APR和Tomcat本地技术的混合模型来解决Tomcat的诸多不足。混合技术模型从最新的操作系统技术里提供了最好的线程和事件处理。结果,JBoss Web达到了可扩展性,性能参数匹配甚至超越了本地Apache HTTP服务器或者IIS。譬如JBoss Web能够提供数据库连接池服务,不仅支持 JSP 等 Java 技术,同时还支持其他 Web 技术的集成,譬如 PHP、.NET 两大阵营。

  标准化是减小技术依赖风险,保护投资最好的方式。JBoss Web率先支持全系列JEE Web标准,从根本上保证了应用“一次开发,到处运行”的特点,使应用成品能方便地在JBoss Web和其他Java Web服务器之间轻易迁移。

  集多功能于一身,性能卓越

  作为Web 应用服务器中的明星产品,JBoss Web服务器集多种功能于一身。其关键功能包括:完全支持Java EE、高度的扩展性、快速的静态内容处理、群集、OpenSSL、URL重写和综合性。

  JBoss Web服务器具有原生特性和强大的可扩展性,可支持多种并非基于Java的服务器内容处理技术,可同时运行JSP, Servlet, Microsoft .NET , PHP 及 CGI,为其提供一个单一的、高性能的企业级部署平台。

  与Tomcat 相比,JBoss Web在静态资源访问方面性能优越。JBoss Web支持两种组件模式——纯Java和Native I/O。在Native组件的支持下,动态运行不会受到任何影响,而静态资源的访问利用了操作系统本身提供的0拷贝传送,CPU消耗降低,响应时间缩短,吞吐率大大提高,混合的连接模式支持最大达到10000个并发客户端的同时访问,与Apache Web服务器相当。部署于高性能的操作系统,可利用JBoss Web对纯Java和Native I/O两种模式的支持,使得应用在开发时可随时跨平台敏捷迁移,而部署于高性能的操作系统相关的Native环境。由于JBoss Web较好地解决了静态资源的访问性能问题,可在解决方案中把它直接作为强大的LVS的分发对象,和RHEL负载均衡系统结合,形成理论上无限线性扩展的负载均衡场景。

  OpenSSL是业界最为快速和安全的开源传输组件,可借助操作系统和硬件的特性实现高效的安全承载。JBoss Web集成了OpenSSL,可提供高效的安全传输服务,使得安全机制更上台阶。研究表明, JBoss Web中的SSL性能比单纯的Tomcat快四倍。

  URL重写功能可缩短URL,隐藏实际路径提高安全性,易于用户记忆和键入,及被搜索引擎收录。Tomcat 不具备URL重写功能,JBoss Web则可提供一个灵活的URL rewriting操作引擎,支持无限个规则数和规则条件。URL可被重写以支持遗留的URL错误处理,或应对服务器不时产生的其他问题。

  JBoss Web既可单独运行,也可无缝嵌入JBoss应用服务器,成为JBoss中间件平台的一部分。不仅后台服务调用的性能将得以提升,也可利用以下JBoss平台的特性提升Web应用功能:

  基于JGroups的多种集群方案的支持

  基于Arjuna技术的JTA和JTS的事务处理支持

  优化的线程池和连接池的支持

  基于JMX 控制台的基本管理支持和JBoss On的高级管理维护支持

  基于JBoss AOP技术的面向方面架构的支持

  Hibernate服务组件的支持

  专业团队支持

  业界大多数开源产品在技术方面富于创新性,但在可持续性,产品生命周期规划,以及质量保证方面缺乏有效保障,为软件集成商和最终用户所诟病。红帽所力行的“专业化开源技术”则完美解决了这一问题。

  来自开源社区的JBoss Web,在红帽专业化开源的锤炼下,在性能、扩展性、稳定性、安全性等方面,已成为一个达到企业级,甚至电信级标准的优秀产品。红帽不仅有专职的技术团队投入JBoss Web的开发,而且具备专门的QA团队为产品作质量保证。完善的集成测试和兼容性测试保证了JBoss Web自身的稳定性,并保证了它的后向兼容和其他JBoss产品协作良好的互操作性。

  在服务体系保障方面,JBoss 开拓了以产品专家提供的专家级支持服务作为开源软件强大后盾的软件生态模式。公司以及庞大的 JBoss 授权服务合作伙伴网络可为包括JBoss Web在内的整个JEMS 产品套件提供全面的支持服务。与Tomcat相比,JBoss Web 可提供迁移服务与现场专家服务,在迁移服务方面,专家指导应用可从Tomcat向JBoss Web迁移,省时省力。独特的服务订阅模式,全力保障软件生命周期,让企业高枕无忧。

posted @ 2009-12-05 17:46 睫晋姬 阅读(210) | 评论 (0)编辑 收藏

仅列出标题  下一页