Review Request: CR 7100996 - (spec str) IndexOutOfBoundsException when using a StringBuffer from multiple threads (original) (raw)

Jim Gish jim.gish at oracle.com
Mon Jun 25 19:32:44 UTC 2012

• Previous message: Review Request: CR 7100996 - (spec str) IndexOutOfBoundsException when using a StringBuffer from multiple threads
• Next message: Review Request: CR 7100996 - (spec str) IndexOutOfBoundsException when using a StringBuffer from multiple threads
• Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]

Hopefully, this will address most, if not all of the suggestions made to date.

....Jim

diff -r f37afaa214e9 src/share/classes/java/lang/StringBuffer.java --- a/src/share/classes/java/lang/StringBuffer.java Mon Jun 25 14:22:42 2012 -0400 +++ b/src/share/classes/java/lang/StringBuffer.java Mon Jun 25 15:30:57 2012 -0400 @@ -39,40 +39,38 @@

• that is consistent with the order of the method calls made by each of
• the individual threads involved.

• • The principal operations on a StringBuffer are the
• • append and insert methods, which are

• • The principal operations on a {@code StringBuffer} are the
• • {@code append} and {@code insert} methods, which are
  • overloaded so as to accept data of any type. Each effectively
  • converts a given datum to a string and then appends or inserts the
  • characters of that string to the string buffer. The

• • append method always adds these characters at the end
• • of the buffer; the insert method adds the characters at

• • {@code append} method always adds these characters at the end
• • of the buffer; the {@code insert} method adds the characters at
  • a specified point.

• • For example, if z refers to a string buffer object
• • whose current contents are "start", then
• • the method call z.append("le") would cause the string
• • buffer to contain "startle", whereas
• • z.insert(4, "le") would alter the string buffer to
• • contain "starlet".

• • For example, if {@code z} refers to a string buffer object
• • whose current contents are "{@code start}", then
• • the method call {@code z.append("le")} would cause the string
• • buffer to contain "{@code startle}", whereas
• • {@code z.insert(4, "le")} would alter the string buffer to
• • contain "{@code starlet}".

• • In general, if sb refers to an instance of a StringBuffer,
• • then sb.append(x) has the same effect as
• • sb.insert(sb.length(), x).

• • In general, if sb refers to an instance of a {@code StringBuffer},
• • then {@code sb.append(x)} has the same effect as
• • {@code sb.insert(sb.length(), x)}.
  • Whenever an operation occurs involving a source sequence (such as

• • appending or inserting from a source sequence) this class synchronizes

• • appending or inserting from a source sequence), this class synchronizes
  • only on the string buffer performing the operation, not on the source.

• • Although {@code StringBuffer} is designed to be safe to use
• • concurrently from multiple threads, if the source data passed
• • to the constructor, i.e. {@code StringBuffer(source)}, or to the
• • {@code append(source)}, or {@code insert(source)} operations
• • is shared across threads, it must be ensured that the operations have
• • a consistent and unchanging view of the source data for the duration
• • of the operation.

• • {@code StringBuffer} is designed to be safe to use
• • concurrently from multiple threads, but if the source data passed
• • to the constructor or to the {@code append()}, or {@code insert()}
• • operations is shared across threads, the calling code must be ensure
• • that the operations have a consistent and unchanging view of the source
• • data for the duration of the operation.
  • This could be satisfied by the caller holding a lock during the

• • operation's call, or because the source data is
• • immutable, or because the source data is not shared across threads.

• • operation's call, or by the source data being
• • immutable, or by the source data not being shared across threads.
  • Every string buffer has a capacity. As long as the length of the
  • character sequence contained in the string buffer does not exceed @@ -112,8 +110,8 @@
    • the specified initial capacity.
    • @param capacity the initial capacity.

• * @exception  NegativeArraySizeException  if the <code>capacity</code>

• *               argument is less than <code>0</code>.

• * @exception  NegativeArraySizeException  if the {@code capacity}

• *               argument is less than {@code 0}.
   */
  public StringBuffer(int capacity) {
      super(capacity);

@@ -122,10 +120,10 @@ /** * Constructs a string buffer initialized to the contents of the * specified string. The initial capacity of the string buffer is

• * <code>16</code> plus the length of the string argument.

• * {@code 16} plus the length of the string argument.
   *
   * @param   str   the initial contents of the buffer.

• * @exception NullPointerException if <code>str</code> is

null

• * @exception NullPointerException if {@code str} is {@code null}
   */
  public StringBuffer(String str) {
      super(str.length() + 16);

@@ -134,16 +132,16 @@

  /**
   * Constructs a string buffer that contains the same characters

• * as the specified <code>CharSequence</code>. The initial capacity of

• * the string buffer is <code>16</code> plus the length of the

• * <code>CharSequence</code> argument.

• * as the specified {@code CharSequence}. The initial capacity of

• * the string buffer is {@code 16} plus the length of the

• * {@code CharSequence} argument.
   * <p>

• * If the length of the specified <code>CharSequence</code> is

• * If the length of the specified {@code CharSequence} is
   * less than or equal to zero, then an empty buffer of capacity

• * <code>16</code> is returned.

• * {@code 16} is returned.
   *
   * @param      seq   the sequence to copy.

• * @exception NullPointerException if <code>seq</code> is

null

• * @exception NullPointerException if {@code seq} is {@code null}
   * @since 1.5
   */
  public StringBuffer(CharSequence seq) {

@@ -264,10 +262,10 @@ * the new character sequence is equal to the character at index k * in the old character sequence, if k is less than n; * otherwise, it is equal to the character at index k-n in the

• * argument <code>sb</code>.

• * argument {@code sb}.
   * <p>

• * This method synchronizes on <code>this</code> (the destination)

• * object but does not synchronize on the source (<code>sb</code>).

• * This method synchronizes on {@code this} (the destination)

• * object but does not synchronize on the source ({@code sb}).
   *
   * @param   sb   the <tt>StringBuffer</tt> to append.
   * @return  a reference to this object.

@@ -280,10 +278,10 @@

  /**

• * Appends the specified <code>CharSequence</code> to this

• * Appends the specified {@code CharSequence} to this
   * sequence.
   * <p>

• * The characters of the <code>CharSequence</code> argument are

appended,

• * The characters of the {@code CharSequence} argument are appended,
   * in order, increasing the length of this sequence by the length

of the * argument. * @@ -291,12 +289,12 @@ * invocation of this.append(s, 0, s.length()); * *

This method synchronizes on this (the destination)

• * object but does not synchronize on the source (<code>s</code>).

• * object but does not synchronize on the source ({@code s}).
   *

• * <p>If <code>s</code> is <code>null</code>, then the four characters

• * <code>"null"</code> are appended.

• * <p>If {@code s} is {@code null}, then the four characters

• * {@code "null"} are appended.
   *

• * @param   s the <code>CharSequence</code> to append.

• * @param   s the {@code CharSequence} to append.
   * @return  a reference to this object.
   * @since 1.5
   */

• Previous message: Review Request: CR 7100996 - (spec str) IndexOutOfBoundsException when using a StringBuffer from multiple threads
• Next message: Review Request: CR 7100996 - (spec str) IndexOutOfBoundsException when using a StringBuffer from multiple threads
• Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]

More information about the core-libs-dev mailing list