Multithreading tutorial (XXV) atomic array

Multithreading tutorial （ twenty-five ） An array of atoms

There are three kinds of commonly used atomic arrays ：

• AtomicIntegerArray

• AtomicLongArray

• AtomicReferenceArray

AtomicIntegerArray Array to store integers ;

AtomicLongArray The array stores long integers ;

AtomicReferenceArray The array stores reference types ;

give an example ：

/**  Parameters 1, Provide arrays 、 It can be a thread unsafe array or a thread safe array   Parameters 2, Method to get the length of the array   Parameters 3, Self increasing method , Comes back  array, index  Parameters 4, How to print an array  */
// supplier  Provider   Out of thin air  ()-> result 
// function  function   One parameter, one result  ( Parameters )-> result  , BiFunction ( Parameters 1, Parameters 2)-> result 
// consumer  consumer   A parameter has no result  ( Parameters )->void, BiConsumer ( Parameters 1, Parameters 2)->
private static <T> void demo(
    Supplier<T> arraySupplier,
    Function<T, Integer> lengthFun,
    BiConsumer<T, Integer> putConsumer,
    Consumer<T> printConsumer ) {
    
    List<Thread> ts = new ArrayList<>();
    T array = arraySupplier.get();
    int length = lengthFun.apply(array);
    for (int i = 0; i < length; i++) {
    
        //  Each thread is grouped in pairs  10000  operations 
        ts.add(new Thread(() -> {
    
            for (int j = 0; j < 10000; j++) {
    
                putConsumer.accept(array, j%length);
            }
        }));
    }
    ts.forEach(t -> t.start()); //  Start all threads 
    ts.forEach(t -> {
    
        try {
    
            t.join();
        } catch (InterruptedException e) {
    
            e.printStackTrace();
        }
    }); //  When all threads end 
    printConsumer.accept(array);
}

The above code uses functional programming , You can see the introduction of functional programming Blog

1. Pass a non thread safe array into the method

demo(
    ()->new int[10],
    (array)->array.length,
    (array, index) -> array[index]++,
    array-> System.out.println(Arrays.toString(array))
);

Output ：

[9870, 9862, 9774, 9697, 9683, 9678, 9679, 9668, 9680, 9698]

2. Pass a thread safe array into a function

demo(
    ()-> new AtomicIntegerArray(10),
    (array) -> array.length(),
    (array, index) -> array.getAndIncrement(index),
    array -> System.out.println(array)
);

result

[10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000]

reference ：

Functional programming