【记录】并发编程-学习日志（六）

已于 2023-09-20 14:32:04 修改
阅读量51 收藏
点赞数
分类专栏： 并发编程 - 学习日志 文章标签： 学习
于 2023-09-18 16:48:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73376124/article/details/132943085
版权

6. 共享模式之无锁

6.1 提出问题【引言】

package com.rui.six;

import java.util.ArrayList;
import java.util.List;

public class Test1 {
    public static void main(String[] args) {
        Account.demo(new AccountUnsafe(10000));
    }
}

class AccountUnsafe implements Account{

    private Integer balance;

    public AccountUnsafe(Integer balance) {
        this.balance = balance;
    }

    @Override
    public Integer getBalance() {
        return balance;
    }

    @Override
    public void withdraw(Integer amount) {
        balance -= amount;
    }
}

interface Account {

    // 获取余额
    Integer getBalance();

    // 取款
    void withdraw(Integer amount);

    /**
     * 方法内会启动 1000 个线程，每个线程做取款 10 元的操作
     * 如果初始余额为 10000 元，那么终止余额应当是 0 元
     */
    static void demo(Account account) {
        List<Thread> ts = new ArrayList<>();
        long start = System.nanoTime();
        for (int i = 0; i < 1000; i++) {
            ts.add(new Thread(() -> {
                account.withdraw(10);
            }));
        }
        ts.forEach(Thread::start);
        ts.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        long end = System.nanoTime();
        System.out.println("终止余额 = " + account.getBalance()
                + "；cost " + (end - start) / 1000_000 + " ms");
    }
}
// 某次运行结果

终止余额 = 180；cost 107 ms

进程已结束，退出代码 0

造成某次运行结果同预期结果不符的原因：非线程安全

6.1.1 解决思路 - 锁

package com.rui.six;

import java.util.ArrayList;
import java.util.List;

public class Test1 {
    public static void main(String[] args) {
        Account.demo(new AccountUnsafe(10000));
        Account.demo(new AccountSynchronized(10000));
    }
}

class AccountSynchronized implements Account {

    private Integer balance;

    public AccountSynchronized(Integer balance) {
        this.balance = balance;
    }

    @Override
    public synchronized Integer getBalance() {
        return balance;
    }

    @Override
    public synchronized void withdraw(Integer amount) {
        balance -= amount;
    }
}

class AccountUnsafe implements Account {

    private Integer balance;

    public AccountUnsafe(Integer balance) {
        this.balance = balance;
    }

    @Override
    public Integer getBalance() {
        return balance;
    }

    @Override
    public void withdraw(Integer amount) {
        balance -= amount;
    }
}

interface Account {

    // 获取余额
    Integer getBalance();

    // 取款
    void withdraw(Integer amount);

    /**
     * 方法内会启动 1000 个线程，每个线程做取款 10 元的操作
     * 如果初始余额为 10000 元，那么终止余额应当是 0 元
     */
    static void demo(Account account) {
        List<Thread> ts = new ArrayList<>();
        long start = System.nanoTime();
        for (int i = 0; i < 1000; i++) {
            ts.add(new Thread(() -> {
                account.withdraw(10);
            }));
        }
        ts.forEach(Thread::start);
        ts.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        long end = System.nanoTime();
        System.out.println("终止余额 = " + account.getBalance()
                + "；cost " + (end - start) / 1000_000 + " ms");
    }
}
// 某次运行结果

终止余额 = 200；cost 120 ms
终止余额 = 0；cost 75 ms

进程已结束，退出代码 0

 6.1.2 解决思路 - 无锁

本章内容【问题不大】

package com.rui.six;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

public class Test1 {
    public static void main(String[] args) {
        Account.demo(new AccountUnsafe(10000));
        Account.demo(new AccountSynchronized(10000));
        Account.demo(new AccountCas(10000));
    }
}

class AccountCas implements Account {
    private AtomicInteger balance;

    public AccountCas(Integer balance) {
        this.balance = new AtomicInteger(balance);
    }

    @Override
    public Integer getBalance() {
        return balance.get();
    }

    @Override
    public void withdraw(Integer amount) {
        while (true) {
            int prev = balance.get();
            int next = prev - amount;
            if (balance.compareAndSet(prev, next)) {
                break;
            }
        }
    }
}

class AccountSynchronized implements Account {

    private Integer balance;

    public AccountSynchronized(Integer balance) {
        this.balance = balance;
    }

    @Override
    public synchronized Integer getBalance() {
        return balance;
    }

    @Override
    public synchronized void withdraw(Integer amount) {
        balance -= amount;
    }
}

class AccountUnsafe implements Account {

    private Integer balance;

    public AccountUnsafe(Integer balance) {
        this.balance = balance;
    }

    @Override
    public Integer getBalance() {
        return balance;
    }

    @Override
    public void withdraw(Integer amount) {
        balance -= amount;
    }
}

interface Account {

    // 获取余额
    Integer getBalance();

    // 取款
    void withdraw(Integer amount);

    /**
     * 方法内会启动 1000 个线程，每个线程做取款 10 元的操作
     * 如果初始余额为 10000 元，那么终止余额应当是 0 元
     */
    static void demo(Account account) {
        List<Thread> ts = new ArrayList<>();
        long start = System.nanoTime();
        for (int i = 0; i < 1000; i++) {
            ts.add(new Thread(() -> {
                account.withdraw(10);
            }));
        }
        ts.forEach(Thread::start);
        ts.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        long end = System.nanoTime();
        System.out.println("终止余额 = " + account.getBalance()
                + "；cost " + (end - start) / 1000_000 + " ms");
    }
}
// 某次运行结果

终止余额 = 500；cost 135 ms
终止余额 = 0；cost 86 ms
终止余额 = 0；cost 59 ms

进程已结束，退出代码 0

 6.2 CAS 和 volatile

while (true) {
    int prev = balance.get();
    int next = prev - amount;
    if (balance.compareAndSet(prev, next)) {
        break;
    }
}

CAS：compareAndSet，直译 “比较并设置” 

//（线程 1 ）

int prev = balance.get();  // 获取余额 100

int next = prev - amount;  // 减 10 = 90

// （线程 2 ）已经修改为 90 了

balance.compareAndSet(prev, next)  // 因为100 != 90，所以 return false

// ...

int prev = balance.get();  // 获取余额 80

int next = prev - amount;  // 减 10 = 70

balance.compareAndSet(prev, next)  // 因为80 == 80，所以将余额修改为 70 并 return true

volatile 关键字对 CAS 中的 C 提供了可见性的支持

【6.1.2 解决思路 - 无锁】的某次运行结果表明，无锁的运行效率高于 synchronized 的运行效率，为什么？

在线程数小于 CPU core 数的条件下， synchronized 会发生上下文切换而无锁不会。

CAS 运用了乐观锁的思想；synchronized 运用了悲观锁的思想

CAS 适用于线程数少、多核 CPU 的情况

线程数少、多核 CPU 不等同于 线程数小于 CPU core数

多线程、单核 CPU 的情况一定会发生上下文切换

线程数多的情况可能会导致 CAS 频繁 return false

import java.util.concurrent.atomic

6.3 原子整数

AtomicBoolean、AtomicInteger、AtomicLong

以 AtomicInteger 为例

构造方法（AtomicInteger）

无参构造
package com.rui.six;

import java.util.concurrent.atomic.AtomicInteger;

public class Test2 {
    public static void main(String[] args) {

        AtomicInteger value = new AtomicInteger();

        System.out.println(value.get());
    }
}

// 运行结果

0

进程已结束，退出代码 0
有参构造
package com.rui.six;

import java.util.concurrent.atomic.AtomicInteger;

public class Test2 {
    public static void main(String[] args) {

        AtomicInteger value = new AtomicInteger(5);

        System.out.println(value.get());
    }
}

// 运行代码

5

进程已结束，退出代码 0

incrementAndGet

value.incrementAndGet() 等同于 ++value

package com.rui.six;

import java.util.concurrent.atomic.AtomicInteger;

public class Test2 {
    public static void main(String[] args) {

        AtomicInteger value = new AtomicInteger(5);

        System.out.println(value.incrementAndGet());
    }
}

// 运行结果

6

进程已结束，退出代码 0

getAndIncrement

value.getAndIncrement() 等同于 value++

package com.rui.six;

import java.util.concurrent.atomic.AtomicInteger;

public class Test2 {
    public static void main(String[] args) {

        AtomicInteger value = new AtomicInteger(5);

        System.out.println(value.getAndIncrement());

        System.out.println(value.get());
    }
}

// 运行结果

5
6

进程已结束，退出代码 0

decrementAndGet

value.decrementAndGet() 等同于 --value

getAndDecrement

value.getAndDecrement() 等同于 value--

addAndGet

package com.rui.six;

import java.util.concurrent.atomic.AtomicInteger;

public class Test2 {
    public static void main(String[] args) {

        AtomicInteger value = new AtomicInteger(5);

        System.out.println(value.addAndGet(-4));  // 1 <- 5+(-4)=1
    }
}

// 运行结果

1

进程已结束，退出代码 0

【6.1.2 解决思路 - 无锁】优化 

package com.rui.six;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

public class Test1 {
    public static void main(String[] args) {
        Account.demo(new AccountCas(10000));
    }
}

class AccountCas implements Account {
    private AtomicInteger balance;

    public AccountCas(Integer balance) {
        this.balance = new AtomicInteger(balance);
    }

    @Override
    public Integer getBalance() {
        return balance.get();
    }

    @Override
    public void withdraw(Integer amount) {
        balance.addAndGet(-amount);
    }
}

interface Account {

    // 获取余额
    Integer getBalance();

    // 取款
    void withdraw(Integer amount);

    /**
     * 方法内会启动 1000 个线程，每个线程做取款 10 元的操作
     * 如果初始余额为 10000 元，那么终止余额应当是 0 元
     */
    static void demo(Account account) {
        List<Thread> ts = new ArrayList<>();
        long start = System.nanoTime();
        for (int i = 0; i < 1000; i++) {
            ts.add(new Thread(() -> {
                account.withdraw(10);
            }));
        }
        ts.forEach(Thread::start);
        ts.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        long end = System.nanoTime();
        System.out.println("终止余额 = " + account.getBalance()
                + "；cost " + (end - start) / 1000_000 + " ms");
    }
}
// 运行结果

终止余额 = 0；cost 96 ms

进程已结束，退出代码 0

getAndAdd

package com.rui.six;

import java.util.concurrent.atomic.AtomicInteger;

public class Test2 {
    public static void main(String[] args) {

        AtomicInteger value = new AtomicInteger(5);

        System.out.println(value.getAndAdd(5));

        System.out.println(value.get());
    }
}
// 运行结果

5
10

进程已结束，退出代码 0

updateAndGet

package com.rui.six;

import java.util.concurrent.atomic.AtomicInteger;

public class Test2 {
    public static void main(String[] args) {

        AtomicInteger value = new AtomicInteger(5);

        System.out.println(value.updateAndGet(x -> x * -1));  // -5 <- 5*(-1)=-5
    }
}

// 运行结果

-5

进程已结束，退出代码 0

getAndUpdate

package com.rui.six;

import java.util.concurrent.atomic.AtomicInteger;

public class Test2 {
    public static void main(String[] args) {

        AtomicInteger value = new AtomicInteger(5);

        System.out.println(value.getAndUpdate(x -> x + 2));

        System.out.println(value.get());
    }
}

// 运行结果

5
7

进程已结束，退出代码 0
package com.rui.six;

import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.IntUnaryOperator;

public class Test3 {
    public static void main(String[] args) {
        AtomicInteger value = new AtomicInteger(5);

        System.out.println(getAndUpdate(value, x -> x * 2));

        System.out.println(value.get());
    }

    public static int getAndUpdate(AtomicInteger value, IntUnaryOperator operator) {
        while (true) {
            int prev = value.get();
            int next = operator.applyAsInt(prev);
            if (value.compareAndSet(prev, next)) {
                return prev;
            }
        }
    }
}

// 运行结果

5
10

进程已结束，退出代码 0

6.4 原子引用

AtomicReference、AtomicMarkableReference、AtomicStampedReference

AtomicReference 

package com.rui.six;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicReference;

public class Test4 {
    public static void main(String[] args) {
        Account4.demo(new AccountCas4(new BigDecimal("10000")));
    }
}

class AccountCas4 implements Account4 {
    private AtomicReference<BigDecimal> balance;

    public AccountCas4(BigDecimal balance) {
        this.balance = new AtomicReference<>(balance);
    }

    @Override
    public BigDecimal getBalance() {
        return balance.get();
    }

    @Override
    public void withdraw(BigDecimal amount) {
        while (true) {
            BigDecimal prev = balance.get();
            BigDecimal next = prev.subtract(amount);
            if (balance.compareAndSet(prev, next)) {
                break;
            }
        }
    }
}

interface Account4 {

    // 获取余额
    BigDecimal getBalance();

    // 取款
    void withdraw(BigDecimal amount);

    /**
     * 方法内会启动 1000 个线程，每个线程做取款 10 元的操作
     * 如果初始余额为 10000 元，那么终止余额应当是 0 元
     */
    static void demo(Account4 account) {
        List<Thread> ts = new ArrayList<>();
        long start = System.nanoTime();
        for (int i = 0; i < 1000; i++) {
            ts.add(new Thread(() -> {
                account.withdraw(BigDecimal.TEN);
            }));
        }
        ts.forEach(Thread::start);
        ts.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        long end = System.nanoTime();
        System.out.println("终止余额 = " + account.getBalance()
                + "；cost " + (end - start) / 1000_000 + " ms");
    }
}
// 运行结果

终止余额 = 0；cost 116 ms

进程已结束，退出代码 0
package com.rui.six;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.atomic.AtomicReference;

@Slf4j(topic = "c.Test5")
public class Test5 {
    static AtomicReference<String> value = new AtomicReference<>("A");

    public static void main(String[] args) throws InterruptedException {
        log.debug("main begin...");
        other();
        Thread.sleep(1000);
        log.debug("A -> C : {}", value.compareAndSet(value.get(), "C"));
    }

    public static void other() throws InterruptedException {
        new Thread(() -> {
            log.debug("t1 begin...");
            log.debug("A -> B : {}", value.compareAndSet(value.get(), "B"));
        }, "t1").start();
        Thread.sleep(500);
        new Thread(() -> {
            log.debug("t2 begin...");
            log.debug("B -> A : {}", value.compareAndSet(value.get(), "A"));
        }, "t2").start();
    }
}
// 运行结果

11:46:15 [main] c.Test5 - main begin...
11:46:15 [t1] c.Test5 - t1 begin...
11:46:15 [t1] c.Test5 - A -> B : true
11:46:16 [t2] c.Test5 - t2 begin...
11:46:16 [t2] c.Test5 - B -> A : true
11:46:17 [main] c.Test5 - A -> C : true

进程已结束，退出代码 0

上述代码中，对 value 的修改（ABA 问题）未能被检测到，那么如何检测到这种修改呢？

AtomicStampedReference

AtomicStampedReference

package com.rui.six;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.atomic.AtomicStampedReference;

@Slf4j(topic = "c.Test5")
public class Test6 {
    static AtomicStampedReference<String> value = new AtomicStampedReference<>("A", 0);

    public static void main(String[] args) throws InterruptedException {
        log.debug("main begin...");
        int stamp = value.getStamp();
        other();
        Thread.sleep(1000);
        log.debug("stamp = {}", stamp);
        log.debug("A -> C : {}", value.compareAndSet(value.getReference(), "C", stamp, stamp + 1));
    }

    public static void other() throws InterruptedException {
        new Thread(() -> {
            log.debug("t1 begin...");
            log.debug("A -> B : {}", value.compareAndSet(value.getReference(), "B", value.getStamp(), value.getStamp() + 1));
        }, "t1").start();
        Thread.sleep(500);
        new Thread(() -> {
            log.debug("t2 begin...");
            log.debug("B -> A : {}", value.compareAndSet(value.getReference(), "A", value.getStamp(), value.getStamp() + 1));
        }, "t2").start();
    }
}
// 运行结果

11:55:23 [main] c.Test5 - main begin...
11:55:23 [t1] c.Test5 - t1 begin...
11:55:23 [t1] c.Test5 - A -> B : true
11:55:23 [t2] c.Test5 - t2 begin...
11:55:23 [t2] c.Test5 - B -> A : true
11:55:24 [main] c.Test5 - stamp = 0
11:55:24 [main] c.Test5 - A -> C : false

进程已结束，退出代码 0

AtomicMarkableReference

package com.rui.six;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.atomic.AtomicMarkableReference;
import java.util.concurrent.atomic.AtomicReference;

@Slf4j(topic = "c.Test7")
public class Test7 {
    static AtomicMarkableReference<String> amr = new AtomicMarkableReference<>("垃圾溢出", true);
    public static void main(String[] args) throws InterruptedException {
        other();
        Thread.sleep(1000);
        log.debug("T/F?{}",amr.compareAndSet(amr.getReference(),"清理垃圾",true,false));
    }

    public static void other() {
        new Thread(() -> {
            log.debug("T/F?{}",amr.compareAndSet(amr.getReference(),"清理垃圾",true,false));
            log.debug("{}",amr.getReference());
        },"保洁阿姨 1 号").start();

        new Thread(() -> {
            log.debug("T/F?{}",amr.compareAndSet(amr.getReference(),"垃圾溢出",true,false));
            log.debug("{}",amr.getReference());
        },"保洁阿姨 2 号").start();
    }
}

class GarbageBag {
    private String garbageBag;

    public GarbageBag(String garbageBag) {
        this.garbageBag = garbageBag;
    }

    public String getGarbageBag() {
        return garbageBag;
    }

    @Override
    public String toString() {
        return "GarbageBag{" +
                "garbageBag='" + garbageBag + '\'' +
                '}';
    }
}
// 运行结果

12:06:27 [保洁阿姨 1 号] c.Test7 - T/F?true
12:06:27 [保洁阿姨 2 号] c.Test7 - T/F?false
12:06:27 [保洁阿姨 2 号] c.Test7 - 清理垃圾
12:06:27 [保洁阿姨 1 号] c.Test7 - 清理垃圾
12:06:28 [main] c.Test7 - T/F?false

进程已结束，退出代码 0

6.5 原子数组

AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray

非线程安全

package com.rui.six;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.*;

public class Test8 {
    public static void main(String[] args) {
        demo(
                () -> new int[10],
                (array) -> array.length,
                (array, index) -> array[index]++,
                (array) -> System.out.println(Arrays.toString(array))

        );
    }

    /**
     * 参数1，提供数组、可以是线程不安全数组或线程安全数组
     * 参数2，获取数组长度的方法
     * 参数3，自增方法，回传 array、index
     * 参数4，打印数组的方法
     */
    // Supplier 提供者 无中生有 () -> 结果
    // Function 函数 一个参数一个结果 (参数) -> 结果，BiFunction (参数1,参数2) -> 结果
    // Consumer 消费者 一个参数没结果 (参数) -> void，BiConsumer (参数1,参数2) -> void
    private static <T> void demo(
            Supplier<T> arraySupplier,
            Function<T, Integer> lengthFun,
            BiConsumer<T, Integer> putConsumer,
            Consumer<T> printConsumer) {
        List<Thread> list = new ArrayList<>();
        T array = arraySupplier.get();
        int length = lengthFun.apply(array);
        for (int i = 0; i < length; i++) {
            // 每个线程对数组做 10000 次操作
            list.add(new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    putConsumer.accept(array, j % length);
                }
            }));
        }
        list.forEach(t -> t.start()); // 启动所有线程
        list.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }); // 等所有线程结束
        printConsumer.accept(array);
    }
}

// 某次运行结果

[9496, 9462, 9530, 9506, 9486, 9509, 9522, 9494, 9447, 9483]

进程已结束，退出代码 0

线程安全 - 以 AtomicIntegerArray 为例

package com.rui.six;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.atomic.AtomicIntegerArray;
import java.util.function.*;

public class Test8 {
    public static void main(String[] args) {
        demo(
                () -> new int[10],
                (array) -> array.length,
                (array, index) -> array[index]++,
                (array) -> System.out.println(Arrays.toString(array))

        );

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

    /**
     * 参数1，提供数组、可以是线程不安全数组或线程安全数组
     * 参数2，获取数组长度的方法
     * 参数3，自增方法，回传 array、index
     * 参数4，打印数组的方法
     */
    // Supplier 提供者 无中生有 () -> 结果
    // Function 函数 一个参数一个结果 (参数) -> 结果，BiFunction (参数1,参数2) -> 结果
    // Consumer 消费者 一个参数没结果 (参数) -> void，BiConsumer (参数1,参数2) -> void
    private static <T> void demo(
            Supplier<T> arraySupplier,
            Function<T, Integer> lengthFun,
            BiConsumer<T, Integer> putConsumer,
            Consumer<T> printConsumer) {
        List<Thread> list = new ArrayList<>();
        T array = arraySupplier.get();
        int length = lengthFun.apply(array);
        for (int i = 0; i < length; i++) {
            // 每个线程对数组做 10000 次操作
            list.add(new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    putConsumer.accept(array, j % length);
                }
            }));
        }
        list.forEach(t -> t.start()); // 启动所有线程
        list.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }); // 等所有线程结束
        printConsumer.accept(array);
    }
}

// 某次运行结果

[9076, 9056, 9086, 9076, 9036, 9048, 9810, 9772, 9794, 9806]
[10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000]

进程已结束，退出代码 0

6.7 字段更新器

AtomicReferenceFieldUpdater

修改成员变量

package com.rui.six;

import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;

public class Test9 {
    public static void main(String[] args) {
        Student stu = new Student();
        AtomicReferenceFieldUpdater arfu = AtomicReferenceFieldUpdater.newUpdater(Student.class, String.class, "name");
        System.out.println(arfu.compareAndSet(stu, null, "张三"));
        System.out.println(stu);
    }
}

class Student {
    public volatile String name;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                '}';
    }
}

// 运行结果

true
Student{name='张三'}

进程已结束，退出代码 0

 6.8 原子累加器

package com.rui.six;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.LongAdder;
import java.util.function.Consumer;
import java.util.function.Supplier;

public class Test10 {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            demo(
                    () -> new AtomicLong(),
                    (adder) -> adder.incrementAndGet()
            );
        }

        System.out.println("================== 一条华丽的分割线 ==================");

        for (int i = 0; i < 5; i++) {
            demo(
                    () -> new LongAdder(),
                    (adder) -> adder.increment()
            );
        }

    }

    private static <T> void demo(Supplier<T> adderSupplier, Consumer<T> action) {
        T adder = adderSupplier.get();
        long start = System.nanoTime();
        List<Thread> list = new ArrayList<>();
        // 40 个线程，每个线程累加 50 W
        for (int i = 0; i < 40; i++) {
            list.add(new Thread(() -> {
                for (int j = 0; j < 500000; j++) {
                    action.accept(adder);
                }
            }));
        }
        list.forEach(t -> t.start());
        list.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        long end = System.nanoTime();
        System.out.println(adder + "，cost:" + (end - start) / 1000_000);
    }
}

// 某次运行结果

20000000，cost:180
20000000，cost:165
20000000，cost:163
20000000，cost:161
20000000，cost:161
================== 一条华丽的分割线 ==================
20000000，cost:18
20000000，cost:9
20000000，cost:9
20000000，cost:25
20000000，cost:18

进程已结束，退出代码 0

说些废话

本篇文章为博主日常学习记录，故而会概率性地存在各种错误，若您在浏览过程中发现一些，请在评论区指正，望我们共同进步，谢谢！

在听Rr.
关注
专栏目录
Java并发编程-线程安全与基础构建模块
04-04
2. **守护线程（Daemon Thread）**：后台运行的线程，当所有非守护线程结束时，程序会自动停止，常用于日志记录、垃圾收集等任务。 3. **线程通信**：`wait()`、`notify()`和`notifyAll()`方法用于线程间的协作，...
spring 微服务相关框架学习。以及记录 jvm 调优 数据监控 并发控制-spring-frame.zip
01-29
首先，Spring框架是一个全面的Java企业级应用开发平台，它简化了开发过程并提供了丰富的功能，包括依赖注入（DI）、面向切面编程（AOP）、事务管理等。Spring Boot进一步简化了Spring应用的启动和运行，使得开发者...
Java并发编程-线程池
千月落
02-21 1万+
Java 中的线程池是运用场景最多的并发框架，几乎所有需要异步或并发执行任务的程序都可以使用线程池。
并发编程 - 通过 Disruptor 来实现无锁无阻塞的并发编程
小工匠
07-04 1万+
Disruptor是一种高性能的并发编程框架，它由LMAX Exchange公司开发，并于2011年开源。Disruptor旨在解决传统多线程编程中的性能瓶颈和并发问题，特别适用于需要高度并发处理的场景。Disruptor采用了一种称为"无锁编程"的机制，通过使用环形缓冲区（Ring Buffer）和事件驱动的方式实现高效的消息传递和处理。它的核心思想是将消息（事件）在生产者和消费者之间进行无锁的、高效的交换，以减少线程间的竞争和上下文切换。
Java多线程实战-异步操作日志记录解决方案(AOP+注解+多线程)
qq_35716689的博客
03-16 25万+
异步日志记录是一种提升系统性能和可维护性的有效手段。牵着猫散步的鼠鼠。通过将日志记录操作异步化，不仅可以减少对业务处理流程的影响，还可以提高日志处理的灵活性和扩展性。然而，实现异步日志记录机制也伴随着一定的挑战，如日志的实时性、顺序性和丢失风险等问题。
并发编程面试题（2020最新版）
热门推荐
ThinkWon的博客
03-14 36万+
文章目录基础知识并发编程的优缺点为什么要使用并发编程（并发编程的优点）并发编程有什么缺点并发编程三要素是什么？在 Java 程序中怎么保证多线程的运行安全？并行和并发有什么区别？什么是多线程，多线程的优劣？线程和进程区别什么是线程和进程?进程与线程的区别什么是上下文切换?守护线程和用户线程有什么区别呢？如何在 Windows 和 Linux 上查找哪个线程cpu利用率最高？什么是线程死锁形成死锁的...
PHP高并发编程
争当做一个有趣的人
12-10 2776
php高并发编程swoole.workman.20210202 一 课程说明 内容： 多进程程序 多线程程序 协程程序 提高Web并发能力 高级IO及相关开源产品 长连接项目应用 收效： 了解多进程，多线程，协程的概念 使用php进行系统编程 可以使用php的socket开源框架 利用多进程，多线程，协程写出高效的程序 对php编程有一个全新的认识（不止专注与web开发） 多进程 二 多进程概念和准备 进程： ​ 是某段程序运行的实例 多进程： ​ 同一同一时间操作系统中有两个及以上的进程实例在执行
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
qq_35716689的博客
03-10 25万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
Python 异常处理与日志记录
一键难忘的博客
04-23 3348
异常处理是任何编程语言中的重要组成部分，Python 也不例外。Python 提供了丰富的异常处理机制，让开发者可以更好地管理程序中出现的错误。除了捕获和处理异常外，记录异常信息也是至关重要的，以便日后排查问题和改进程序。本文将介绍如何在 Python 中捕获异常，并将异常信息记录到日志文件中。
[并发编程] - Executor框架#ThreadPoolExecutor源码解读02
小工匠
09-02 9489
文章目录Pre线程池的具体实现线程池的创建参数解读corePoolSizemaximumPoolSizekeepAliveTimeunitworkQueuethreadFactoryhandler任务提交方式一 提交任务无返回值方式二 提交任务有返回值线程池监控 Pre Java-Java中的线程池原理分析及使用 [并发编程] - Executor框架#ThreadPoolExecutor源码解读01 线程池的具体实现 主要两大类 ThreadPoolExecutor ScheduledTh
高并发编程-捕获线程运行时的异常 + 获取调用链
小工匠
10-18 9904
文章目录概述捕获线程运行时的异常使用场景UncaughtExceptionHandler 接口示例获取调用链 概述 捕获线程运行时的异常 我们看下Thread的定义 实现了Runnable接口 重写了run方法 根据方法签名可知，run方法是不能向上层抛出异常的，如果线程内部产生异常， 不catch的情况下，上层调用代码如何知道呢？ 使用场景 为啥需要这样做呢？ 一个线程抛出异常之后，...
高并发编程-Wait Set 多线程的“休息室”
小工匠
10-27 9979
文章目录概述关于wait set 概述 官方指导： https://docs.oracle.com/javase/specs/jls/se7/html/jls-17.html 或者： https://learning.oreilly.com/library/view/the-java-language/9780133260335/ch17lev1sec2.html 关于wait set Eve...
java并发编程-超级大全整理
10-19
【Java 并发编程-超级大全整理】 Java 并发编程是Java开发中不可或缺的一部分，尤其是在高并发场景下，能够有效提升程序的运行效率。本文将深入探讨Java多线程的相关知识点，帮助开发者理解并掌握如何在Java环境中...
商业编程-源码-MyLog 小鱼日志 v1.1.zip
06-21
4. **异步处理**：在高并发环境下，日志记录应采用异步方式，避免阻塞主线程。 5. **日志切割**：为了避免单个日志文件过大，系统可能会定时或按大小切割日志文件。 6. **日志过滤**：通过配置，允许用户只记录...
商业编程-源码-Dday个人日志系统 v1.0 多用户版.zip
06-21
《Dday个人日志系统 v1.0 多用户版》是一个专为商业编程环境设计的源码项目，它提供了一种高效、安全且多用户兼容的日志管理解决方案。这个系统的核心目标是帮助用户在日常工作中跟踪、记录并管理他们的个人活动和...
shader 案例学习笔记之将坐标系分成4个象限
localhost
09-13 103
坐标系被分成了4个单元格，每个单元格都有唯一的索引，后续就可以根据索引去渲染。
UEFI学习笔记（五）：EDK II PCD的概念、类型、使用
qq_44189622的博客
09-11 790
如果在BIOS里面有一些模块是binary方式集成进来的而这些binary又需要用到PCD（用于Binary Release），那么这些Binary集成的要用到的PCD就必须要设置为。PCD的值存在memory里面，下次启动时，上次更改的值丢失了，每次启动都是从default值开始。是存在VPD空间的（在FLASH上，只读），一般是出厂配置。如果platform是从源码build出来的，没有binary在里面的时候，PCD用的都是。作用域在一个模块中（模块级的），可以在Binary Level进行修改。
Redis 入门 - 五大基础类型及其指令学习
IT规划师
09-11 696
学习Redis基础类型：字符串、集合、有序集合、列表、哈希，每种类型有各自的特点和常用指令。掌握这些基础是熟练使用Redis的关键。更多指令需自行尝试。
Spring Framework 学习总结博客
最新发布
2302_80084329的博客
09-13 664
通过本文的学习，我们从Spring的核心架构入手，逐步理解了IoC和DI的概念，并通过代码示例掌握了如何在实际项目中使用这些技术。Spring通过IoC容器管理bean，依赖注入将bean之间的关系解耦，大大简化了复杂系统的开发过程。这些基本的Spring知识是理解其高级特性（如AOP、事务管理）的基础，掌握这些概念后，我们可以更加自如地使用Spring构建复杂的企业级应用。
Java并发编程：线程信息获取与设置实战
线程名则可以通过`Thread.getName()`获取或通过`Thread.setName()`设置，这对于调试和日志记录非常有用。线程的优先级是通过`Thread.getPriority()`和`Thread.setPriority()`进行读取和设置的，不过通常不建议直接...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值