驯服共享可变性

于 2019-03-10 21:31:06 发布
阅读量198 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lingmao555/article/details/88384252
版权

如果一个变量可以给多个线程读写，则我们说这个变量是共享的。下面通过一个栗子一步一步认识共享变量。

这是一个关于电源的控制程序，可以充电，用电，取得当前电量，停止充电。

package com.winter.Concurrency.April.TeachSample;

/**
 * 这个程序的问题
 * 1.level是一个非安全的共享可变变量
 * 2.replenish函数在大多数情况是睡眠状态，但是它要消耗一个线程，如果线程过多会溢出
 * 3.在构造函数中调用Thread的start方法，Thread类会自动插入一个内存栅栏，并将尚未构架完成的对象暴露给其他线程。
 * 4.EnergySource的实现破坏了类不变式。
 */
public class EnergySource {

    private final long MAXLEVEL=100;
    private long level=MAXLEVEL;
    private boolean keepRunning =true;
    //构造器初始化线程
    public EnergySource(){
        new Thread(new Runnable() {
            @Override
            public void run() {
                replenish();
            }
        }).start();
    }
    //充电函数
    public void replenish(){
        while(keepRunning){
            if(level<MAXLEVEL){
                level++;
            }
            try { 
                Thread.sleep(1000);
            }catch (InterruptedException ex){
                System.out.println(ex.getMessage());
            }
        }
    }
    //取得当前电量
    public long getUnitLevelAvailable(){
        return level;
    }
    //停止充电
    public void StopEnergySource(){
        keepRunning=false;
    }
    //使用电量
    public boolean useEnergy(final long unit){
        if(unit>0&&unit<=level){
            level-=level;
            return true;
        }
        return false;
    }
}

上面的程序存在很多问题

package com.winter.Concurrency.April.TeachSample;

/**
 *为了不破坏类的不变式,考虑使用静态工厂函数来代替构造函数。即在一个静态工厂函数中创建对象实例，并将实例的引用返回给调用方之前启动的线程。
 *这种方法可以保证后台的任务能够在对象创建完成之后启动，从而保证了对象在创建和初始化的过程中一直处于有效状态。
 *
 */
public class FixEnergySource1 {

    private final long MAXLEVEL=100;
    private long level=MAXLEVEL;
    private boolean keepRunning =true;

    //静态工厂方法
    public static FixEnergySource1 create(){
        final FixEnergySource1 fixEnergySource1=new FixEnergySource1();
        fixEnergySource1.init();
        return fixEnergySource1;
    }
    //初始化线程的方法
    private void init(){
        new Thread(new Runnable() {
            @Override
            public void run() {
                replenish();
            }
        }).start();
    }
    //充电函数
    public void replenish(){
        while(keepRunning){
            if(level<MAXLEVEL){
                level++;
            }
            try {
                Thread.sleep(1000);
            }catch (InterruptedException ex){
                System.out.println(ex.getMessage());
            }
        }
    }
    //取得当前的电量
    public long getUnitLevelAvailable(){
        return level;
    }
    //停止充电
    public void StopEnergySource(){
        keepRunning=false;
    }
    //使用电量
    public boolean useEnergy(final long unit){
        if(unit>0&&unit<=level){
            level-=level;
            return true;
        }
        return false;
    }
}

package com.winter.Concurrency.April.TeachSample;

import java.util.concurrent.*;

/**
 * 由于线程资源非常有限，所以创建的行为就不能太随意，选用java.util.Timer周期性的运行。
 * 在创建大量的FixEnergySource2的实例的时候，能实现线程复用。取消keepRunning属性，直接停掉周期任务。
 *
 *
 */
public class FixEnergySource2 {

    private final long MAXLEVEL=100;
    private long level=MAXLEVEL;
    //因为任务很少，所有10个线程就够了。
    private static final ScheduledExecutorService replenishTimer= Executors.newScheduledThreadPool(10);
    //上面的replenishTimer声明为static可以帮助我们在ScheduledThreadPool中共享线程池里的线程，我们必须想出一个将replenishTimer
    //关闭的方法，默认情况下，执行线程都是非守护线程，如果我们不手动将它关闭，jvm是不会替我们关闭的，当然我们可以手动调用replenishTimer
    //.shutdown();方法进行关闭，也可以使用下面的线程工厂，保证所产生的线程都是守护线程。
//    private static final ScheduledExecutorService replenishTimer= Executors.newScheduledThreadPool(10, new ThreadFactory() {
//        @Override
//        public Thread newThread(Runnable r) {
//            Thread thread=new Thread(r);
//            thread.setDaemon(true);
//            return thread;
//        }
//    });

    private ScheduledFuture<?> replenishTask;
    private boolean keepRunning =true;
    //默认构造器私有化
    private FixEnergySource2(){

    }

    public static FixEnergySource2 create(){
        final FixEnergySource2 fixEnergySource2=new FixEnergySource2();
        fixEnergySource2.init();
        return fixEnergySource2;
    }
    //初始化周期充电的任务
    private void init(){
       replenishTask=replenishTimer.scheduleAtFixedRate(new Runnable() {
           @Override
           public void run() {
               replenish();
           }
       },0,1, TimeUnit.SECONDS);
    }
    //充电的函数
    public void replenish(){
        if(level<MAXLEVEL){
            level++;
        }
    }
    //取得当前电量
    public long getUnitLevelAvailable(){
        return level;
    }
    //停止充电
    public void StopEnergySource(){
        replenishTask.cancel(false);
    }
    //使用电量
    public boolean useEnergy(final long unit){
        if(unit>0&&unit<=level){
            level-=level;
            return true;
        }
        return false;
    }
}

package com.winter.Concurrency.April.TeachSample;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;

/**
 *为保证FixEnergySource3类跨越内存栅栏,简单粗暴的方法是直接在方法面前加上synchronized关键字
 *写程序的座右铭是“先跑起来，然后再优化”
 *在下面4个方法前加上了synchronized关键字，因为这些函数需要访问level变量。
 */
public class FixEnergySource3 {

    private final long MAXLEVEL=100;
    private long level=MAXLEVEL;
    private static final ScheduledExecutorService replenishTimer= Executors.newScheduledThreadPool(10);
    private ScheduledFuture<?> replenishTask;
    private boolean keepRunning =true;
    //默认构造器私有化
    private FixEnergySource3(){

    }

    public static FixEnergySource3 create(){
        final FixEnergySource3 fixEnergySource2=new FixEnergySource3();
        fixEnergySource2.init();
        return fixEnergySource2;
    }
    //初始化周期充电的任务
    private void init(){
       replenishTask=replenishTimer.scheduleAtFixedRate(new Runnable(){
           @Override
           public void run() {
               replenish();
           }
       },0,1, TimeUnit.SECONDS);
    }
    //充电的函数
    public synchronized void replenish(){
        if(level<MAXLEVEL){
            level++;
        }
    }
    //取得当前电量
    public synchronized long getUnitLevelAvailable(){
        return level;
    }
    //停止充电
    public synchronized void StopEnergySource(){
        replenishTask.cancel(false);
    }
    //使用电量
    public synchronized boolean useEnergy(final long unit){
        if(unit>0&&unit<=level){
            level-=level;
            return true;
        }
        return false;
    }
}

package com.winter.Concurrency.April.TeachSample;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;

/**
 * FixEnergySource3虽然解决了跨越内存栅栏问题，但是并发性能不高。下面使用原子类来解决并发问题。
 *
 *
 */
public class FixEnergySource4 {

    private final long MAXLEVEL=100;
    private final AtomicLong level=new AtomicLong(MAXLEVEL);//定义原子类
    private static final ScheduledExecutorService replenishTimer= Executors.newScheduledThreadPool(10);
    private ScheduledFuture<?> replenishTask;
    private boolean keepRunning =true;

    private FixEnergySource4(){
    }

    public static FixEnergySource4 create(){
        final FixEnergySource4 fixEnergySource3=new FixEnergySource4();
        fixEnergySource3.init();
        return fixEnergySource3;
    }

    private void init(){
        replenishTask=replenishTimer.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                replenish();
            }
        },0,1, TimeUnit.SECONDS);
    }

    public void replenish(){
        if(level.get()<MAXLEVEL){
            level.incrementAndGet();//原子类增加
        }
    }
    //取得当前原子类的值
    public long getUnitLevelAvailable(){
        return level.get();
    }
    public synchronized void StopEnergySource(){
        replenishTask.cancel(false);
    }
    public boolean useEnergy(final long unit){
        final long currentLevel=level.get();
        if(unit>0&&unit<=currentLevel){
            return level.compareAndSet(currentLevel,currentLevel-unit);
        }
        return false;
    }

}

package com.winter.Concurrency.April.TeachSample;

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

/**
 * 在一个变量的时候，原子类很好的解决了问题，现在需求增加，现在需要追踪并记录电源的使用情况，
 * 每次电源电量使用完的时候都必须把电源的使用次数累加。使用synchronized当然能解决问题，但是并发性并不好。
 *
 *
 */
public class FixEnergySource5 {

    private final long MAXLEVEL=100;
    private long level=MAXLEVEL;
    private long usage=0;//记录使用的次数
    private final ReadWriteLock monitor= new ReentrantReadWriteLock();//读写锁
    private static final ScheduledExecutorService replenishTimer= Executors.newScheduledThreadPool(10);
    private ScheduledFuture<?> replenishTask;

    private FixEnergySource5(){}

    public static FixEnergySource5 create(){
        final FixEnergySource5 fixEnergySource4=new FixEnergySource5();
        fixEnergySource4.init();
        return fixEnergySource4;
    }

    private void init(){
        replenishTask=replenishTimer.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                replenish();
            }
        },0,1, TimeUnit.SECONDS);
    }
    //变量改变，用写锁
    public void replenish(){
        monitor.writeLock().lock();
        try {
            if (level < MAXLEVEL) {
                level++;
            }
        }finally {
            monitor.writeLock().unlock();
        }
    }
    //只是读取变量
    public long getUnitLevelAvailable(){
        monitor.readLock().lock();
        try {
            return level;
        }finally {
            monitor.readLock().unlock();
        }
    }
    //读取使用的次数
    public long getUsageCount(){
        monitor.readLock().lock();
        try{
            return usage;
        }finally {
            monitor.readLock().unlock();
        }
    }
    public void StopEnergySource(){
        replenishTask.cancel(false);
    }
    //写操作
    public boolean useEnergy(final long unit) {
        monitor.writeLock().lock();
        try {
            if (unit > 0 && unit <= level) {
                level -= level;
                usage++;
                return true;
            }
            return false;
        }finally {
            monitor.writeLock().unlock();
        }
    }


}

 

呵呵。。。

lingmao555
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java多线程计算素数
lingmao555的博客
08-21 6734
package com.sunyard.demo.concurrency; /** * 此类作为工具类 */ public abstract class AbstractPrimeFinder { /** * 判断一个数是否为素数 * @param number * @return */ public boolean isPrime(f
Apache DSO -- 动态共享对象（DSO）
Blau的博客
04-13 402
Apache DSO -- 动态共享对象（DSO） DSO 究竟是什么？事实上 DSO 是 Dynamic SharedObjects（动态共享目标） 的缩写，它是现代 Unix 派生出来的操作系统都存在着的一种动态连接机制。它提供了一种在运行时将特殊格式的代码，在程序运行需要时，将需要的部分从外存调入内存执行的方法。 Apache 在 1.3 以后的版本后开始支持它。因为 Apache 早就使...
共享可变性设计中存在风险以及解决方法(五)
xck503c
10-21 245
本篇是《Java虚拟机并发编程》第六章的阅读笔记在(四)中,因为程序中不止一个与可变状态相关或依赖的变量，所以我们使用显示锁的来进行同步操作。虽然是用了同步锁成功执行了代码，但同时也会产生许多的问题，因为同步本身就有缺陷。例如可能会产生死锁，活锁；可能会因为是人工加锁，所以会导致错误的概率增加，你需要一个个确认是否每个地方都做了适当的同步，开发效率低，等等。这里我们通过使用软件事务内存STM模型来使
DSO(dynamic shared object)动态共享对象的原理
河西无名式
12-02 3469
摘要：可执行ELF文件的生成，如果从源文件c开始算起，需要经过编译、链接、装载几个步骤。在链接和装载这两个步骤中，有两种不同的实现方式，一种是静态链接，这样加载之前，已经形成可执行目标文件；另外一种是动态链接，这种模式下，链接阶段只是链接一部分目标文件，动态链接库（DSO）在装载的时刻才会映射到进程地址空间。本文主要讲解DSO的原理。 1.装载过程涉及的问题 当程序被装载时，系统的
共享可变性设计中存在风险以及解决方法(一)
xck503c
09-04 311
本篇是《Java虚拟机并发编程》第五章的阅读笔记 首先看代码 这是一段控制一个高档电源的代码，改代码允许用户使用电池里的能量，并定期对电源进行自动充电 package com.originalcode; //Bad code public class EnergySource { private final long MAXLEVEL = 100; private lo...
“驯服”振荡—电容性负载问题
01-20
如果您才刚刚接触我们的讨论，那么您应该首先阅读前两篇博客文章《振荡原因》和《“驯服”振荡》。 　“麻烦制造者”运算放大器开环输出电阻 (Ro)，实际并非运算放大器内部的一个电阻器。它是一个依赖于运算放大器...
驯服烂代码
04-15
本书通过编程操练的方式讲述了如何用TDD（测试驱动开发）的方法来驯服烂代码，通过结对编程的对话形式展示了驯服烂代码的完整过程，将驯服烂代码所需要的思想、态度、习惯、方法和技艺完全融入编程操练实践中，是...
基于FPGA的GPS时钟驯服电路设计与实现
04-16
为满足系统对高精度时钟的要求，根据晶振时钟无随机误差和全球定位系统（GPS）时钟无累计误差的特点，提出了一种利用GPS 秒时钟驯服晶振时钟来实现高精度时钟的方案。该方案根据数字锁相环倍频原理，通过测量GPS 秒...
java生成PDF文件
lingmao555的博客
10-23 5763
用Java生成pdf的方法很多，项目用到两种，一种是用adobecrobat pro版画一个模板，定义变量，然后依次把变量的值通过接口赋值过去。但是这个软件兼容性有问题，而且是个收费的工具。有些时候生成的pdf文件在某些pdf软件中能显示，有些不能显示。所以想用Java直接生成pdf文件。 首先下载两个包，网上很多网友说下载不了，我下载的时候没有遇到什么问题，不需要注册，直接下载就行了。 网址
Vector的特性以及和List的区别
lingmao555的博客
02-25 5239
Vector在java语言中是实现自动增长的对象数组，里面是用来存储对象的，这点和List，Set，Map有点相像。 package com.it.test; import java.util.Vector; /** * Created by lingmao on 2016/2/23. * Vector 主要是在多线程中的一个选择。 */ public class test { p
java判断字符串为空
lingmao555的博客
10-14 2457
判断字符串为空在很多场合中用到，方法也很多，下面简单介绍下。 1.在没有其他工具类的情况下，先判断是不是null然后再判断长度。 public static void checkString(String str){ if(str==null || str.length()&lt;=0){ System.out.println("string为空！"); } ...
List和数组相互转换
lingmao555的博客
06-30 1618
import java.util.Arrays; import java.util.List; /** * 【强制】 使用工具类Arrays.asList()把数组转换成集合时， 不能使用其修改集合相关的方法， * 它的 add/remove/clear 方法会抛出 UnsupportedOperationException 异常。 * 说明：asList 的返回对象是一个 Array...
Java在金额方面的使用
lingmao555的博客
12-12 1293
public class testBigDecimal { public static double add(double v1,double v2){ BigDecimal b1 = new BigDecimal(Double.toString(v1)); BigDecimal b2 = new BigDecimal(Double.toString(v2
Java二元操作符instance的用法
lingmao555的博客
08-15 1169
/** * java的instance是一个二元操作符， * 作用：判断一个对象是否是一个类的实例，只能用作对象的判断 */ public class Client { public static void main(String args[]){ boolean a1="string" instanceof Object;//object类是所有类的父类
SFTP操作服务器的文件
lingmao555的博客
06-20 1126
package com.socket; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import ja...
java语言读取xml文本中的内容
lingmao555的博客
02-01 936
感觉很久没有写博客了。。。。刚学了点新的内容贴下面。 用java语言读取xml中的内容，java语言可以读取很多格式文档中的内容，下面读取xml的内容。 第一步得下载一个jdom.jar的java包，其他没有特殊的要求。 整个功能的实现要用两个文件，一个是test.xml和simple.java。 将test.xml放到src目录下，放好了之后的目录结构如下： test.xml的
Java文件下载模块
lingmao555的博客
08-08 907
下载，下载附件
Log4j日志工具实践
lingmao555的博客
12-23 598
Log4J是Apache的一个开放源代码的项目，是目前用的最多的日志控件。通过使用Log4J，程序员可以控制日志信息输送的目的地，包括控制台，文件，GUI组件和NT事件记录器，也可以控制每一条日志的输出格式，或通过定义每一条日志信息的级别，更加细致地控制日志的生成过程。 日志分为下面6个级别，越向下面等级越低： FATAL       ERROR       WARN
qinglong 拉库
最新发布
09-17
与其他龙类生物不同的是，清龙拉库可以被驯服并与人类建立牢固的契约。骑在拉库背上的龙骑士可以与它心灵相通，共同战斗。龙骑士不仅可以乘坐拉库飞行，还可以与它一同合力攻击敌人。他们之间的默契和配合是无与伦比...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值