String漫谈

在讨论String之前先看一下并发模式中的不变模式

Immutable设计模式

核心思想

一个对象一旦被创建, 它的内部状态永远不会发生改变, 因此我们在对他进行多线程操作的时候是不需要并发控制的, 因此在多线程环境下可以省略同步和锁等待的时间, 提高系统性能。 不变模式和只读属性并不是同一个东西, 对于只读属性而言只是保证了没有任何第三方线程去修改它的属性, 但是它本身还是有可能变化的, 不变模式要求, 对象创建之后, 其内部状态和数据会保持绝对稳定。

设计方式
  • 去除setter方法
  • 将所有属性设为私有并用final标注, 以确保不能修改
  • 对class定义final确保没有子类可以通过重载修改它的行为。
  • 有一个可以创建完整对象的构造函数。

String

常量池:
  • 常量池简单定义:常量池在java用于保存在编译期已确定的,已编译的class文件中的一份数据。它包括了关于类,方法,接口等中的常量,也包括字符串常量,如String s = "java"这种申明方式。常量池是在堆内存中的一块。
    简单来说就是两个String拥有相同的值时, 他们会复用常量池中的同一份拷贝, 但是如果是new一个String的话, 它还是会在堆里
  • String str1 = new String("abc");
    第一种是用new()来新建对象的,它会在存放于堆中。每调用一次就会创建一个新的对象。运行时期创建
  • String str2 = "abc";
    而第二种是先在栈中创建一个对String类的对象引用变量str2,然后通过符号引用去字符串常量池里找有没有"abc",如果没有,则将"abc"存放进字符串常量池,并令str2指向”abc”,如果已经有”abc” 则直接令str2指向“abc”。编译期间完成
  • intern:
    • 直接使用双引号声明出来的String对象会直接存储在常量池中。
    • 如果不是用双引号声明的String对象,可以使用String提供的intern方法。intern 方法会从字符串常量池中查询当前字符串是否存在,若不存在就会将当前字符串放入常量池中
不变性:
  • char数组
  • offset 偏移
  • count长度
    JDK1.6中
public String substring(int beginIndex, int endIndex) {
  if (beginIndex < 0) {
      throw new StringIndexOutOfBoundsException(beginIndex);
  }
  if (endIndex > count) {
      throw new StringIndexOutOfBoundsException(endIndex);
  }
  if (beginIndex > endIndex) {
      throw new StringIndexOutOfBoundsException(endIndex - beginIndex);
  }
  return ((beginIndex == 0) && (endIndex == count)) ? this :
      new String(offset + beginIndex, endIndex - beginIndex, value);
}
public String substring(int beginIndex, int endIndex) {

String(int offset, int count, char value[]) {
  this.value = value;
  this.offset = offset;
  this.count = count;
}

subString其实是直接复用了数组, 改变了偏移量和长度而已,这样的话就不会真正销毁掉之前的数组, 在JDK1.7之后对此策略进行了改变:

public String(char value[], int offset, int count) {
    if (offset < 0) {
          throw new StringIndexOutOfBoundsException(offset);
    }
    if (count < 0) {
      throw new StringIndexOutOfBoundsException(count);
    }
    // Note: offset or count might be near -1>>>1.
    if (offset > value.length - count) {
      throw new StringIndexOutOfBoundsException(offset + count);
    }
    this.value = Arrays.copyOfRange(value, offset, offset+count);
}

将String的构造函数改成了这样, 也就是根据偏移量等条件重新复制一份。显然这种方式速度会更慢, 所以褒贬不一。 更简单的解决方式其实应该是显示的new String(str.subString(begin, end)), 这样就不会出现内存泄露的问题了。

StringBuilder

String每+一次都会重新复制数组, 为了解决String是不变模式的问题而设计了该类。
它有一个容量参数的概念, 可以根据要存储的大小预先设好, 一开始就初始化一个足够大的数组, 不然的话当数组容量超过时会需要扩容操作, 会用到Arrays.copyOf(value, newCapacity), 其中会有一些消耗, 该类是非线程安全的

StringBuffer

线程安全的

无状态和有状态

String的设计是采用了一种无状态的思路以保证并发。我们可以深入的了解一下这种设计思路

有状态

有状态就是有数据存储功能。有状态对象(Stateful Bean),就是有实例变量的对象,可以保存数据,是非线程安全的。在不同方法调用间不保留任何状态。

  1. /** 
  2.  * 有状态bean,有state,user等属性,并且user有存偖功能,是可变的。 
  3.  *  
  4.  * @author Peter Wei 
  5.  *  
  6.  */  
  7. public class StatefulBean {  
  8.   
  9.     public int state;  
  10.     // 由于多线程环境下,user是引用对象,是非线程安全的  
  11.     public User user;  
  12.   
  13.     public int getState() {  
  14.         return state;  
  15.     }  
  16.   
  17.     public void setState(int state) {  
  18.         this.state = state;  
  19.     }  
  20.   
  21.     public User getUser() {  
  22.         return user;  
  23.     }  
  24.   
  25.     public void setUser(User user) {  
  26.         this.user = user;  
  27.     }  
  28. }  
无状态

无状态就是一次操作,不能保存数据。无状态对象(Stateless Bean),就是没有实例变量的对象.不能保存数据,是不变类,是线程安全的。

单例模式中的有状态和无状态:

单例类可以是有状态的(stateful),一个有状态的单例对象一般也是可变(mutable)单例对象。有状态的可变的单例对象常常当做状态库(repositary)使用。比如一个单例对象TaskCache(Spring中配为singleton)可以持有一个AtomicLong类型的属性,用来给一个系统提供一个数值惟一的序列号码,作为任务通迅管理的ID生成器。同时,一个单例类也可以持有一个聚集,从而允许存储多个状态,如示例中的ExpiringMap缓存任务列表。

  1. import java.util.concurrent.atomic.AtomicLong;  
  2.   
  3. import org.apache.mina.util.ExpiringMap;  
  4.   
  5. /** 
  6.  * Description: 内存中缓存的实时控制端任务列表.示例有状态的单例类 
  7.  *  
  8.  * @author Peter Wei 
  9.  * @version 1.0 Dec 2, 2008 
  10.  */  
  11. public class TaskCache {  
  12.   
  13.     // 请求超时  
  14.     private short requestTimeout;  
  15.   
  16.     // 这个缓存Map是线程安全,并且有定时超时功能  
  17.     private ExpiringMap tasksMap = new ExpiringMap();  
  18.   
  19.     // 线程安全的原子类,示例有状态的单例类  
  20.     private static AtomicLong seqNo = new AtomicLong(1);  
  21.   
  22.     // 示例有状态的单例类  
  23.     public Long nextSeqNo() {  
  24.         return seqNo.getAndIncrement();  
  25.     }  
  26.   
  27.     public void setRequestTimeout(short requestTimeout) {  
  28.         this.requestTimeout = requestTimeout;  
  29.     }  
  30.   
  31.     // 启动过期检测  
  32.     public void startExpiring() {  
  33.         tasksMap.getExpirer().setTimeToLive(requestTimeout);  
  34.         tasksMap.getExpirer().startExpiringIfNotStarted();  
  35.     }  
  36.   
  37.     // 停止过期检测  
  38.     public void stopExpiring() {  
  39.         tasksMap.getExpirer().stopExpiring();  
  40.     }  
  41.   
  42.     // 取任务列表.  
  43.     public Object getTasks(String key) {  
  44.         return tasksMap.get(key);  
  45.     }  
  46.   
  47.     // 去除任务列表.  
  48.     public Object removeTasks(String key) {  
  49.         return tasksMap.remove(key);  
  50.     }  
  51.   
  52.     // 添加任务列表.  
  53.     public void addTasks(String key, Object value) {  
  54.         tasksMap.put(key, value);  
  55.     }  
  56. }  

单例类也可以是没有状态的(stateless),仅用做提供工具性函数的对象。既然是为了提供工具性函数,也就没有必要创建多个实例,因此使用单例模式很合适。平常的单例类都是没有状态的,这里就不示例了。一个没有状态的单例类也就是不变(Immutable)单例类。

Spring中的有状态(Stateful)和无状态(Stateless)

1.通过上面的分析,相信大家已经对有状态和无状态有了一定的理解。无状态的Bean适合用不变模式,技术就是单例模式,这样可以共享实例,提高性能。有状态的Bean,多线程环境下不安全,那么适合用Prototype原型模式。Prototype: 每次对bean的请求都会创建一个新的bean实例。

2.默认情况下,从Spring bean工厂所取得的实例为singleton(scope属性为singleton),容器只存在一个共享的bean实例。

3.理解了两者的关系,那么scope选择的原则就很容易了:有状态的bean都使用prototype作用域,而对无状态的bean则应该使用singleton作用域。

4.如Service层、Dao层用默认singleton就行,虽然Service类也有dao这样的属性,但dao这些类都是没有状态信息的,也就是相当于不变(immutable)类,所以不影响。Struts2中的Action因为会有User、BizEntity这样的实例对象,是有状态信息的,在多线程环境下是不安全的,所以Struts2默认的实现是Prototype模式。在Spring中,Struts2的Action中,scope要配成prototype作用域。

Servlet中的有状态和无状态:

Servlet体系结构是建立在Java多线程机制之上的,它的生命周期是由Web 容器负责的。一个Servlet类在Application中只有一个实例存在,也就是有多个线程在使用这个实例。这是单例模式的应用。无状态的单例是线程安全的,但我们如果在Servlet里用了实例变量,那么就变成有状态了,是非线程安全的。如下面的用法就是不安全的,因为user,out都是有状态信息的。

  1. /** 
  2.  * 非线程安全的Servlet。 
  3.  * @author Peter Wei 
  4.  * 
  5.  */  
  6. public class UnSafeServlet HttpServlet{  
  7.       
  8.     User user;  
  9.     PrintWriter out;  
  10.       
  11.     public void doGet (HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException{  
  12.         //do something...  
  13.     }  
  14. }  

Out,Request,Response,Session,Config,Page,PageContext是线程安全的,Application在整个系统内被使用,所以不是线程安全的

你可能感兴趣的