驯服共享可变性

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class EnergySourceFinal {

    private final long MAXLEVEL = 100;
    
    private AtomicLong level = new AtomicLong(MAXLEVEL);//保证了多线程并发访问环境下的可见性和线程安全性，在本例中可改为long类型
    private long usage = 0;
    private ReadWriteLock monitor = new ReentrantReadWriteLock();//原子性
    
    //执行周期性任务
    //private static ScheduledExecutorService replenishTimer = Executors.newScheduledThreadPool(10);
    private static ScheduledExecutorService replenishTimer = Executors.newScheduledThreadPool(10,new ThreadFactory() {
        
        public Thread newThread(Runnable arg0) {
            Thread thread = new Thread(arg0);
            return thread;
        }
    });//ThreadFactory能保证所创建的所有线程都是守护线程
    
    ScheduledFuture<?> replenishTask;
    
    public EnergySourceFinal() {
    }

    private void init() {
        replenishTask = replenishTimer.scheduleAtFixedRate(new Runnable() {
            public void run() {
                replenish();
            }

        }, 0, 1, TimeUnit.SECONDS);
    }
    
    private void replenish() {
        monitor.writeLock().lock();//写锁
        try{
            if(level.get() < MAXLEVEL) {
                level.getAndIncrement();
                System.out.println("充电中："+level.get());
            }
        }finally{
            monitor.writeLock().unlock();
        }
    }
    
    //不要在构造函数中启动线程，避免线程在对象尚未构造完成之前就调用其成员方法，建议使用静态工厂函数
    public static EnergySourceFinal create() {
        final EnergySourceFinal energySource = new EnergySourceFinal();
        energySource.init();
        return energySource;
    }
    
    //synchronized 竞争条件下保证可见性
    public synchronized void stopEnergySource() {
        replenishTask.cancel(false);
    }
    
    public boolean useEnergy(final long units) {
        monitor.writeLock().lock();
        try{
            long currentLevel = level.get();
            if(currentLevel > units && units > 0) {
                level.compareAndSet(currentLevel, currentLevel-units);
                System.out.println("使用"+units+"units");
                return true;
            }
            
            return false;
        }finally{
            monitor.writeLock().unlock();
        }
    }
    
    public long getUnitsAvailable() {
        monitor.readLock().lock();
        try {
            return level.get();
        } finally {
            monitor.readLock().unlock();
        }
    }
    
    public long getUsageCount() {
        monitor.readLock().lock();//读锁
        try {
            return usage;
        } finally {
            monitor.readLock().unlock();
        }
    }
    
    public static void main(String[] args) {
        final EnergySourceFinal energySource = EnergySourceFinal.create();
        new Thread(new Runnable(){
            public void run() {
                energySource.useEnergy(10);
            }
        }).start();
        new Thread(new Runnable(){
            public void run() {
                energySource.useEnergy(20);
            }
        }).start();
        new Thread(new Runnable(){
            public void run() {
                energySource.useEnergy(10);
            }
        }).start();
        for(long i = 0; i < 20000000000l; i++) {
            if(i == 15999999999l)
                System.out.println("当前值："+energySource.getUnitsAvailable());
        }
    }
}