基于Boost线程库实现Java中atomic…

      Java的java.util.concurrent.atomic包的说明是“ A small toolkit of classes that support lock-free thread-safe programming on single variables”。挺贴切的。是实际多线程编程时很方便的一组类。最近我使用boost里的thread库模仿实现了下，没有单元测试，但应该是正确的。因为它是如此简单以至于肉眼就能看出是否正确了。注意：我模仿的只是外部接口和功能，具体实现不是lock-free的，效率会低一些。
      实现了两个类：Atomic（模板类，基本使用它)和AtomicInteger（继承了Atomic，额外提供++、--等整形操作）。
      技术含量很低，但又很实用的两个类。我觉得boost::thread库如果能够实现下java.util.concurrent提供的众多基础设施，对并发编程肯定很有帮助。

===================华丽的代码分割线====================
#pragma once

#include <boost/thread.hpp>

template <class T>
class Atomic
{
public:
      Atomic()
            : val()
      {
      }

      Atomic(T val_)
            : val(val_)
      {
      }

      virtual ~Atomic(){}

      void set(T val_)
      {
            boost::mutex::scoped_lock lock(mtx);
            val = val_;
      }

      T get()
      {
            boost::mutex::scoped_lock lock(mtx);
            return val;
      }

      bool updateTo(T update)
      {
            boost::mutex::scoped_lock lock(mtx);
            if (val != update)
            {
                  val = update;
                  return true;
            }
            return false;                 
      }

      bool compareAndSet(T expect, T update)
      {
            boost::mutex::scoped_lock lock(mtx);
            if (val == expect)
            {
                  val = update;
                  return true;
            }
            return false;
      }

      T getAndSet(T update)
      {
            boost::mutex::scoped_lock lock(mtx);
            T tmp = val;
            val = update;
            return tmp;
      }

protected:

      T val;
      boost::mutex mtx;
};

class AtomicInteger
      : public Atomic<int>
{
public:
      AtomicInteger()
            : Atomic<int>(0)
      {
      }

      AtomicInteger(int val_)
            : Atomic<int>(val_)
      {
      }

      bool operator==(int comp)
      {
            boost::mutex::scoped_lock lock(mtx);
            return (val == comp);
      }

      int operator++(int)
      {
            boost::mutex::scoped_lock lock(mtx);
            return (val++);
      }

      int operator++()
      {
            boost::mutex::scoped_lock lock(mtx);
            return (++val);
      }

      int operator--(int)
      {
            boost::mutex::scoped_lock lock(mtx);
            return (val--);
      }

      int operator--()
      {
            boost::mutex::scoped_lock lock(mtx);
            return (--val);
      }

      void operator+=(int delta)
      {
            boost::mutex::scoped_lock lock(mtx);
            val += delta;                 
      }

      void operator-=(int delta)
      {
            boost::mutex::scoped_lock lock(mtx);
            val -= delta;                 
      }

};