<html>
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
  </head>
  <body text="#000000" bgcolor="#FFFFFF">
    <p>Perhaps this thread has diverged too far...<br>
    </p>
    <p>Someone wondered on this thread, if synchronized or compare and
      set would work better under high contention.  The example I have
      does not use equals() so it does not quite match the original
      question.  However, the example does use Instant and compareTo()
      and hence might be similar enough to illustrate.<br>
    </p>
    <p>My program needs an id that is unique even among runs of a
      singleton process.  I figured the easiest way was to use the
      current time.  I could have used System.currentTimeMillis() but
      decided to go with Instant since that would probably make the code
      easier to understand and maintain.<br>
    </p>
    <p>I had code like the following...<br>
    </p>
    <pre>      Instant result;

      result = Instant.now();

      synchronized (Task.class)
      {
         if (result.compareTo(last) <= 0)
            result = last.plusNanos(1);

         last = result;
      }
</pre>
    <p>This code didn't scale.  I changed the code to this...<br>
    </p>
    <pre>      Instant result;

      result = Instant.now();

      while (true)
      {
         expect = last.get();    // last is now an AtomicReference

         if (result.compareTo(expect) <= 0)
            result = last.plusNanos(1);

         if (last.compareAndSet(expect, result))
            return(result);
      }</pre>
    This code scales much better.  I no longer see any scalability or
    performance issues with this code.  This code is using both identity
    comparison (i.e. "inside" compareAndSet when comparing expect to the
    actual current value) as well as compareTo().  <br>
    <p>-Nathan<br>
    </p>
    <div class="moz-cite-prefix">On 7/9/2017 5:10 PM, Gregg Wonderly
      wrote:<br>
    </div>
    <blockquote type="cite"
      cite="mid:E743F36D-E587-46DD-82F7-717D291298A9@cox.net">
      <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
      <meta http-equiv="Content-Type" content="text/html; charset=utf-8"
        class="">
      <div style="word-wrap: break-word; -webkit-nbsp-mode: space;
        -webkit-line-break: after-white-space;" class="">
        <meta http-equiv="Content-Type" content="text/html;
          charset=utf-8" class="">
        <div style="word-wrap: break-word; -webkit-nbsp-mode: space;
          -webkit-line-break: after-white-space;" class="">
          <meta http-equiv="Content-Type" content="text/html;
            charset=utf-8" class="">
          <div style="word-wrap: break-word; -webkit-nbsp-mode: space;
            -webkit-line-break: after-white-space;" class="">
            <meta http-equiv="Content-Type" content="text/html;
              charset=utf-8" class="">
            <div style="word-wrap: break-word; -webkit-nbsp-mode: space;
              -webkit-line-break: after-white-space;" class="">
              <meta http-equiv="Content-Type" content="text/html;
                charset=utf-8" class="">
              <div style="word-wrap: break-word; -webkit-nbsp-mode:
                space; -webkit-line-break: after-white-space;" class="">
                <meta http-equiv="Content-Type" content="text/html;
                  charset=utf-8" class="">
                <div style="word-wrap: break-word; -webkit-nbsp-mode:
                  space; -webkit-line-break: after-white-space;"
                  class="">
                  <div class="">Anything that is a Number should be
                    performing automatic unboxing to perform literal
                    value comparisons.  I count on this day in and day
                    out.  There is no reason that Number values should
                    ever do anything different.   You can suggest that
                    two Number values which might be typed as Object
                    parameters into a code structure that compares them
                    with ==, will be costly to execute because of
                    runtime type checking.  But, if the developer codes
                    it that way, because they have other Object values
                    which are used in identity comparisons that are
                    logically valid for the code structure, why perform
                    a compile time optimization that invalidates the
                    premise of how identity works against
                    auto-boxing/unboxing?</div>
                  <div class=""><br class="">
                  </div>
                  <div class="">Gregg</div>
                  <br class="">
                  <div class="">
                    <blockquote type="cite" class="">
                      <div class="">On Jul 6, 2017, at 12:52 PM, Gil
                        Tene <<a href="mailto:gil@azul.com" class=""
                          moz-do-not-send="true">gil@azul.com</a>>
                        wrote:</div>
                      <br class="Apple-interchange-newline">
                      <div class="">
                        <meta http-equiv="Content-Type"
                          content="text/html; charset=utf-8" class="">
                        <div dir="auto" class="">
                          <div class="">Hence my suggestion that
                            identity-based operations on instances of
                            value-based classes should throw
                            exceptions... Right now they silently do
                            unpredictable things, and should be avoided
                            in any case (but harder to know/find when
                            you accidentally use them).<br class="">
                            <br class="">
                            Sent from my iPad</div>
                          <div class=""><br class="">
                            On Jul 6, 2017, at 10:46 AM, Alex Otenko
                            <<a
                              href="mailto:oleksandr.otenko@gmail.com"
                              class="" moz-do-not-send="true">oleksandr.otenko@gmail.com</a>>
                            wrote:<br class="">
                            <br class="">
                          </div>
                          <blockquote type="cite" class="">
                            <div class="">Are they subclasses of Object
                              or not? If they are not, no questions. If
                              they are, someone still needs to explain
                              how exactly the “identity based
                              operations” can be avoided safely.
                              <div class=""><br class="">
                              </div>
                              <div class="">List<j.u.Optional> is
                                just a List underneath, and searching
                                for an item may use “identity based
                                operations”, whether you want it or not
                                - depending on what implementation of
                                List you happen to use.<br class="">
                                <div class=""><br class="">
                                </div>
                                <div class="">Alex</div>
                                <div class=""><br class="">
                                  <div class="">
                                    <blockquote type="cite" class="">
                                      <div class="">On 6 Jul 2017, at
                                        17:33, Gil Tene <<a
                                          href="mailto:gil@azul.com"
                                          class=""
                                          moz-do-not-send="true">gil@azul.com</a>>
                                        wrote:</div>
                                      <br
                                        class="Apple-interchange-newline">
                                      <div class="">
                                        <div dir="auto" class="">
                                          <div class=""><span class=""></span></div>
                                          <div class="">
                                            <div class=""><span class=""></span></div>
                                            <div class="">
                                              <div class="">It says: "<span
style="background-color: rgba(255, 255, 255, 0);" class="">Use of such
                                                  identity-sensitive
                                                  operations on
                                                  instances of
                                                  value-based classes
                                                  may have unpredictable
                                                  effects and should be
                                                  avoided." It does not
                                                  say what the reason
                                                  for the unpredictable
                                                  effect may be and WHEN
                                                  you shouldn't use
                                                  identity based
                                                  operations, it warns
                                                  you not to use them
                                                  for any reason
                                                  whatsoever. Can't be
                                                  much more clear than
                                                  that, and you don't
                                                  need to be a JVM or
                                                  compiler implementor
                                                  to understand it. </span>It
                                                means "don't do that".
                                                And "if you do that,
                                                very surprising things
                                                may (or may not)
                                                happen". </div>
                                              <div class=""><br class="">
                                              </div>
                                              <div class="">Acting on a
                                                current understanding
                                                and perception of what
                                                implementations actually
                                                do, and saying "I
                                                thought that what it
                                                really means is that
                                                using identity in some
                                                way X would be
                                                unreliable because of
                                                effect Y, but using
                                                identity in case Z is
                                                ok, because I don't see
                                                why it shouldn't be" is
                                                a wrong reading of this
                                                clear admonition to not
                                                use identity for
                                                anything. Doing so will
                                                come back to bite you,
                                                either now or in the
                                                future.</div>
                                              <div class=""><br class="">
                                              </div>
                                              <div class="">For example,
                                                instances of value-based
                                                classes have the [well
                                                documented] quality of
                                                being "<em
                                                  style="background-color:
                                                  rgba(255, 255, 255,
                                                  0);" class="">freely
                                                  substitutable</em><span
style="background-color: rgba(255, 255, 255, 0);" class=""> </span><span
style="background-color: rgba(255, 255, 255, 0);" class="">when equal,
                                                  meaning that
                                                  interchanging any two
                                                  instances</span><span
style="background-color: rgba(255, 255, 255, 0);" class=""> </span><code
style="background-color: rgba(255, 255, 255, 0); padding-top: 4px;
                                                  margin-top: 8px;
                                                  line-height: 1.4em;"
                                                  class="">x</code><span
style="background-color: rgba(255, 255, 255, 0);" class=""> </span><span
style="background-color: rgba(255, 255, 255, 0);" class="">and</span><span
style="background-color: rgba(255, 255, 255, 0);" class=""> </span><code
style="background-color: rgba(255, 255, 255, 0); padding-top: 4px;
                                                  margin-top: 8px;
                                                  line-height: 1.4em;"
                                                  class="">y</code><span
style="background-color: rgba(255, 255, 255, 0);" class=""> </span><span
style="background-color: rgba(255, 255, 255, 0);" class="">that are
                                                  equal according to</span><span
style="background-color: rgba(255, 255, 255, 0);" class=""> </span><code
style="background-color: rgba(255, 255, 255, 0); padding-top: 4px;
                                                  margin-top: 8px;
                                                  line-height: 1.4em;"
                                                  class="">equals()</code><span
style="background-color: rgba(255, 255, 255, 0);" class=""> </span><span
style="background-color: rgba(255, 255, 255, 0);" class="">in any
                                                  computation or method
                                                  invocation should
                                                  produce no visible
                                                  change in behavior."
                                                  The JVM may (and
                                                  likely will at some
                                                  point will) use this
                                                  quality freely in some
                                                  optimizations, A
                                                  simple and obviously
                                                  valid resulting
                                                  optimization would be
                                                  for == to always be
                                                  evaluated as false
                                                  when the operands are
                                                  instances of
                                                  value-based classes:
                                                  since the JVM *may*
                                                  freely substitute the
                                                  instances of either
                                                  side of the ==
                                                  evaluation with some
                                                  instance that is equal
                                                  according to equals(),
                                                  it can choose to do so
                                                  in all evaluations of
                                                  ==, which would mean
                                                  that the two sides are
                                                  never the same
                                                  instance, and would
                                                  then mean that the JVM
                                                  can treat all code
                                                  that would only
                                                  execute if == were
                                                  true as dead code.
                                                  Similarly, != may
                                                  trivially be evaluated
                                                  as always-true. And
                                                  since these
                                                  optimizations may or
                                                  may not be applied in
                                                  different places and
                                                  times, they may lead
                                                  to </span><span
                                                  style="background-color:
                                                  rgba(255, 255, 255,
                                                  0);" class="">seemingly
                                                  random evaluation of
                                                  == or != for identical
                                                  code on identical data
                                                  (for the exact same,
                                                  unmodified values of a
                                                  and d, a will
                                                  sometimes be equal to
                                                  d and sometimes not,
                                                  and at the same point
                                                  in code, depending on
                                                  mood).</span></div>
                                              <div class=""><span
                                                  style="background-color:
                                                  rgba(255, 255, 255,
                                                  0);" class=""><br
                                                    class="">
                                                </span></div>
                                              <div class=""><span
                                                  style="background-color:
                                                  rgba(255, 255, 255,
                                                  0);" class="">We could
                                                  further discuss
                                                  whether or not the JVM
                                                  is allowed to
                                                  "falsely" indicate
                                                  that == is true (or
                                                  that != is false) even
                                                  when the instances
                                                  differ in value (so
                                                  are not .equals()). It
                                                  is. Doing that may
                                                  certainly surprise
                                                  anyone who uses the
                                                  identity based == for
                                                  anything to do with
                                                  instances of
                                                  value-based classes,
                                                  even tho using it
                                                  would be silly given
                                                  that == might
                                                  obviously be
                                                  always-false. For
                                                  example, I could see
                                                  how someone may
                                                  mistakenly try to use
                                                  == as an
                                                  "optimization" on the
                                                  assumption that if
                                                  they get lucky and ==
                                                  is true, .equals()
                                                  must be true as well,
                                                  and that evaluating ==
                                                  might be cheaper, but
                                                  they would still "do
                                                  the right thing" in
                                                  the != case. But that
                                                  would be a mistake,
                                                  and a clear violation
                                                  of the "don't do that"
                                                  admonition above. The
                                                  cases where the result
                                                  of == can be
                                                  *unpredictable* are
                                                  not limited to cases
                                                  where the JVM freely
                                                  substitutes instances
                                                  for other equal()
                                                  ones, that's just one
                                                  example of how the JVM
                                                  may obviously and
                                                  validly use one known
                                                  quality of value-based
                                                  classes. But another
                                                  key quality of
                                                  instances of value
                                                  based classes is that
                                                  they </span><span
                                                  style="background-color:
                                                  rgba(255, 255, 255,
                                                  0);" class="">"</span><span
style="background-color: rgba(255, 255, 255, 0);" class="">are
                                                  considered equal
                                                  solely based on </span><code
style="background-color: rgba(255, 255, 255, 0); padding-top: 4px;
                                                  margin-top: 8px;
                                                  line-height: 1.4em;"
                                                  class="">equals()</code><span
style="background-color: rgba(255, 255, 255, 0);" class="">, not based
                                                  on reference equality
                                                  (</span><code
                                                  style="background-color:
                                                  rgba(255, 255, 255,
                                                  0); padding-top: 4px;
                                                  margin-top: 8px;
                                                  line-height: 1.4em;"
                                                  class="">==</code><span
style="background-color: rgba(255, 255, 255, 0);" class="">)". </span><span
style="background-color: rgba(255, 255, 255, 0);" class="">There is
                                                  nothing there that
                                                  limits us to "if == is
                                                  true, equals() must be
                                                  true as well". It may
                                                  be convenient to think
                                                  otherwise when wanting
                                                  to explain how
                                                  breaking the rules in
                                                  some specific way is
                                                  still ok (and
                                                  currently seems to
                                                  work). But it's not.
                                                  Bottom line: The JVM
                                                  *may* choose to make
                                                  == always-true.
                                                  Nothing wrong with
                                                  that.</span></div>
                                              <div class=""><span
                                                  style="background-color:
                                                  rgba(255, 255, 255,
                                                  0);" class=""><br
                                                    class="">
                                                </span></div>
                                              <div class=""><span
                                                  style="background-color:
                                                  rgba(255, 255, 255,
                                                  0);" class="">It is
                                                  dangerous (and nearly
                                                  impossible) to deduce
                                                  which optimizations
                                                  may or may not happen
                                                  when they are clearly
                                                  allowed by the
                                                  specified set of rules
                                                  and qualities. The
                                                  defined qualities are
                                                  what matter, and
                                                  optimizations that
                                                  indirectly result from
                                                  the propagation of
                                                  those qualities are
                                                  allowed and may (or
                                                  may  not) happen.
                                                  Instance identity
                                                  either exists or
                                                  doesn't, and instance
                                                  Identity checks either
                                                  have meaning, or they
                                                  don't. If they do,
                                                  certain things follow
                                                  (like .equals() always
                                                  being true if the
                                                  identity of the twin
                                                  instances is the same,
                                                  as tested by ==). If
                                                  they don't, then
                                                  identity checks are
                                                  meaningless, and can
                                                  be discarded or
                                                  conveniently evaluated
                                                  in ways that seem
                                                  profitable.</span></div>
                                              <div class=""><span
                                                  style="background-color:
                                                  rgba(255, 255, 255,
                                                  0);" class=""><br
                                                    class="">
                                                </span></div>
                                              <div class=""><span
                                                  style="background-color:
                                                  rgba(255, 255, 255,
                                                  0);" class="">For
                                                  "instances" of
                                                  value-based classes,
                                                  instance identity does
                                                  not exist.
                                                  Unfortunately, unlike
                                                  value types, where the
                                                  operand == is defined
                                                  to act on value and
                                                  not on identity, the
                                                  operand == is
                                                  undefined for
                                                  instances of
                                                  value-based classes.
                                                  It certainly does not
                                                  mean "if true, the
                                                  identity of these
                                                  things is the same",
                                                  and it certainly
                                                  doesn't mean "if
                                                  false, these things
                                                  are not equal". But it
                                                  also doesn't mean "if
                                                  true, these things are
                                                  equal". It is
                                                  *undefined*, specified
                                                  with "may have
                                                  unpredictable
                                                  effects", and users
                                                  are clearly told not
                                                  to use it for
                                                  anything.</span></div>
                                              <div class=""><span
                                                  style="background-color:
                                                  rgba(255, 255, 255,
                                                  0);" class=""><br
                                                    class="">
                                                </span></div>
                                              <div class=""><span
                                                  style="background-color:
                                                  rgba(255, 255, 255,
                                                  0);" class="">One can
                                                  argue that the spec
                                                  should change, e.g.
                                                  add a statement that
                                                  would have the effect
                                                  of requiring "if == is
                                                  true then .equals() is
                                                  also true", and would
                                                  prevent or limit
                                                  certain unpredictable
                                                  effects when
                                                  considering the
                                                  identity of
                                                  identity-less things,
                                                  but I suspect that
                                                  writing that down in
                                                  actual words would be
                                                  painful given the
                                                  necessary "there is no
                                                  meaning to identify,
                                                  but..." logic. We
                                                  could also look to
                                                  redefine the meaning
                                                  of certain operands,
                                                  e.g. == and != can be
                                                  dealt with as they are
                                                  in value types, but
                                                  compare in
                                                  compareAndSet is more
                                                  challenging...</span></div>
                                              <div class=""><span
                                                  style="background-color:
                                                  rgba(255, 255, 255,
                                                  0);" class=""><br
                                                    class="">
                                                </span></div>
                                              <div class=""><span
                                                  style="background-color:
                                                  rgba(255, 255, 255,
                                                  0);" class="">This is
                                                  [partly] why I think
                                                  that throwing an
                                                  exception (or even a
                                                  compile-time error
                                                  where possible) when
                                                  encountering == or !=
                                                  operations (and any of
                                                  the other undefined
                                                  behavior ones) on
                                                  instances of
                                                  value-based classes is
                                                  a good idea, and
                                                  something that should
                                                  start happening ASAP.
                                                  Any such operation is
                                                  wrong (literally) by
                                                  definition, and the
                                                  "may have
                                                  unpredictable effects"
                                                  statement in the spec
                                                  is certainly wide
                                                  enough to allow
                                                  exception throwing. It
                                                  is wide enough to
                                                  allow much worse
                                                  things to happen, and
                                                  silent unpredictable
                                                  and undefined
                                                  behavior, while
                                                  allowed, is worse than
                                                  preventing the code
                                                  from executing. The
                                                  same way we wouldn't
                                                  argue that
                                                  synchronized(int)
                                                  should simply be
                                                  "undefined" but
                                                  silently allowed to
                                                  run with unpredictable
                                                  effects, we shouldn't
                                                  argue that
                                                  synchronized(LocalDateTime)
                                                  should.</span></div>
                                              <div class=""><br class="">
                                              </div>
                                              <div class="">
                                                <div class="">Sent from
                                                  my iPad</div>
                                              </div>
                                              <div class=""><br class="">
                                                On Jul 6, 2017, at 3:04
                                                AM, Alex Otenko <<a
                                                  href="mailto:oleksandr.otenko@gmail.com"
                                                  class=""
                                                  moz-do-not-send="true">oleksandr.otenko@gmail.com</a>>
                                                wrote:<br class="">
                                                <br class="">
                                              </div>
                                              <blockquote type="cite"
                                                class="">
                                                <div class="">:-) the
                                                  one causing Byzantine
                                                  failures!
                                                  <div class=""><br
                                                      class="">
                                                  </div>
                                                  <div class="">Given
                                                    how underspecified
                                                    the things generally
                                                    are, and that the
                                                    target audience of
                                                    such javadoc is not
                                                    a JVM implementor,
                                                    we shouldn’t read
                                                    too much into the
                                                    possible freedoms
                                                    the vague wording
                                                    seems to imply. It
                                                    shouldn’t suddenly
                                                    break the promises
                                                    about identity
                                                    equality for
                                                    specific instances.</div>
                                                  <div class=""><br
                                                      class="">
                                                  </div>
                                                  <div class="">All it’s
                                                    saying is that, like
                                                    Integer.from(10) may
                                                    or may not return
                                                    the same instance.
                                                    It may or may not
                                                    work the same way
                                                    throughout the JVM’s
                                                    lifetime, allowing
                                                    the implementors to
                                                    choose suitable
                                                    caching strategies,
                                                    code optimizations,
                                                    etc - <b class="">therefore</b> should
                                                    not rely on
                                                    comparing
                                                    identities, and
                                                    such; for example,
                                                    synchronized(Integer.from(10))
                                                    does not guarantee
                                                    neither lock
                                                    freedom, nor
                                                    deadlock freedom. It
                                                    should not say that
                                                    suddenly it is
                                                    unsafe to compare
                                                    identities (like Gil
                                                    suggests JVM could
                                                    start throwing
                                                    exceptions). It
                                                    should not say that
                                                    suddenly we
                                                    shouldn’t be able to
                                                    CAS (like Gil says
                                                    suddenly the
                                                    reference to
                                                    instance can
                                                    sneakily be replaced
                                                    with something
                                                    else).<br class="">
                                                    <div class=""><br
                                                        class="">
                                                    </div>
                                                    <div class=""><br
                                                        class="">
                                                    </div>
                                                    <div class="">Alex<br
                                                        class="">
                                                      <div class=""><br
                                                          class="">
                                                      </div>
                                                      <div class=""><br
                                                          class="">
                                                        <div class="">
                                                          <blockquote
                                                          type="cite"
                                                          class="">
                                                          <div class="">On
                                                          6 Jul 2017, at
                                                          10:12,
                                                          Millies,
                                                          Sebastian <<a
href="mailto:Sebastian.Millies@softwareag.com" class=""
                                                          moz-do-not-send="true">Sebastian.Millies@softwareag.com</a>>
                                                          wrote:</div>
                                                          <br
                                                          class="Apple-interchange-newline">
                                                          <div class="">
                                                          <div
                                                          class="WordSection1"
                                                          style="page:
                                                          WordSection1;
                                                          font-family:
                                                          Helvetica;
                                                          font-size:
                                                          12px;
                                                          font-style:
                                                          normal;
                                                          font-variant:
                                                          normal;
                                                          font-weight:
                                                          normal;
                                                          letter-spacing:
                                                          normal;
                                                          line-height:
                                                          normal;
                                                          orphans: auto;
                                                          text-align:
                                                          start;
                                                          text-indent:
                                                          0px;
                                                          text-transform:
                                                          none;
                                                          white-space:
                                                          normal;
                                                          widows: auto;
                                                          word-spacing:
                                                          0px;
                                                          -webkit-text-stroke-width:
                                                          0px;">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          <span
                                                          style="font-size:
                                                          11pt;
                                                          font-family:
                                                          Calibri,
                                                          sans-serif;
                                                          color: rgb(31,
                                                          73, 125);"
                                                          class="">just
                                                          out of
                                                          curiosity: I
                                                          am familiar
                                                          with the term
                                                          “Byzantine
                                                          failure”, but
                                                          what is a
                                                          “Byzantine
                                                          optimization”?<o:p
                                                          class=""></o:p></span></div>
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt 36pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman', serif;
                                                          text-indent:
                                                          -18pt;"
                                                          class="">
                                                          <span
                                                          style="font-size:
                                                          inherit;
                                                          font-family:
                                                          inherit;
                                                          color: rgb(31,
                                                          73, 125);"
                                                          class=""><span
                                                          class="">■<span
style="font-style: normal; font-variant: normal; font-weight: normal;
                                                          font-size:
                                                          7pt;
                                                          line-height:
                                                          normal;
                                                          font-family:
                                                          'Times New
                                                          Roman';"
                                                          class=""> <span
class="Apple-converted-space"> </span></span></span></span><span
                                                          style="font-size:
                                                          11pt;
                                                          font-family:
                                                          Calibri,
                                                          sans-serif;
                                                          color: rgb(31,
                                                          73, 125);"
                                                          class="">Sebastian<o:p
                                                          class=""></o:p></span></div>
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          <o:p class=""> </o:p></div>
                                                          <div class="">
                                                          <div
                                                          style="border-style:
                                                          solid none
                                                          none;
                                                          border-top-color:
                                                          rgb(181, 196,
                                                          223);
                                                          border-top-width:
                                                          1pt; padding:
                                                          3pt 0cm 0cm;"
                                                          class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          <b class=""><span
style="font-size: 10pt; font-family: Tahoma, sans-serif;" class=""
                                                          lang="DE">From:</span></b><span
style="font-size: 10pt; font-family: Tahoma, sans-serif;" class=""
                                                          lang="DE"><span
class="Apple-converted-space"> </span>Concurrency-interest [<a
                                                          href="mailto:concurrency-interest-bounces@cs.oswego.edu"
                                                          class=""
                                                          moz-do-not-send="true">mailto:concurrency-interest-bounces@cs.oswego.edu</a>]<span
class="Apple-converted-space"> </span><b class="">On Behalf Of<span
                                                          class="Apple-converted-space"> </span></b>Alex
                                                          Otenko<br
                                                          class="">
                                                          <b class="">Sent:</b><span
class="Apple-converted-space"> </span>Thursday, July 06, 2017 10:17 AM<br
                                                          class="">
                                                          <b class="">To:</b><span
class="Apple-converted-space"> </span>Gil Tene<br class="">
                                                          <b class="">Cc:</b><span
class="Apple-converted-space"> </span><a
                                                          href="mailto:concurrency-interest@cs.oswego.edu"
                                                          class=""
                                                          moz-do-not-send="true">concurrency-interest@cs.oswego.edu</a><br
                                                          class="">
                                                          <b class="">Subject:</b><span
class="Apple-converted-space"> </span>Re: [concurrency-interest] Should
                                                          I avoid
                                                          compareAndSet
                                                          with
                                                          value-based
                                                          classes?<o:p
                                                          class=""></o:p></span></div>
                                                          </div>
                                                          </div>
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          <o:p class=""> </o:p></div>
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          <o:p class=""> </o:p></div>
                                                          <div class="">
                                                          <blockquote
                                                          style="margin-top:
                                                          5pt;
                                                          margin-bottom:
                                                          5pt;" class="">
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          On 6 Jul 2017,
                                                          at 08:47, Gil
                                                          Tene <<a
                                                          href="mailto:gil@azul.com"
                                                          style="color:
                                                          purple;
                                                          text-decoration:
                                                          underline;"
                                                          class=""
                                                          moz-do-not-send="true">gil@azul.com</a>>
                                                          wrote:<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          <o:p class=""> </o:p></div>
                                                          <div class="">
                                                          <div class="">
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          <br class="">
                                                          <br class="">
                                                          Sent from my
                                                          iPad<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <p
                                                          class="MsoNormal"
                                                          style="margin:
                                                          0cm 0cm 12pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;">
                                                          <br class="">
                                                          On Jul 6,
                                                          2017, at 12:38
                                                          AM, Alex
                                                          Otenko <<a
href="mailto:oleksandr.otenko@gmail.com" style="color: purple;
                                                          text-decoration:
                                                          underline;"
                                                          class=""
                                                          moz-do-not-send="true">oleksandr.otenko@gmail.com</a>>
                                                          wrote:<o:p
                                                          class=""></o:p></p>
                                                          </div>
                                                          <blockquote
                                                          style="margin-top:
                                                          5pt;
                                                          margin-bottom:
                                                          5pt;" class="">
                                                          <div class="">
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          All it is
                                                          saying is:<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          <o:p class=""> </o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                           
                                                          LocalDateTime
                                                          a =
                                                          LocalDateTime.parse("2007-12-03T10:15:30");<br
                                                          class="">
                                                           
                                                          LocalDateTime
                                                          b =
                                                          LocalDateTime.parse("2007-12-03T10:15:30");<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                           
                                                          LocalDateTime
                                                          c =
                                                          LocalDateTime.parse("2007-12-03T10:15:30");<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          <o:p class=""> </o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          a==b
                                                          &&
                                                          b==c can be
                                                          true and can
                                                          be false<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          </div>
                                                          </blockquote>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          <o:p class=""> </o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          It also means
                                                          that even
                                                          when:<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          <o:p class=""> </o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                           
                                                          LocalDateTime
                                                          d = a;<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                            ...<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                            (a == d) may
                                                          or may not be
                                                          true. And may
                                                          change whether
                                                          it is true or
                                                          not at any
                                                          time,<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          </div>
                                                          </div>
                                                          </blockquote>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          <o:p class=""> </o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          I meant an
                                                          even stronger
                                                          assertion:<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          <o:p class=""> </o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          assert (a==b)
                                                          == (b==a) :
                                                          "No Byzantine
                                                          optimizations"<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          assert (a==d)
                                                          == (a==d): “No
                                                          Byzantine
                                                          optimizations"<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          <o:p class=""> </o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          Alex<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          <o:p class=""> </o:p></div>
                                                          </div>
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          <br class="">
                                                          <br class="">
                                                          <o:p class=""></o:p></div>
                                                          <div class="">
                                                          <div class="">
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          <o:p class=""> </o:p></div>
                                                          </div>
                                                          <blockquote
                                                          style="margin-top:
                                                          5pt;
                                                          margin-bottom:
                                                          5pt;" class="">
                                                          <div class="">
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          <o:p class=""> </o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          Alex<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          <o:p class=""> </o:p></div>
                                                          <div class="">
                                                          <blockquote
                                                          style="margin-top:
                                                          5pt;
                                                          margin-bottom:
                                                          5pt;" class="">
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          On 6 Jul 2017,
                                                          at 08:28, Gil
                                                          Tene <<a
                                                          href="mailto:gil@azul.com"
                                                          style="color:
                                                          purple;
                                                          text-decoration:
                                                          underline;"
                                                          class=""
                                                          moz-do-not-send="true">gil@azul.com</a>>
                                                          wrote:<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          <o:p class=""> </o:p></div>
                                                          <div class="">
                                                          <div class="">
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          <br class="">
                                                          <br class="">
                                                          Sent from my
                                                          iPad<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <p
                                                          class="MsoNormal"
                                                          style="margin:
                                                          0cm 0cm 12pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;">
                                                          <br class="">
                                                          On Jul 5,
                                                          2017, at 11:51
                                                          PM, Henrik
                                                          Johansson <<a
href="mailto:dahankzter@gmail.com" style="color: purple;
                                                          text-decoration:
                                                          underline;"
                                                          class=""
                                                          moz-do-not-send="true">dahankzter@gmail.com</a>>
                                                          wrote:<o:p
                                                          class=""></o:p></p>
                                                          </div>
                                                          <blockquote
                                                          style="margin-top:
                                                          5pt;
                                                          margin-bottom:
                                                          5pt;" class="">
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          Oh, without
                                                          having
                                                          followed the
                                                          value type
                                                          discussions I
                                                          think it was a
                                                          mistake to not
                                                          "fix"
                                                          equality. Why
                                                          not make it a
                                                          deep
                                                          comparison if
                                                          the reference
                                                          is different?
                                                          If it points
                                                          to the same
                                                          object we are
                                                          done otherwise
                                                          start checking
                                                          the struct
                                                          content.<span
class="Apple-converted-space"> </span><o:p class=""></o:p></div>
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          There may be a
                                                          lot I missed
                                                          here but a new
                                                          type of object
                                                          could be
                                                          allowed to
                                                          have different
                                                          meaning
                                                          equality.
                                                          Right?<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          </blockquote>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          .equals()
                                                          means what you
                                                          want it to
                                                          mean. == and
                                                          != (and the
                                                          compare in
                                                          compareAndSet)
                                                          mean very
                                                          specific
                                                          things, and
                                                          cannot be
                                                          overridden.<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          <o:p class=""> </o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          For
                                                          non-reference
                                                          value types
                                                          (int, long,
                                                          char, etc.),
                                                          == and != are
                                                          value
                                                          comparisons.
                                                          An int has no
                                                          identity. Just
                                                          a value:<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                            int a = 5;<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                            int b = 5;<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                            boolean y =
                                                          (a == b);  //
                                                          true<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          <o:p class=""> </o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          For references
                                                          to instances
                                                          of (non
                                                          value-based)
                                                          classes, ==
                                                          and != can be
                                                          thought of as
                                                          comparing the
                                                          value of the
                                                          reference (and
                                                          not the
                                                          contents of
                                                          the object
                                                          instances).
                                                          This is an
                                                          identity
                                                          comparison,
                                                          which ignores
                                                          values within
                                                          the object:<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                            Integer a =
                                                          new
                                                          Integer(5);<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                            Integer b =
                                                          new
                                                          Integer(5);<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                            boolean x =
                                                          a.equals(b);  
                                                          // true<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                            boolean y =
                                                          (a == b);   //
                                                          false<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          <o:p class=""> </o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          And for
                                                          references to
                                                          value-based
                                                          classes (which
                                                          is a
                                                          relatively new
                                                          thing, but is
                                                          part of Java
                                                          8), the
                                                          meaning of ==
                                                          and != appears
                                                          to be
                                                          undefined.
                                                          E.g.:<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          <o:p class=""> </o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
  LocalDateTime a = LocalDateTime.parse("2007-12-03T10:15:30");<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
  LocalDateTime b = LocalDateTime.parse("2007-12-03T10:15:30");<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                            boolean x =
                                                          a.equals(b);  
                                                          // true<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                            boolean y
                                                          = (a == b);  
                                                          //
                                                          unpredictable,
                                                          undefined, who
                                                          knows. <o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                                       
                                                                       
                                                                     
                                                           // Could be
                                                          true, could be
                                                          false.<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                                       
                                                                       
                                                                     
                                                           // Could
                                                          theoretically change
                                                          the values of
                                                          a or b, or of
                                                          something else<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          </div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          <o:p class=""> </o:p></div>
                                                          </div>
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          <br class="">
                                                          <br class="">
                                                          <o:p class=""></o:p></div>
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          <o:p class=""> </o:p></div>
                                                          <div class="">
                                                          <div class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          On Thu, 6 Jul
                                                          2017, 07:12
                                                          Gil Tene, <<a
href="mailto:gil@azul.com" style="color: purple; text-decoration:
                                                          underline;"
                                                          class=""
                                                          moz-do-not-send="true">gil@azul.com</a>>
                                                          wrote:<o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          <blockquote
                                                          style="border-style:
                                                          none none none
                                                          solid;
                                                          border-left-color:
                                                          rgb(204, 204,
                                                          204);
                                                          border-left-width:
                                                          1pt; padding:
                                                          0cm 0cm 0cm
                                                          6pt;
                                                          margin-left:
                                                          4.8pt;
                                                          margin-right:
                                                          0cm;" class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          <br class="">
                                                          I'd take that
                                                          documentation
                                                          seriously. It
                                                          basically says
                                                          that ==, !=,
                                                          synchronization,
                                                          identity
                                                          hashing, and
                                                          serialization
                                                          are undefined
                                                          behaviors.<br
                                                          class="">
                                                          <br class="">
                                                          While the
                                                          *current*
                                                          implementations
                                                          may carry some
                                                          semi-intuitive
                                                          behvaiors,
                                                          e.g. where ==
                                                          indicates true
                                                          when comparing
                                                          two references
                                                          to instances
                                                          of a
                                                          value-based
                                                          class where
                                                          the value of
                                                          the references
                                                          is the same,
                                                          there is no
                                                          guarantee that
                                                          at some point
                                                          in the [near
                                                          or far] future
                                                          that behavior
                                                          will remain.
                                                          Specifically,
                                                          attempting ==
                                                          (or !=, or
                                                          synchronization,
                                                          etc.,
                                                          including
                                                          compareAndSet)
                                                          on a reference
                                                          to a value
                                                          based class is
                                                          allowed to do
                                                          ANYTHING in
                                                          the future.<br
                                                          class="">
                                                          For example:<br
                                                          class="">
                                                          - It may throw
                                                          an exception
                                                          (something it
                                                          should
                                                          probably start
                                                          doing ASAP to
                                                          avoid future
                                                          surprises).<br
                                                          class="">
                                                          - It may
                                                          return
                                                          always-false,
                                                          even when the
                                                          two references
                                                          are "to the
                                                          same instance"
                                                          (and probably
                                                          will, through
                                                          many possible
                                                          value-based
                                                          compiler
                                                          optimizations
                                                          that will
                                                          erase the
                                                          unneeded
                                                          notion of
                                                          reference and
                                                          identity).<br
                                                          class="">
                                                          - It may
                                                          overwrite
                                                          random
                                                          locations in
                                                          memory or to
                                                          variables that
                                                          the code
                                                          performing the
                                                          operation has
                                                          the privilege
                                                          to write to
                                                          (which it
                                                          probably
                                                          shouldn't, but
                                                          that's
                                                          certainly
                                                          included in
                                                          what
                                                          "undefined"
                                                          and
                                                          "unpredictable
                                                          effects" can
                                                          mean).<br
                                                          class="">
                                                          - It may
                                                          sometimes do
                                                          one of the
                                                          above, and
                                                          sometimes seem
                                                          to be doing
                                                          what you mean
                                                          it to do.
                                                          Switching
                                                          between modes
                                                          on a whim
                                                          (e.g. when a
                                                          tier 2
                                                          optimizing
                                                          compilation is
                                                          applied, or
                                                          when the
                                                          mutton is nice
                                                          and lean and
                                                          the tomato is
                                                          ripe).<br
                                                          class="">
                                                          <br class="">
                                                          So no, there
                                                          is no way for
                                                          compareAndSet
                                                          to work
                                                          "correctly" on
                                                          a reference to
                                                          an instance of
                                                          a value-based
                                                          class. Even if
                                                          it happens to
                                                          appear to work
                                                          "correctly"
                                                          now, expect it
                                                          to blow up in
                                                          bad and
                                                          potentially
                                                          silent ways in
                                                          the future.<br
                                                          class="">
                                                          <br class="">
                                                          — Gil.<br
                                                          class="">
                                                          <br class="">
                                                          > On Jul 5,
                                                          2017, at 9:47
                                                          PM, Brian S
                                                          O'Neill <<a
href="mailto:bronee@gmail.com" target="_blank" style="color: purple;
                                                          text-decoration:
                                                          underline;"
                                                          class=""
                                                          moz-do-not-send="true">bronee@gmail.com</a>>
                                                          wrote:<br
                                                          class="">
                                                          ><br
                                                          class="">
                                                          > I think
                                                          the wording in
                                                          the
                                                          value-based
                                                          document is
                                                          too strong.
                                                          It's perfectly
                                                          fine to
                                                          compare value
                                                          based
                                                          instances
                                                          using ==, but
                                                          it can lead to
                                                          confusing
                                                          results when
                                                          comparing
                                                          distinct
                                                          instances with
                                                          equivalent
                                                          state. Using
                                                          compareAndSet
                                                          with a box
                                                          isn't
                                                          necessary for
                                                          it to work
                                                          "correctly"
                                                          with a
                                                          value-based
                                                          class.<br
                                                          class="">
                                                          ><br
                                                          class="">
                                                          > By
                                                          "correctly", I
                                                          mean the
                                                          compareAndSet
                                                          operation
                                                          works
                                                          correctly,
                                                          using ==
                                                          comparison.
                                                          However, if
                                                          your intention
                                                          is for
                                                          compareAndSet
                                                          to compare
                                                          Instants based
                                                          on their
                                                          state, then
                                                          this of course
                                                          won't work
                                                          properly.<br
                                                          class="">
                                                          ><br
                                                          class="">
                                                          > If you
                                                          want to
                                                          perform a
                                                          compareAndSet
                                                          for an
                                                          Instant's
                                                          state (time
                                                          since epoch),
                                                          then you need
                                                          to use
                                                          something that
                                                          can be
                                                          compared
                                                          atomically.
                                                          This means the
                                                          state must be
                                                          representable
                                                          in a 64-bit
                                                          value or
                                                          smaller. The
                                                          Instant class
                                                          measures time
                                                          using a 64-bit
                                                          long and a
                                                          32-bit int,
                                                          and so this
                                                          state cannot
                                                          be compared
                                                          atomically.
                                                          You'd have to
                                                          chop off some
                                                          precision or
                                                          use something
                                                          else.<br
                                                          class="">
                                                          ><br
                                                          class="">
                                                          ><br
                                                          class="">
                                                          > On
                                                          2017-07-05
                                                          09:20 PM, Gil
                                                          Tene wrote:<br
                                                          class="">
                                                          >>
                                                          Reference
                                                          equality for
                                                          value based
                                                          classes (as
                                                          referenced
                                                          below) lacks
                                                          meaning, as
                                                          there is no
                                                          notion of
                                                          identity in
                                                          such classes
                                                          (only a notion
                                                          of value). And
                                                          since
                                                          compareAndSet
                                                          on reference
                                                          fields is
                                                          basically an
                                                          idenitity-based
                                                          operation [in
                                                          the compare
                                                          part], the two
                                                          won't mix well
                                                          logically.<br
                                                          class="">
                                                          >>
                                                          Specifically,
                                                          while two
                                                          references to
                                                          e.g.
                                                          java.time.LocalDateTime
                                                          instances
                                                          being == to
                                                          each other
                                                          *probably*
                                                          means that the
                                                          two are
                                                          actually equal
                                                          in value, the
                                                          opposite is
                                                          not true:
                                                          Being != to
                                                          each other
                                                          does NOT mean
                                                          that they are
                                                          logically
                                                          different. As
                                                          such, the
                                                          "compare" part
                                                          in
                                                          compareAndSet
                                                          may falsely
                                                          fail even when
                                                          the two
                                                          instances are
                                                          logically
                                                          equal to each
                                                          other, leaving
                                                          the rest of
                                                          your logic
                                                          potentially
                                                          exposed.<br
                                                          class="">
                                                          >>
                                                          Bottom line:
                                                          given the
                                                          explicit
                                                          warning to not
                                                          use == and !=
                                                          on references
                                                          to value-based
                                                          instances, I'd
                                                          avoid using
                                                          compareAndSet
                                                          on those
                                                          references. If
                                                          you really
                                                          need to use a
                                                          value-based
                                                          class in your
                                                          logic,
                                                          consider
                                                          boxing it in
                                                          another object
                                                          that has
                                                          [normal]
                                                          identity.<br
                                                          class="">
                                                          >> —
                                                          Gil.<br
                                                          class="">
                                                          >>>
                                                          On Jul 5,
                                                          2017, at 8:59
                                                          PM, Michael
                                                          Hixson <<a
href="mailto:michael.hixson@gmail.com" target="_blank" style="color:
                                                          purple;
                                                          text-decoration:
                                                          underline;"
                                                          class=""
                                                          moz-do-not-send="true">michael.hixson@gmail.com</a>>
                                                          wrote:<br
                                                          class="">
                                                          >>><br
                                                          class="">
                                                          >>>
                                                          AtomicReference
                                                          and VarHandle
                                                          are specified
                                                          to use == in
                                                          compareAndSet<br
                                                          class="">
                                                          >>>
                                                          (and related)
                                                          operations
                                                          [1].  Using ==
                                                          to compare
                                                          instances of<br
                                                          class="">
                                                          >>>
                                                          value-based
                                                          classes may
                                                          lead to
                                                          "unpredictable
                                                          results" [2]. 
                                                          Does<br
                                                          class="">
                                                          >>>
                                                          this mean I
                                                          should avoid
                                                          using
                                                          compareAndSet
                                                          with arguments
                                                          that are<br
                                                          class="">
                                                          >>>
                                                          instances of
                                                          value-based
                                                          classes?<br
                                                          class="">
                                                          >>><br
                                                          class="">
                                                          >>>
                                                          It seems like
                                                          the
                                                          documentation
                                                          clearly tells
                                                          me "yes, avoid
                                                          doing<br
                                                          class="">
                                                          >>>
                                                          that" but I'm
                                                          hoping I
                                                          misunderstood,
                                                          or maybe
                                                          AtomicReference
                                                          and<br
                                                          class="">
                                                          >>>
                                                          VarHandle are
                                                          exempt
                                                          somehow. 
                                                          Otherwise, how
                                                          do I implement<br
                                                          class="">
                                                          >>>
                                                          non-broken
                                                          compareAndSet
                                                          and
                                                          updateAndGet
                                                          for a
                                                          java.time.Instant<br
                                                          class="">
                                                          >>>
                                                          value for
                                                          example?  Do I
                                                          have to box
                                                          the value in
                                                          something
                                                          that's not<br
                                                          class="">
                                                          >>> a
                                                          value-based
                                                          class first,
                                                          like
                                                          AtomicReference<Box<Instant>>?<br
                                                          class="">
                                                          >>><br
                                                          class="">
                                                          >>>
                                                          -Michael<br
                                                          class="">
                                                          >>><br
                                                          class="">
                                                          >>>
                                                          [1]<span
                                                          class="Apple-converted-space"> </span><a
href="http://download.java.net/java/jdk9/docs/api/java/util/concurrent/atomic/AtomicReference.html#compareAndSet-V-V-"
target="_blank" style="color: purple; text-decoration: underline;"
                                                          class=""
                                                          moz-do-not-send="true">http://download.java.net/java/jdk9/docs/api/java/util/concurrent/atomic/AtomicReference.html#compareAndSet-V-V-</a><br
                                                          class="">
                                                          >>>
                                                          [2]<span
                                                          class="Apple-converted-space"> </span><a
href="http://download.java.net/java/jdk9/docs/api/java/lang/doc-files/ValueBased.html"
target="_blank" style="color: purple; text-decoration: underline;"
                                                          class=""
                                                          moz-do-not-send="true">http://download.java.net/java/jdk9/docs/api/java/lang/doc-files/ValueBased.html</a><br
                                                          class="">
                                                          ><br
                                                          class="">
                                                          >
                                                          _______________________________________________<br
                                                          class="">
                                                          >
                                                          Concurrency-interest
                                                          mailing list<br
                                                          class="">
                                                          ><span
                                                          class="Apple-converted-space"> </span><a
href="mailto:Concurrency-interest@cs.oswego.edu" target="_blank"
                                                          style="color:
                                                          purple;
                                                          text-decoration:
                                                          underline;"
                                                          class=""
                                                          moz-do-not-send="true">Concurrency-interest@cs.oswego.edu</a><br
                                                          class="">
                                                          ><span
                                                          class="Apple-converted-space"> </span><a
href="http://cs.oswego.edu/mailman/listinfo/concurrency-interest"
                                                          target="_blank"
                                                          style="color:
                                                          purple;
                                                          text-decoration:
                                                          underline;"
                                                          class=""
                                                          moz-do-not-send="true">http://cs.oswego.edu/mailman/listinfo/concurrency-interest</a><br
                                                          class="">
                                                          <br class="">
_______________________________________________<br class="">
Concurrency-interest mailing list<br class="">
                                                          <a
                                                          href="mailto:Concurrency-interest@cs.oswego.edu"
target="_blank" style="color: purple; text-decoration: underline;"
                                                          class=""
                                                          moz-do-not-send="true">Concurrency-interest@cs.oswego.edu</a><br
                                                          class="">
                                                          <a
                                                          href="http://cs.oswego.edu/mailman/listinfo/concurrency-interest"
target="_blank" style="color: purple; text-decoration: underline;"
                                                          class=""
                                                          moz-do-not-send="true">http://cs.oswego.edu/mailman/listinfo/concurrency-interest</a><o:p
                                                          class=""></o:p></div>
                                                          </blockquote>
                                                          </div>
                                                          </div>
                                                          </div>
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
_______________________________________________<br class="">
Concurrency-interest mailing list<br class="">
                                                          <a
                                                          href="mailto:Concurrency-interest@cs.oswego.edu"
                                                          style="color:
                                                          purple;
                                                          text-decoration:
                                                          underline;"
                                                          class=""
                                                          moz-do-not-send="true">Concurrency-interest@cs.oswego.edu</a><br
                                                          class="">
                                                          <a
                                                          href="http://cs.oswego.edu/mailman/listinfo/concurrency-interest"
                                                          style="color:
                                                          purple;
                                                          text-decoration:
                                                          underline;"
                                                          class=""
                                                          moz-do-not-send="true">http://cs.oswego.edu/mailman/listinfo/concurrency-interest</a><o:p
                                                          class=""></o:p></div>
                                                          </div>
                                                          </blockquote>
                                                          </div>
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          <o:p class=""> </o:p></div>
                                                          </div>
                                                          </blockquote>
                                                          </div>
                                                          </div>
                                                          </div>
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          <o:p class=""> </o:p></div>
                                                          </div>
                                                          <br
                                                          style="font-family:
                                                          Helvetica;
                                                          font-size:
                                                          12px;
                                                          font-style:
                                                          normal;
                                                          font-variant:
                                                          normal;
                                                          font-weight:
                                                          normal;
                                                          letter-spacing:
                                                          normal;
                                                          line-height:
                                                          normal;
                                                          orphans: auto;
                                                          text-align:
                                                          start;
                                                          text-indent:
                                                          0px;
                                                          text-transform:
                                                          none;
                                                          white-space:
                                                          normal;
                                                          widows: auto;
                                                          word-spacing:
                                                          0px;
                                                          -webkit-text-stroke-width:
                                                          0px;" class="">
                                                          <div
                                                          style="font-family:
                                                          Helvetica;
                                                          font-size:
                                                          12px;
                                                          font-style:
                                                          normal;
                                                          font-variant:
                                                          normal;
                                                          font-weight:
                                                          normal;
                                                          letter-spacing:
                                                          normal;
                                                          line-height:
                                                          normal;
                                                          orphans: auto;
                                                          text-indent:
                                                          0px;
                                                          text-transform:
                                                          none;
                                                          white-space:
                                                          normal;
                                                          widows: auto;
                                                          word-spacing:
                                                          0px;
                                                          -webkit-text-stroke-width:
                                                          0px;" class=""
                                                          align="center">
                                                          <table
                                                          class="MsoNormalTable"
                                                          style="width:
                                                          836px; border:
                                                          1pt outset
                                                          rgb(102, 102,
                                                          102);"
                                                          cellspacing="0"
cellpadding="0" width="100%" border="1">
                                                          <tbody
                                                          class="">
                                                          <tr class="">
                                                          <td
                                                          style="border:
                                                          1pt inset
                                                          rgb(102, 102,
                                                          102); padding:
                                                          3.75pt;"
                                                          class="">
                                                          <div
                                                          style="margin:
                                                          0cm 0cm
                                                          0.0001pt;
                                                          font-size:
                                                          12pt;
                                                          font-family:
                                                          'Times New
                                                          Roman',
                                                          serif;"
                                                          class="">
                                                          <span
                                                          style="font-size:
                                                          8pt;
                                                          font-family:
                                                          'Trebuchet
                                                          MS',
                                                          sans-serif;
                                                          color: gray;"
                                                          class="">Software
                                                          AG –
                                                          Sitz/Registered
                                                          office:
                                                          Uhlandstraße
                                                          12, 64297
                                                          Darmstadt,
                                                          Germany –
                                                          Registergericht/Commercial
                                                          register:
                                                          Darmstadt HRB
                                                          1562 -
                                                          Vorstand/Management
                                                          Board:
                                                          Karl-Heinz
                                                          Streibich
                                                          (Vorsitzender/Chairman),
                                                          Eric Duffaut,
                                                          Dr. Wolfram
                                                          Jost, Arnd
                                                          Zinnhardt, Dr.
                                                          Stefan Sigg; -
Aufsichtsratsvorsitzender/Chairman of the Supervisory Board: Dr. Andreas
                                                          Bereczky -<span
class="Apple-converted-space"> </span></span><a
                                                          href="http://www.softwareag.com/"
                                                          style="color:
                                                          purple;
                                                          text-decoration:
                                                          underline;"
                                                          class=""
                                                          moz-do-not-send="true"><b
                                                          class=""><span
style="font-size: 8pt; font-family: 'Trebuchet MS', sans-serif; color:
                                                          navy;"
                                                          class="">http://www.softwareag.com</span></b></a></div>
                                                          </td>
                                                          </tr>
                                                          </tbody>
                                                          </table>
                                                          </div>
                                                          </div>
                                                          </blockquote>
                                                        </div>
                                                        <br class="">
                                                      </div>
                                                    </div>
                                                  </div>
                                                </div>
                                              </blockquote>
                                              <blockquote type="cite"
                                                class="">
                                                <div class=""><span
                                                    class="">_______________________________________________</span><br
                                                    class="">
                                                  <span class="">Concurrency-interest
                                                    mailing list</span><br
                                                    class="">
                                                  <span class=""><a
                                                      href="mailto:Concurrency-interest@cs.oswego.edu"
                                                      class=""
                                                      moz-do-not-send="true">Concurrency-interest@cs.oswego.edu</a></span><br
                                                    class="">
                                                  <span class=""><a
                                                      href="http://cs.oswego.edu/mailman/listinfo/concurrency-interest"
                                                      class=""
                                                      moz-do-not-send="true">http://cs.oswego.edu/mailman/listinfo/concurrency-interest</a></span><br
                                                    class="">
                                                </div>
                                              </blockquote>
                                            </div>
                                          </div>
                                        </div>
                                      </div>
                                    </blockquote>
                                  </div>
                                  <br class="">
                                </div>
                              </div>
                            </div>
                          </blockquote>
                        </div>
                        _______________________________________________<br
                          class="">
                        Concurrency-interest mailing list<br class="">
                        <a
                          href="mailto:Concurrency-interest@cs.oswego.edu"
                          class="" moz-do-not-send="true">Concurrency-interest@cs.oswego.edu</a><br
                          class="">
                        <a
                          href="http://cs.oswego.edu/mailman/listinfo/concurrency-interest"
                          class="" moz-do-not-send="true">http://cs.oswego.edu/mailman/listinfo/concurrency-interest</a><br
                          class="">
                      </div>
                    </blockquote>
                  </div>
                  <br class="">
                </div>
              </div>
            </div>
          </div>
        </div>
      </div>
      <br>
      <fieldset class="mimeAttachmentHeader"></fieldset>
      <br>
      <pre wrap="">_______________________________________________
Concurrency-interest mailing list
<a class="moz-txt-link-abbreviated" href="mailto:Concurrency-interest@cs.oswego.edu">Concurrency-interest@cs.oswego.edu</a>
<a class="moz-txt-link-freetext" href="http://cs.oswego.edu/mailman/listinfo/concurrency-interest">http://cs.oswego.edu/mailman/listinfo/concurrency-interest</a>
</pre>
    </blockquote>
    <br>
    <pre class="moz-signature" cols="72">-- 
-Nathan</pre>
  </body>
</html>