Java concurrency Programming the 15th Chapter atom variable and non-blocking synchronization mechanism

Non-blocking synchronization mechanism

To put it simply, it's about synchronizing and not using locks.

The implementation of a nonblocking algorithm is much more cumbersome than a lock-based scheme, but it has a huge advantage in scalability and activity.

A common way to implement non-blocking algorithms is to use volatile semantics and atomic variables.

Hardware-to-concurrency support

The generation of atomic variables is primarily supported by the processor, and most importantly the CAS (compare and exchange) directives that are supported by most processor architectures.

Analog implementation of Atomicinteger + + operations

First we simulate the CAS syntax of the processor, and the reason is that the CAs are directly supported by atomic operations in the processor. No lock required.

1. public synchronized int Compareandswap (int exceptvalue, int newvalue) {
2. int oldValue = count;
3. if (OldValue = = Exceptvalue) {
4. Count = newvalue;
5. }
6. return oldValue;
7. }

Note: CAs always returns oldValue.

Use the above method to simulate the Atomicinteger + + operation.

2. Class myatomicinteger{
4. private int value;
6. public int Incrementandget ()
8. {
10. int v;
12. do{
14. v = value;
16. }while (v! = Compareandswap (v,v+1));
20. return v + 1;
22. }
24. }

Note: Java's Atomicinteger Implementation mechanism is like this, does not block, uses the processor's CAS function, but polls the attempt.

It seems that polling attempts are worse, but the CAS-based algorithm is better when the competition is not very high.

Atomic class

Atomicboolean Atomicinteger Atomiclong atomicreference

Atomic Array class: Atomicintegerarray Atomiclong atomicreferencearray.

Arrays decorated with volatile syntax can only guarantee the volatile semantics of the array variables themselves, and cannot guarantee the volatile semantics of the elements. The atomic array class should be used at this time.

Note: Atomicboolean Atomicinteger Atomiclong and non-atomic corresponding numeric classes such as Integer are completely unused. The implementation mechanism is completely different and there is no corresponding relationship. One of the most important differences: This three-atom class is mutable. and is the hashcode and Equals method of the object used, which does not extend itself.

Performance comparisons: Locks and Atomic variables

In the medium to low level competition, the atom variable can provide the very high scalability, the Atom variable performance surpasses the lock, but under the intense competition, the lock can avoid the competition more effectively, the lock performance will surpass the atom variable performance. But in a more realistic situation (generally less powerful competition), the performance of the atomic variable will exceed the performance of the lock.

Note: Regardless of whether it is a lock or an atomic variable, it is far less efficient than avoiding shared states (such as using thread-blocking techniques, but using scenarios to limit the usage) to eliminate competition.

Two non-blocking algorithm examples

2. /**
4. * Non-blocking stacks constructed using the Treiber algorithm
6. */
8. public class Concurrentstack<e> {
10. private atomicreference<node<e>> top = new atomicreference<concurrentstack.node<e>> ();
14. Public void Push (E item) {
16. node<e> newhead = new node<e> (item);
18. Node<e> Oldhead;
22. do{
24. Oldhead = top. get ();
26. Newhead.next = Oldhead;
28. } while (!top.compareandset (Oldhead, Newhead));
30. }
34. Public E Pop () {
36. Node<e> Oldhead;
38. Node<e> Newhead;
42. Do {
44. Oldhead = top. get ();
46. if (Oldhead = = null)
48. return null;
50. Newhead = Oldhead.next;
52. } while (!top.compareandset (Oldhead, Newhead));
54. return oldhead.item;
56. }
60. private static Class node<e>{
62. Public final E item;
64. Public node<e> Next;
68. Public Node (E item) {
70. This.item = Item;
72. }
74. }
76. }

Below this did not understand, stay here record, later look:

2. /**
4. * Insert sort in non-blocking algorithm of list, from Michael-scott
6. */
8. public class Linkedqueue<e> {
10. private static Class node<e>{
12. final E item;
14. final atomicreference<node<e>> next;
18. Public Node (E item, node<e> next) {
20. This.item = Item;
22. this.next = new atomicreference<> (next);
24. }
26. }
30. private final node<e> dummy = new node<e> (null, NULL);
32. Private final atomicreference<node<e>> head =
34. new atomicreference<> (dummy);
36. private final atomicreference<node<e>> tail =
38. new atomicreference<> (dummy);
42. Public Boolean put (E item) {
44. node<e> NewNode = new node<e> (item, NULL);
46. While (true) {
48. Node<e> curtail = Tail.get ();
50. node<e> Tailnext = CurTail.next.get ();
52. if (curtail = = Tail.get ()) { //Trailer not modified
54. if (tailnext! = null) {
56. //queue is in the middle (i.e. the new node has been connected, the tail node has not been updated), push the tail node
58. Tail.compareandset (curtail, tailnext);
60. } else{
62. //In a stable state, try inserting a new node
64. if (CurTail.next.compareAndSet (null, NewNode)) {
66. //After insert succeeds, push tail node
68. Tail.compareandset (curtail, tailnext);
70. return true;
72. }
74. }
76. }
78. }
80. }
82. }

Java concurrency Programming the 15th Chapter atom variable and non-blocking synchronization mechanism