你的位置:首页 > Java教程

[Java教程]无锁编程:采用不可变类减少锁的使用


 

很多的同学很少使用、或者干脆不了解不可变类(Immutable Class)。直观上很容易认为Immutable类效率不高,或者难以理解他的使用场景。其实不可变类是非常有用的,可以提高并行编程的效率和优化设计。让我们跳过一些宽泛的介绍,从一个常见的并行编程场景说起:

 

假设系统需要实时地处理大量的订单,这些订单的处理依赖于用户的配置,例如用户的会员级别、支付方式等。程序需要通过这些配置的参数来计算订单的价格。而用户配置同时被另外一些线程更新。显然,我们在订单计算的过程中保持配置的一致性。

 

上面的例子是我虚拟出来的,但是类似的场景非常常见--线程A实时地大量地处理请求;线程B偶尔地修改线程A依赖的配置信息。我们陷入这样的两难:

1,为了保持配置的一致性,我们不得不在线程A和线程B上,对配置的读和写都加锁,才能保障配置的一致性。这样才能保证请求处理过程中,不会出现某些配置项被更新了,而另外一些没有;或者处理中开始使用的是旧配置,而后又使用新的配置。(听起来类似于数据库的脏读问题)

2,另一方面,线程A明显比线程B更繁忙,为了偶尔一次的配置更新,为每秒数以万次的请求处理加锁,显然代价太高了。

 

解决方案

解决方案有两种:

第一种是,采用ReadWriteLock。这是最常见的方式。

对读操作加读锁,对写操作加写锁。如果没有正在发生的写操作,读锁的代价很低。

 

第二种是,采用不可变对象来保存配置信息,用替换配置对象的方式,而不是修改配置对象的方式,来更新配置信息。让我们来思考一下这么做的利弊:

1)对于订单处理线程A来说,它不再需要加锁了!因为用于保存配置的对象是不可变对象。我们要么读取的是一个旧的配置对象,要么是一个新的配置对象(新的配置对象覆盖了旧的配置对象)。不会出现“脏读”的情况。

2)对于用于更新配置的线程B,它的负担加重了 -- 更新任何一项配置,都必须重新创建一个新的不可变对象,然后把更新的新的属性和其他旧属性赋给新的对象,最后覆盖旧的对象,被抛弃的旧对象还增加了GC的负担。而原本,这一切只要一个set操作就能完成。

 

我们如何衡量利弊呢?经常,这是非常划算的,线程A和线程B的工作量可能相差几个数量级。用线程B压力的增加(其实不值一提)来换取线程A可以不用锁,效率应该会有很大提升。

 

代码及性能测试

让我们用代码来测试一下哪个解决方案更好。

 

方案一:采用ReentrantReadWriteLock来加读写锁:

一个普通的配置类,保存了用户的优惠信息,包括会员优惠和特殊节日优惠,在计算订单总价的时候用到:

public class AccountConfig {  private double membershipDiscount;  private double specialEventDiscount;    public AccountConfig(double membershipDiscount, double specialEventDiscount)  {    this.membershipDiscount = membershipDiscount;    this.specialEventDiscount = specialEventDiscount;  }  public double getMembershipDiscount() {    return membershipDiscount;  }  public void setMembershipDiscount(double membershipDiscount) {    this.membershipDiscount = membershipDiscount;  }  public double getSpecialEventDiscount() {    return specialEventDiscount;  }  public void setSpecialEventDiscount(double specialEventDiscount) {    this.specialEventDiscount = specialEventDiscount;  }}

 

程序包括2个工作线程,一个负责处理订单,计算订单的总价,它在读取配置信息时采取读锁。另一个负责更新配置信息,采用写锁。

public static void main(String[] args) throws Exception {    final ConcurrentHashMap<String, AccountConfig> accountConfigMap =        new ConcurrentHashMap<String, AccountConfig>();    AccountConfig accountConfig1 = new AccountConfig(0.02, 0.05);    accountConfigMap.put("user1", accountConfig1);    AccountConfig accountConfig2 = new AccountConfig(0.03, 0.04);    accountConfigMap.put("user2", accountConfig2);    final ReadWriteLock lock = new ReentrantReadWriteLock();    ExecutorService executor = Executors.newFixedThreadPool(2);    executor.execute(new Runnable() {      Random r = new Random();      @Override      public void run() {        Long t1 = System.nanoTime();        for (int i = 0; i < 100000000; i++) {          Order order = MockOrder();          lock.readLock().lock();          AccountConfig accountConfig = accountConfigMap.get(order.getUser());          double price = order.getPrice() * order.getCount()               * (1 - accountConfig.getMembershipDiscount())              * (1 - accountConfig.getSpecialEventDiscount());          lock.readLock().unlock();        }        Long t2 = System.nanoTime();        System.out.println("ReadWriteLock:" + (t2 - t1));      }      private Order MockOrder() {        Order order = new Order();        order.setUser("user1");        order.setPrice(r.nextDouble() * 1000);        order.setCount(r.nextInt(10));        return order;      }    });    executor.execute(new Runnable() {      Random r = new Random();      @Override      public void run() {        while (true) {
          lock.writeLock().lock();           AccountConfig accountConfig = accountConfigMap.get("user1");          accountConfig.setMembershipDiscount(r.nextInt(10) / 100.0);          lock.writeLock().unlock();          try {            Thread.sleep(1000);          } catch (InterruptedException e) {            // TODO Auto-generated catch block            e.printStackTrace();          }        }      }    });  }

 

方案二:采用不可变对象:

创建一个不可变的配置类ImmutableAccountConfig:

public final class ImmutableAccountConfig {    private final double membershipDiscount;  private final double specialEventDiscount;    public ImmutableAccountConfig(double membershipDiscount, double specialEventDiscount)  {    this.membershipDiscount = membershipDiscount;    this.specialEventDiscount = specialEventDiscount;  }  public double getMembershipDiscount() {    return membershipDiscount;  }  public double getSpecialEventDiscount() {    return specialEventDiscount;  }}

 

还是创建2个线程。订单线程不必加锁。而配置更新的线程由于采用了不可变类,采用替换对象的方式来更新配置:

public static void main(String[] args) throws Exception {    final ConcurrentHashMap<String, ImmutableAccountConfig> immutableAccountConfigMap     = new ConcurrentHashMap<String, ImmutableAccountConfig>();    ImmutableAccountConfig accountConfig1 = new ImmutableAccountConfig(0.02, 0.05);    immutableAccountConfigMap.put("user1", accountConfig1);    ImmutableAccountConfig accountConfig2 = new ImmutableAccountConfig(0.03, 0.04);    immutableAccountConfigMap.put("user2", accountConfig2);    //final ReadWriteLock lock = new ReentrantReadWriteLock();    ExecutorService executor = Executors.newFixedThreadPool(2);    executor.execute(new Runnable() {      Random r = new Random();      @Override      public void run() {        Long t1 = System.nanoTime();        for (int i = 0; i < 100000000; i++) {          Order order = MockOrder();          ImmutableAccountConfig immutableAccountConfig =               immutableAccountConfigMap.get(order.getUser());          double price = order.getPrice() * order.getCount()              * (1 - immutableAccountConfig.getMembershipDiscount())              * (1 - immutableAccountConfig.getSpecialEventDiscount());        }        Long t2 = System.nanoTime();        System.out.println("Immutable:" + (t2 - t1));      }      private Order MockOrder() {        Order order = new Order();        order.setUser("user1");        order.setPrice(r.nextDouble() * 1000);        order.setCount(r.nextInt(10));        return order;      }    });    executor.execute(new Runnable() {      Random r = new Random();      @Override      public void run() {        while (true) {          //lock.writeLock().lock();          ImmutableAccountConfig oldImmutableAccountConfig =               immutableAccountConfigMap.get("user1");          Double membershipDiscount = r.nextInt(10) / 100.0;          Double specialEventDiscount =               oldImmutableAccountConfig.getSpecialEventDiscount();          ImmutableAccountConfig newImmutableAccountConfig =               new ImmutableAccountConfig(membershipDiscount,              specialEventDiscount);          immutableAccountConfigMap.put("user1", newImmutableAccountConfig);          //lock.writeLock().unlock();          try {            Thread.sleep(1000);          } catch (InterruptedException e) {            e.printStackTrace();          }        }      }    });}

(注:如果有多个写进程,我们还是需要对他们加写锁,否则不同线程的配置信息修改会被相互覆盖。而读线程是不要加锁的。)

 

结果:

ReadWriteLock:5289501171Immutable  :3599621120

 

测试结果表明,采用不可变对象的方式要比采用读写锁的方式快很多。但是,并没有数量级的差距。

真实的项目环境的性能差别,还要以实际的项目测试为准。因为不同项目,读写线程的个数,负载和使用方式都是不一样的,得到的结果也会不一样。

 

设计上的优势

采用不可变对象方式,相比读写锁的好处还有就是在设计上的 -- 由于不可变对象的特性,我们不必担心项目组的程序员会错误的使用配置类: 读进程不用加锁,所以不用担心在需要被加读锁的地方没有合理的加锁,导致数据不一致性(但如果是多进程写,还是要非常注意加写锁);也不用担心配置在不被预期的地方被任意修改。

 

我们不能简单地说,在任何场景下采用Immutable对象就一定比采用读写锁的方式好, 还取决于读写的频率、Immutable对象更新的代价等因素。但是我们可以通过这个例子,更清楚的理解采用Immutable对象的好处,并认真地在项目中考虑它,因为有可能为效率和设计带来很大的好处。

 

google的不可变集合类库

如果我们采用集合或者Map来保存不可变信息,我们可以采用google的不可变集合类库(属于Guava项目)。(JDK并没有实现原生的不可变集合类库)

http://mvnrepository.com/artifact/com.google.collections/google-collections/1.0

 

下面写一些代码示例一下:

   public static void main(String[] args) throws Exception {    //创建ImmutableMap    ImmutableMap<String,Double> immutableMap = ImmutableMap.<String,Double>builder()        .put("SpecialEventDiscount", 0.01)        .put("MembershipDiscount", 0.02)        .build();        //基于原ImmutableMap生成新的更新的ImmutableMap    Map<String,Double> tempMap = Maps.newHashMap(immutableMap);    tempMap.put("MembershipDiscount", 0.03);    ImmutableMap<String,Double> newImmutableMap = ImmutableMap.<String,Double>builder()        .putAll(tempMap)        .build();  }