精华内容
下载资源
问答
  • 如果要对原子值和互斥锁进行二选一,你认为最重要的三个决策条件应该是什么?</p>
  • 选择恒定的原子值类型数据 转载于:https://www.cnblogs.com/movemoon/archive/2012/10/22/2734172.html

    选择恒定的原子值类型数据

    转载于:https://www.cnblogs.com/movemoon/archive/2012/10/22/2734172.html

    展开全文
  • Effective C# 原则7: 选择恒定的原子值类型数据恒定类型(immutable types)其实很简单,就是一但它们被创建,它们(的值)就是固定的。如果你验证一些准备用于创建一个对象的参数,你知道它在验证状态从前面的观点上看...

    Effective C# 7 选择恒定的原子值类型数据

    恒定(immutable types)简单,就是一但它建,它()就是固定的。如果你验证一些准用于建一个象的参数,你知道它在验证从前面的点上看。你不能修改一个象的内部状使之成无效的。在一个象被建后,你必自己小心翼翼的保护对象,否你不得不做错误验证来禁止改任何状。恒定型天生就具有线程完全性的特点:多访问者可同时访问相同的内容。如果内部状不能修改,那就不能不同的线程提供看不一致的数据视图的机会。恒定型可以从你的上安全的暴露出来。用者不能修改象的内部状。恒定型可以很好的在基于哈希代的集合上工作。以Object.GetHashCode()方法返回的同一个例是必相同的(10),而正是恒定能成功的地方。

    并不是所有的型都能成恒定型的。如果它可以,你需要克隆一个象用于修改任何程序的状了。就是推荐使用恒定型和原子型数据了。把你的象分解自然的构。一个Address型就是的,它就是一个简单的事,由多个相的字段成。改其中一个字段就很可能意味着修改了其它字段。一个客户类型不是一个原子型,一个客户类型可能包含很多小的信息:地址,名字,一个或者多个电话。任何一个互不关联的信息都可以改。一个客可能会在不搬家的情况下改变电话。而另一个客可能在搬了家的情况下保留原来的电话有可能,一个客了他()的名字,而没有搬家也没有改电话。一个客户类型就不是原子型;它是由多个不同的恒定的成部份构成的:地址,名字,以及一个成电话集合。原子型是体:你很自然的用原子型来取代体内容。一例外会改它其中的一个成字段。

    下面就是一个典型的可地址实现
    // Mutable Address structure.
    public struct Address
    {
      private string  _line1;
      private string _line2;
      private string  _city;
      private string _state;
      private int    _zipCode;

      // Rely on the default system-generated
      // constructor.

      public string Line1
      {
        get { return _line1; }
        set { _line1 = value; }
      }
      public string Line2
      {
        get { return _line2; }
        set { _line2 = value; }
      }
      public string City
      {
        get { return _city; }
        set { _city= value; }
      }
      public string State
      {
        get { return _state; }
        set
        {
          ValidateState(value);
          _state = value;
        }
      }
      public int ZipCode
      {
        get { return _zipCode; }
        set
        {
          ValidateZip( value );
          _zipCode = value;
        }
      }
      // other details omitted.
    }

    // Example usage:
    Address a1 = new Address( );
    a1.Line1 = "111 S. Main";
    a1.City = "Anytown";
    a1.State = "IL";
    a1.ZipCode = 61111 ;
    // Modify:
    a1.City = "Ann Arbor"; // Zip, State invalid now.
    a1.ZipCode = 48103; // State still invalid now.
    a1.State = "MI"; // Now fine.

    内部状的改意味着它很可能反了象的不性,至少是临时的。当你改City个字段后,你就使a1于无效状。城市的改使得它与洲字段及以区字段不再匹配。代的有害性看上去不足以致命,但这对于多线程程序来只是一小部份。在城市化以后,洲化以前的任何内容转变,都会潜在的使另一个线程看到一份矛盾的数据视图

    Okay,所以你不准去写多线程程序。你仍然于困境当中。想象这样问题,区代是无效的,并且置抛出了一个异常。你只是完成了一些你想做的事,可你却使系统处于一个无效的状当中。了修正问题,你要在地址里面添加一个相当大的内部验证码验证码应该须要相当大的空,并且很复杂了完全实现期望的安全性,当你修改多个字段,你要在你的代码块围创建一个被的数据COPY线程安全性可能要求添加一个明确的线程同用于检测每一个属性访问器,包括setget而言之,将是一个意重大的行--并且很可能在你添加新功能分的展。

    取而代之,把address构做一个恒定型。始把所有的字段都改成只的吧:
    public struct Address
    {
      private readonly string  _line1;
      private readonly string  _line2;
      private readonly string  _city;
      private readonly string  _state;
      private readonly int    _zipCode;

      // remaining details elided
    }

    要移除所有的属性置功能:
    public struct Address
    {
      // ...
      public string Line1
      {
        get { return _line1; }
      }
      public string Line2
      {
        get { return _line2; }
      }
      public string City
      {
        get { return _city; }
      }
      public string State
      {
        get { return _state; }
      }
      public int ZipCode
      {
        get { return _zipCode; }
      }
    }

    在,你就有了一个恒定型。它有效的工作,你必添加一个构造函数来完全初始化address构。address构只外的添加一个构造函数,来验证每一个字段。一个拷构造函数不是必的,因为赋值运算符算高效。住,默的构造函数仍然是可访问的。是一个默所有字符串nullZIP码为0的地址构:
    public struct Address
    {
      private readonly string  _line1;
      private readonly string  _line2;
      private readonly string  _city;
      private readonly string  _state;
      private readonly int    _zipCode;

      public Address( string line1,
        string line2,
        string city,
        string state,
        int zipCode)
      {
        _line1 = line1;
        _line2 = line2;
        _city = city;
        _state = state;
        _zipCode = zipCode;
        ValidateState( state );
        ValidateZip( zipCode );
      }

      // etc.
    }

    在使用个恒定数据,要求直接用不同的用来一的修改它的状。你更宁愿建一个新的象而不是去修改某个例:
    // Create an address:
    Address a1 = new Address( "111 S. Main",
      "", "Anytown", "IL", 61111 );

    // To change, re-initialize:
    a1 = new Address( a1.Line1,
      a1.Line2, "Ann Arbor", "MI", 48103 );

    a1是两者之一:它的原始位置Anytown,或者是后来更新后的位置Ann Arbor。你再不用像前面的例子那了修改已存在的地址而使临时无效状里只有一些在构造函数才存在的临时,而在构造函数外是无法访问内部状的。很快,一个新的地址象很快就生了,它的就一直固定了。正是期望的安全性:a1是默的原始,要是新的。如果在构造时发生了异常,那a1保持原来的默认值

    (注:在构造时发生异常不会影响a1呢?因只要构造函数没有正确返回,a1都只保持原来的。因是那是一个赋值语句。也就是要用构造函数来实现对象更新,而不是另外添加一个函数来更新象,因就算用一个函数来更新象,也有可能更新到一半生异常,也会使得于不正确的状当中。大家可以参考一下.Net里的日期时间结构,它就是一个典型的恒定常量例子。它没有提供任何的对单独年,月,日或者星期行修改的方法。因为单独修改其中一个,可能致整个日期于不正确的状:例如你把日期独的修改31号,但很可能那个月没有31号,而且星期也可能不同。它同也是没提供任何方法来同时设置所以参数,了条原后就明白了吧。参考一下DateTime构,可以更好的理解要使用恒定型。注:有些immutable type译为变类型。)

    建一个恒定型,你要确保你的用没有任何机会来修改内部状值类型不支持派生,所以你不必定担心派生来修改它的内部状。但你要注意任何在恒定型内的可的引用型字段。当你为这实现了构造函数后,你要被的把可的引用COPY一遍(注:被COPYdefensive copy,文中应该是指了保数据,在数据赋值时不得不行的一个COPY,所以被认为防守,我译为:被,表示拷不是自的,而是不得以而之的)
    所有些例子,都是假Phone是一个恒定的值类型,因及到值类型的恒定性:

    // Almost immutable: there are holes that would
    // allow state changes.
    public struct PhoneList
    {
      private readonly Phone[] _phones;

      public PhoneList( Phone[] ph )
      {
        _phones = ph;
      }

      public IEnumerator Phones
      {
        get
        {
          return _phones.GetEnumerator();
        }
      }
    }

    Phone[] phones = new Phone[10];
    // initialize phones
    PhoneList pl = new PhoneList( phones );

    // Modify the phone list:
    // also modifies the internals of the (supposedly)
    // immutable object.
    phones[5] = Phone.GeneratePhoneNumber( );

    个数是一个引用型。PhoneList内部引用的数,引用了分配在象外的数上。开发可以通另一个引用到个存上的象来修改你的恒定构。了避免这种可能,你对这个数做一个被。前面的例子示了可集合的弊端。如果电话类型是一个可的引用型,它会有更多危害存在的可能。客可以修改它在集合里的,即使个集合是保,不任何人修改。个被的拷贝应该个构造函数里被实现,而不管你的恒定型里是否存在引用象:

    // Immutable: A copy is made at construction.
    public struct PhoneList
    {
      private readonly Phone[] _phones;

      public PhoneList( Phone[] ph )
      {
         _phones = new Phone[ ph.Length ];
         // Copies values because Phone is a value type.
         ph.CopyTo( _phones, 0 );
      }

      public IEnumerator Phones
      {
        get
        {
          return _phones.GetEnumerator();
        }
      }
    }

    Phone[] phones = new Phone[10];
    // initialize phones
    PhoneList pl = new PhoneList( phones );

    // Modify the phone list:
    // Does not modify the copy in pl.
    phones[5] = Phone.GeneratePhoneNumber( );

    当你返回一个可变类型的引用,也应该遵守一原。如果你添加了一个属性用于从PhoneList构中取得整个数表,访问器也必须实现一个被情参23

    复杂型表明了三个策略,是你在初始化你的恒定时应该使用的。Address构定了一个构造函数,你的客可以初始化一个地址,定合理的构造函数通常是最容易达到的。

    你同可以建一个工厂方法来实现一个构。工厂使得建一个通用的型数据得更容易。.Net框架的Color型就是遵从一策略来初始化系统颜色的。个静的方法Color.FromKnownColor()Color.FromName()从当前示的色中拷一个定的系统颜色,返回

    第三,你可以那些需要多作才能完成构造函数的恒定型添加一个伴随.Net框架里的字符串就遵从一策略,它利用了伴随System.Text.StringBuilter。你是使用StringBuliter类经过操作来建一个字符串。在完成了所有必须步骤生成一个字符串后,你从StringBuilter取得了一个恒定的字符串。
    (
    注:.net里的string是一但初始化,就不能再修改,它的任何改都会生成新的字符串。因此多次操作一个string多的垃圾内存碎片,你可以用StringBuliter来平衡问题)

    恒定型是更简单,更容易维护的。不要盲目的你的一个象的属性getset访问器。你对这型的第一选择是把些数存储为恒定型,原子型。从体中,你可以可以容易的建更多复杂

     

    展开全文
  • 转:http://dev.csdn.net/author/Knight94/5582b364fc744be09bca2dca36786322.html《Effective C#》Item 7:推荐使用不可改变的原子值类型 首先来解释一下标题,原标题为《Prefer Immutable Atomic Value Type》,...

    转:http://dev.csdn.net/author/Knight94/5582b364fc744be09bca2dca36786322.html

    《Effective C#》Item 7:推荐使用不可改变的原子值类型

     

    首先来解释一下标题,原标题为《Prefer Immutable Atomic Value Type》,因此对于标题的理解要分成三部分,第一部分为不可改变,第二部分为原子,最后一个部分为值类型CSDN也经常提到,例如保证操作的原子性之类的语句,那么一个原子类型,其的子成员为不可分割的一部分,不能单独被操作。。最后一部分,我不多说了,限制此章适用的范围。对于什么是不可改变类型,这里的意思是指此类型的变量一旦产生其成员就不能发生变化。至于原子类型,我以前在
     
    听了标题解释,难免有些人会问,为什么要加上这样的限制,或者说这样做的好处是什么。为了解开这个疑团,我用一个例子来说明,去定义一个电话号码的值类型,一般形式如下:
        public struct Phone
        {
            private string strCountry_Code;
            private string strCity_Code;
            private string strPhone_Number;
            public string Country_Code
            {
                get{ return strCountry_Code; }
                set{ strCountry_Code = value;}
            }
            public string City_Code
            {
                get{ return strCity_Code; }
                set{ strCity_Code = value;}
            }
            public string Phone_Number
            {
                get{ return strPhone_Number; }
                set{ strPhone_Number = value;}
            }
     
            // Constructor
            public Phone( string sCountry_Code, string sCity_Code, string sPhone_Number )
            {
                strCountry_Code = sCountry_Code;
                strCity_Code = sCity_Code;
                strPhone_Number = sPhone_Number;
            }
        }
     
    这样去初始化一个Phone类型变量的话,同时也可以做类似如下的相关操作。
        Phone myPhone = new Phone( "086", "010", "66666666" );
        myPhone.City_Code = "021";
        myPhone.Phone_Number = "777777777";
     
    大多数人觉得如上的代码没有什么问题,不过稍微明眼的人看了如上的代码,就会立刻觉得有潜在的危险。作为一个Phone类型变量来说,国家区号,城市区号,以及电话号码来说是一个整体。因此动态修改其中的某一个值,会造成其他两个无效。也就是说如上的代码直接修改City_Code的时候,对于myPhone来说其他两个变量Country_Code以及Phone_Number来说,此时是无效的。不过这种错误在单线程中不是很明显,但是在多线程中是致命的,而且很难查出来。Lock语句或者互斥标识来避免。这样是可以避免,但是试问一下,类型是你创建的,你怎么要求别人在使用你这个类型的时候做过多的操纵呢,为什么你不在创建此类型的时候就直接把这条路堵死。如果明白了这一点,就理解了这篇文章推荐的目的,即与其后期增加代码弥补,不如在前期就编写正确的代码。有人可能会说了,在修改的时候加上
     
    知道这样做的原因,接下来就是如何去实现。不过在实现之前,要区分什么样的数据类型可以定义成不可变的原子类型。也就是说,你如何区分一个类型是一个整体,而且每个分支不能独立于整体而存在。例如对于联系方式这个类型来说,它包括电话号码、住址等等。它可以看为一个整体,但是分支可以脱离这个整体而存在,因此它不是一个原子类型。对于如何具体区分,很难有一个统一的方法,毕竟适应的环境不同,操作以及实现也不同。不过对于原子类型,有一个唯一判断方式,就是每个分支能否独立于整体而被操作,这个的是与否决定是否为原子类型。
     
    那么如何去定义一个不可变的原子值类型呢,大致要对原有的类型做两个处理,一个就是把所有成员加上readonly标示,即只能在构造函数中被修改;另一个就是删除属性set部分。对于Phone这个类型来说,经过处理后,正确的形式如下:
        public struct Phone
        {
            private readonly string strCountry_Code;
            private readonly string strCity_Code;
            private readonly string strPhone_Number;
            public string Country_Code
            {
                get{ return strCountry_Code; }
            }
            public string City_Code
            {
                get{ return strCity_Code; }
            }
            public string Phone_Number
            {
                get{ return strPhone_Number; }
            }
     
            // Constructor
            public Phone( string sCountry_Code, string sCity_Code, string sPhone_Number )
            {
                strCountry_Code = sCountry_Code;
                strCity_Code = sCity_Code;
                strPhone_Number = sPhone_Number;
            }
        }
     
    这样对于一个Phone类型变量,只能通过new来创建(也就是说在输入三个有效的数据后,一个Phone类型变量才能产生)。
     
    在此有人会问,除了new是否还有其他方法来进行修改。这是没有任何问题的,首先你只要理解了原子类型的意义,保证分支不会单独被修改即可,因此可以实现类似于“Phone.Parse”或者“Phone.From”之类的函数来形成一个新的Phone变量。
     
    在实现不可变的原子值类型的时候,要防止类型中包括引用类型分支的时候,在进行成员赋值的时候,防止浅copy,这方面我就不多说了,参看我以前写的文章就可以明白(这里的目的也就是一点,防止局部破坏原子类型的分支)。

     

    展开全文
  • 《Effective C#》Item 7:推荐使用不可改变的原子值类型《Effective C#》Item 7:推荐使用不可改变的原子值类型 首先来解释一下标题,原标题为《Prefer Immutable Atomi...
    《Effective C#》Item 7:推荐使用不可改变的原子值类型
    《Effective C#》Item 7:推荐使用不可改变的原子值类型

    首先来解释一下标题,原标题为《Prefer Immutable Atomic Value Type》,因此对于标题的理解要分成三部分,第一部分为不可改变,第二部分为原子,最后一个部分为值类型。最后一部分,我不多说了,限制此章适用的范围。对于什么是不可改变类型,这里的意思是指此类型的变量一旦产生其成员就不能发生变化。至于原子类型,我以前在CSDN也经常提到,例如保证操作的原子性之类的语句,那么一个原子类型,其的子成员为不可分割的一部分,不能单独被操作。

    听了标题解释,难免有些人会问,为什么要加上这样的限制,或者说这样做的好处是什么。为了解开这个疑团,我用一个例子来说明,去定义一个电话号码的值类型,一般形式如下:

    public struct Phone

    {

    private string strCountry_Code;

    private string strCity_Code;

    private string strPhone_Number;

    public string Country_Code

    {

    get{ return strCountry_Code; }

    set{ strCountry_Code = value;}

    }

    public string City_Code

    {

    get{ return strCity_Code; }

    set{ strCity_Code = value;}

    }

    public string Phone_Number

    {

    get{ return strPhone_Number; }

    set{ strPhone_Number = value;}

    }

    // Constructor

    public Phone( string sCountry_Code, string sCity_Code, string sPhone_Number )

    {

    strCountry_Code = sCountry_Code;

    strCity_Code = sCity_Code;

    strPhone_Number = sPhone_Number;

    }

    }

    这样去初始化一个Phone类型变量的话,同时也可以做类似如下的相关操作。

    Phone myPhone = new Phone( "086", "010", "66666666" );

    myPhone.City_Code = "021";

    myPhone.Phone_Number = "777777777";

    大多数人觉得如上的代码没有什么问题,不过稍微明眼的人看了如上的代码,就会立刻觉得有潜在的危险。作为一个Phone类型变量来说,国家区号,城市区号,以及电话号码来说是一个整体。因此动态修改其中的某一个值,会造成其他两个无效。也就是说如上的代码直接修改City_Code的时候,对于myPhone来说其他两个变量Country_Code以及Phone_Number来说,此时是无效的。不过这种错误在单线程中不是很明显,但是在多线程中是致命的,而且很难查出来。有人可能会说了,在修改的时候加上Lock语句或者互斥标识来避免。这样是可以避免,但是试问一下,类型是你创建的,你怎么要求别人在使用你这个类型的时候做过多的操纵呢,为什么你不在创建此类型的时候就直接把这条路堵死。如果明白了这一点,就理解了这篇文章推荐的目的,即与其后期增加代码弥补,不如在前期就编写正确的代码。

    知道这样做的原因,接下来就是如何去实现。不过在实现之前,要区分什么样的数据类型可以定义成不可变的原子类型。也就是说,你如何区分一个类型是一个整体,而且每个分支不能独立于整体而存在。例如对于联系方式这个类型来说,它包括电话号码、住址等等。它可以看为一个整体,但是分支可以脱离这个整体而存在,因此它不是一个原子类型。对于如何具体区分,很难有一个统一的方法,毕竟适应的环境不同,操作以及实现也不同。不过对于原子类型,有一个唯一判断方式,就是每个分支能否独立于整体而被操作,这个的是与否决定是否为原子类型。

    那么如何去定义一个不可变的原子值类型呢,大致要对原有的类型做两个处理,一个就是把所有成员加上readonly标示,即只能在构造函数中被修改;另一个就是删除属性set部分。对于Phone这个类型来说,经过处理后,正确的形式如下:

    public struct Phone

    {

    private readonly string strCountry_Code;

    private readonly string strCity_Code;

    private readonly string strPhone_Number;

    public string Country_Code

    {

    get{ return strCountry_Code; }

    }

    public string City_Code

    {

    get{ return strCity_Code; }

    }

    public string Phone_Number

    {

    get{ return strPhone_Number; }

    }

    // Constructor

    public Phone( string sCountry_Code, string sCity_Code, string sPhone_Number )

    {

    strCountry_Code = sCountry_Code;

    strCity_Code = sCity_Code;

    strPhone_Number = sPhone_Number;

    }

    }

    这样对于一个Phone类型变量,只能通过new来创建(也就是说在输入三个有效的数据后,一个Phone类型变量才能产生)。

    在此有人会问,除了new是否还有其他方法来进行修改。这是没有任何问题的,首先你只要理解了原子类型的意义,保证分支不会单独被修改即可,因此可以实现类似于“Phone.Parse”或者“Phone.From”之类的函数来形成一个新的Phone变量。

    在实现不可变的原子值类型的时候,要防止类型中包括引用类型分支的时候,在进行成员赋值的时候,防止浅copy,这方面我就不多说了,参看我以前写的文章就可以明白(这里的目的也就是一点,防止局部破坏原子类型的分支)。

    来自 “ ITPUB博客 ” ,链接:http://blog.itpub.net/374079/viewspace-130539/,如需转载,请注明出处,否则将追究法律责任。

    转载于:http://blog.itpub.net/374079/viewspace-130539/

    展开全文
  • 首先来解释一下标题,原标题为《Prefer Immutable Atomic Value Type》,因此对于标题的理解要分成三部分,第一部分为不可改变,第二部分为原子,最后一个部分为类型。最后一部分,我不多说了,限制此章适用的范围...
  • 介绍:在这个Boolean的变化的时候不允许在之间插入,保持操作的原子性 方法和举例:compareAndSet(boolean expect, boolean update)这个方法主要两个作用 比较AtomicBoolean和expect的,如果一致,执行...
  • 原子性获取最大

    2015-11-20 16:45:36
    原子性获取最大  void Set(int64_t i)  {  for(;;) {  int64_t v = common::AtomicGet(pValue);  if (common::AtomicCompareExchange(pValue, v, max(v,i)))  
  • MYSQL 原子得到UPDATE变化的

    千次阅读 2013-11-27 11:33:58
    MYSQL原子得到UPDATE变化的
  • 通过这篇文章,我主要想向大家说明一个我们平时可能不太会注意到的问题:创建具有常量性和原子性的类型。 从类型设计谈起 从Class到Struct 假如我们要设计一个存储收信人地址的类型(Type), 我们管这个类型叫 ...
  • 将串口示例程序直接烧在自己的板子上发现不能用,检查引脚配置都正确,查了下晶振发现自己的板子上是12M晶振,而ST官方和原子的示例默认是8M的 在system_stm32f10x.c中有这样一段话: 修改步骤: 1. 在stm32f10...
  • 08-同步5-原子操作

    2020-11-26 09:03:15
    文章目录一 原子操作理解二 常用原子操作2.1 原子运算:增/减2.2 原子运算:比较与替换2.3 原子读取:载入2.4 原子写入:存储2.5 交换三 原子值 一 原子操作理解 对并发的操作,可以利用Go新提出的管道思想,大多数...
  • 原子值sync/atomic.Value 简介 执行过程中不能被中断的操作。在针对某个值的操作过程中,CPU绝不会再去执行其它针对该值的操作,无论这些其他操作是否是原子操作。 对于不能被取地址的值是无法进行原子操作...
  • CAS操作包含三个操作数内存V、预期原值A和新B,当且仅当预期原值A和内存V相同时,将内存V修改为新B,否则,处理器不做任何操作。// CAS C++示意int compare_and_swap (int* reg, int oldval, int newval) ...
  • 图像处理 二化处理 滚球系统单点定位 把程序直接烧录探索者可直接测试
  • 现在,我需要一种在一次原子操作中替换该映射的所有的方法。public final class StatefulBean {private final Map state = new ConcurrentSkipListMap<>();public StatefulBean() {//Initial statethis.s...
  • /** * @author Jiangjunjie * @Date 2020/7/7 * 通过给set NX(一个有锁,其他线程不能再获取锁),PX(设置锁的自动过期时间) 进行保证redis的以及过期时间的原子性 * 通过给锁设置一个拥有者的标识,即每次在获取锁...
  • java.util.concurrent.atomic.AtomicLong类提供了可以被原子地读取和写入的底层long的操作,并且还包含高级原子操作。AtomicLong支持基础long类型变量上的原子操作。 它具有获取和设置方法,如在volatile变量上的...
  • 原子性与原子操作

    千次阅读 2017-10-12 15:27:57
    原子性:如果把一个事务可看作是一个程序,它要么完整的被执行,要么完全不执行。 原子性达到的目标:就是能使一个程序被完整的执行。 原子操作:不可被中断的一个或一系列的操作。 CAS有3个操作数,内存V,...
  • 资源是基于Stm32F407的代码,可以在正点原子探索者上面非常好的运行,代码的作用是轮询扫描共计24路的ADC接口并且将 得到的ADC的保存在数组中,最终通过屏幕的方式显示出来(使用开发板的时候很多IO被内置上下拉,...
  • AtomicInteger原子的使用

    千次阅读 2012-04-07 14:12:17
    原子值:主要用于缓存中唯一的要求,比如队伍,要分配一个 id,并且该id不保存数据库.每次重启服务器,都从指定的值开始. 尝试使用了AtomicInteger这个类,感觉使用起来很爽,特别适用于高并发访问 public static ...
  • ![图片说明](https://img-ask.csdn.net/upload/201708/12/1502501124_341293.png)如图显示,我想把type大小写改了,不影响name,这个要怎么解决
  • 原子变量和原子操作

    千次阅读 2017-06-04 19:47:31
    原子变量和原子操作通常情况下,在Java里面,++i或者–i不是线程安全的,这里面有三个独立的操作:获得变量当前,为该+1/-1,然后写回新的。在没有额外资源可以利用的情况下,只能使用加锁才能保证读-改-写这...
  • INCR key将key中储存的数字增一。如果key不存在,那么key的会先被初始化为0,然后再执行INCR操作。如果包含错误的类型,或字符串类型的不能表示为数字,那么返回一个错误。本操作的限制在 64 位(bit)有...
  • 研究了含级联双光子过程的多束缚态激光场诱导原子连续态结构系统中原子的相干捕获,给出了产生相干捕获的条件及暗态的表达式,讨论了原子初态和激光强度对原子相干捕获及粒子布居在束缚态上分布的影响,揭示了原子...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,170
精华内容 3,668
关键字:

原子值