Java并发编程（三）——锁的优化

最新推荐文章于 2024-05-13 09:26:58 发布
最新推荐文章于 2024-05-13 09:26:58 发布
阅读量322 收藏
点赞数
分类专栏： Java并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzypiper/article/details/103316223
版权

锁的优化

提高锁的性能

减少锁的持有时间

减少锁的持有时间，有助于降低所冲突的可能性，进而提升系统的并发能力。例如：

public synchronized void syncMethod(){
    othercode1();
    mutexMethod();
    othercode2();
}

改为只在必要的时候进行同步：

public void syncMethod2(){
    othercode1();
    synchronized (this){
        mutexMethod();
    }
    othercode2();
}

再如Pattern类中的matcher() 方法：

public Matcher matcher(CharSequence input) {
    if (!compiled) {
        synchronized(this) {
            if (!compiled)
                compile();
        }
    }
    Matcher m = new Matcher(this, input);
    return m;
}

matcher() 方法有条件地申请行锁，只在表达式未编译时局部加锁。

减小锁的粒度

减小锁的粒度，就是缩小锁定对象的范围，从而降低锁冲突的可能性。
例如ConcurrentHashMap类，内部进一步划分为若干个小的HashMap，称之为段（Segment）。如果在ConcurrentHashMap中添加一个新的表项，并不是对整个HashMap加锁，而是根据hashcode得到的该表项应该存在哪个段中，对该段进行加锁，然后完成put() 操作。

读写锁替换独占锁

对系统功能点进行分割，在读多写少的情况下有效提升系统的并发能力。

锁分离

将读写锁的思想进一步延伸。依据应用程序的功能特点，对独占锁进行分离。
例如在java.util.concurrent.LinkedBlockingQueue的实现中，take() 方法和put() 方法分别是往队列中取数据和增加数据。因此两个操作分别是在队头和队尾，理论上来说，两者不会发生冲突。如果使用独占锁，则要求两种操作进行时需要获得当前队列的独占锁，那么take() 方法和put() 方法就不能实现真正的并发。

锁粗化

锁粗化的思想与减少锁的持有时间是相反的，在不同的场合下根据实际情况进行权衡。
例如对同一个锁不停地进行请求、同步和释放，其本身也会消耗系统资源，反而不利于性能的优化。此时，可以将所有对锁的操作整合为一次请求，减少对锁的同步请求次数。

public void demoMethod(){
    synchronized (lock){
        // 同步操作
    }
    // 无需同步的操作，但很快可以执行完毕
    synchronized (lock){
        // 同步操作
    }
}

整合为：

public void demoMethod(){
    synchronized (lock){
        // 同步操作
        // 无需同步的操作，但很快可以执行完毕
        // 同步操作
    }
}

再如：

for (int i = 0; i < circle; i++) {
    synchronized (lock){
        // 同步操作
    }
}

整合为：

synchronized (lock){
    for (int i = 0; i < circle; i++) {
        // 同步操作
    }
}

JVM中对锁的优化策略

锁偏向

针对加锁操作的优化手段。核心思想是：如果有一个线程获得了锁，那么锁进入偏向模式，当这个线程再次请求锁时，无需再做任何同步操作。
对于几乎没有锁竞争的场合，偏向锁有比较好的优化效果。而对于锁竞争比较激烈的场合，最有可能的情况是每次都是不同的线程来请求相同的锁，使偏向模式失效，效果不佳。

轻量级锁

如果偏向锁失败，虚拟机不会立刻挂起线程，而会使用一种称为轻量级锁的优化手段。轻量级锁的操作为，将对象头部作为指针指向持有锁的线程堆栈的内部，来判断一个线程是否持有对象锁。
如果线程获取轻量级锁成功，则进入临界区。若失败，则膨胀为重量级锁。

自旋锁

在锁膨胀后，为了避免线程真实地在操作系统层面挂起，虚拟机会做最后的努力——自旋锁。虚拟机会让当前线程做几个空循环（自旋的含义），经过若干个循环后如果能够得到锁，就能顺利进入临界区。若不能，才会在操作系统层面挂起。

锁消除

锁消除是一种更为彻底的锁优化方法。Java虚拟机在JIT编译时，通过对运行上下文的扫描，出去不可能存在共享资源竞争的锁，。通过锁消除，可以节省毫无意义的请求锁的时间。
例如在使用一些JDK的内置API时，比如StringBuilder、Vector时，很可能会在不存在并发竞争的场合使用。Vector内部使用了synchronized请求锁。在如下代码中：

public String[] createString() {
	Vector<String> v = new  Vector<String>();
	for (int i = 0;i < 100;i++){
		v.add(Integer.toString(i));
	}
	return v.toArray(new String[]{});
}

由于变量v只在createString() 函数中使用，因此只是一个局部变量。局部变量是在线程栈上分配的，不会有其他线程访问。这种情况下加锁是没有必要的。
锁消除涉及的一项关键技术为逃逸分析，就是观察某一个变量是否会逃出某一个作用域。

ThreadLocal

除了控制资源的访问之外，还可以通过增加资源来保证所有对象的线程安全。如果说锁的使用是第一种思路，那么ThreadLocal的使用就是第二种思路。

ThreadLocal的使用

ThreadLocal是一个线程的局部变量，只有当前线程可以访问，因此是线程安全的。

public class DateParseBadDemo {
    private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    public static class ParseDate implements Runnable {
        private int i = 0;

        public ParseDate(int i) {
            this.i = i;
        }

        @Override
        public void run() {
            try {
                Date t =sdf.parse("2015-03-29 19:29:"+i%60);
                System.out.println(i+":"+t);
            }catch (ParseException e){
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        ExecutorService es = Executors.newFixedThreadPool(10);
        for (int i = 0;i<1000;i++){
            es.execute(new ParseDate(i));
        }
    }
}

上述代码在运行中会出现大量的java.lang.NumberFormatException，原因在于SimpleDateFormatparse() 方法是线程不安全的，一种可行的办法是在sdf.parse() 方法的前后加锁。但这里可以采取另一种思路：使用ThreadLocal为每一个线程创建一个SimpleDateFormat对象实例：

static ThreadLocal<SimpleDateFormat> tl = new ThreadLocal<>();

public static class ParseDate implements Runnable {
    private int i = 0;

    public ParseDate(int i) {
        this.i = i;
    }

    @Override
    public void run() {
        try {
            if (tl.get() == null) {
                tl.set(new SimpleDateFormat("yyyy-MM-dd "));
            }
            Date t = tl.get().parse("2015-03-29 19:29:" + i % 60);
            System.out.println(i + ":" + t);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}

其中，为每一个线程分配一个对象的工作不是由ThreadLocal来完成的，而是需要在应用层面完成，ThreadLocal只起到了容器的作用。

ThreadLocal的实现原理

ThreadLocal的实现原理如下图所示：
在这里插入图片描述
由于ThreadLocalMap是定义在Thread类内部的，因此只要线程不退出，对象的引用将一直存在。例如在使用线程池时，线程在结束任务之后不一定会退出。如果将一些比较大的对象设置在ThreadLocal中，可能会使系统出现内存泄漏的现象。

  1. 最好的方法是使用ThreadLocal.remove() 方法将变量移除。
  2. 此外由于Entry是弱引用，可以特意写出 tl = null ，使tl所指向的对象更容易被垃圾回收器发现，从而加速回收。

性能影响

如果共享对象由于竞争的处理容易引起性能损失，此时可以考虑ThreadLocal为每一个线程分配单独的对象。例如下面这个例子：多线程下陈胜随机数。

public class ThreadLocalRandom {
    public static final int GEN_COUNT = 10000000;
    public static final int THREAD_COUNT = 4;

    static ExecutorService exe = Executors.newFixedThreadPool(THREAD_COUNT);

    public static Random rnd = new Random(123);

    public static ThreadLocal<Random> tRnd = new ThreadLocal<Random>() {
        @Override
        protected Random initialValue() {
            return new Random(123);
        }
    };


    public static class RndTask implements Callable<Long> {
        private int mode = 0;

        public RndTask(int mode) {
            this.mode = mode;
        }

        public Random getRandom() {
            if (mode == 0) {
                return rnd;
            } else if (mode == 1) {
                return tRnd.get();
            } else {
                return null;
            }
        }

        @Override
        public Long call() throws Exception {
            long b = System.currentTimeMillis();
            for (long i = 0; i < GEN_COUNT; i++) {
                getRandom().nextInt();
            }
            long e = System.currentTimeMillis();
            System.out.println(Thread.currentThread().getName() + " spend" + (e - b) + "ms");
            return e - b;
        }
    }


    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Future<Long>[] futs = new Future[THREAD_COUNT];

        for (int i = 0; i < THREAD_COUNT; i++) {
            futs[i] = exe.submit(new RndTask(0));
        }
        long totaltime = 0;
        for (int i = 0; i < THREAD_COUNT; i++) {
            totaltime += futs[i].get();
        }
        System.out.println("多线程访问同一个Random实例:" + totaltime + "ms");

        // ThreadLocal的情况
        for (int  i = 0;i<THREAD_COUNT;i++){
            futs[i] = exe.submit(new RndTask(1));
        }
        totaltime = 0;
        for (int i = 0; i<THREAD_COUNT;i++){
            totaltime += futs[i].get();
        }
        System.out.println("使用ThreadLocal包装Random实例:"+ totaltime+"ms");
        exe.shutdown();
    }
}

OUTPUT
pool-1-thread-4 spend2653ms
pool-1-thread-2 spend2789ms
pool-1-thread-1 spend2812ms
pool-1-thread-3 spend2814ms
多线程访问同一个Random实例:11068ms
pool-1-thread-3 spend92ms
pool-1-thread-1 spend93ms
pool-1-thread-2 spend93ms
pool-1-thread-4 spend93ms
使用ThreadLocal包装Random实例:371ms

无锁

对于并发控制而言，锁是一种悲观的策略，总是假设每一次临界区操作都会产生冲突。而无锁是一种乐观的策略，它假设对资源是没有冲突的，没有冲突自然不需要等待。无锁策略使用一种叫做比较交换（CAS，Compare and Swap）的技术来鉴别线程的冲突，一旦检测到冲突发生，就重试当前操作直到没有冲突为止。

CAS算法

CAS算法包含三个参数CAS(V,E,N)，其中

  • V表示内存中的实际值
  • E表示预期值（也就是旧的值）
  • N表示新值（要将V改为N）

当V值等于E值时（说明中间没有发生修改），才会将V值修改为N值。CAS最终返回当前V的真实值。当多个线程使用CAS操作一个变量时，只有一个线程会成功，并成功更新变量值，其他线程均会失败。失败线程会重新尝试或将线程挂起（阻塞）。

在硬件层面，大多数的现代操作系统都已经支持原子化的CAS指令。在JDK1.5之后，虚拟机就可以使用这种指令来实现并发操作和并发数据结构。

无锁的线程安全整数：AtomicInteger

在JDK并发包中有一个atomic包，其中包含了一些可以直接使用CAS操作的线程安全的类型。其中最常用的是AtomicInteger。与Integer不同的是，AtomicInteger是可变的，并且是线程安全的，对其进行的任何操作都是用CAS指令进行的。
在这里插入图片描述
AtomicInteger中的核心字段value

private volatile int value;

AutomicInteger使用的例子：

public class AtomicIntegerDemo {
    static AtomicInteger i = new AtomicInteger();

    public static class AddThread implements Runnable {

        @Override
        public void run() {
            for (int k = 0; k < 10000; k++) {
                i.incrementAndGet();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread[] ts = new Thread[10];
        for (int k = 0; k < 10; k++) {
            ts[k] = new Thread(new AddThread());
        }
        for (int k = 0; k < 10; k++) {
            ts[k].start();
        }
        for (int k = 0; k < 10; k++) {
            ts[k].join();
        }
        System.out.println(i);
    }
}

OUTPUT
100000

和AutomicInteger类似的类还有：AutomicLong、AtomicBoolean、AutomicReference等。

Java中的指针：Unsafe类

Java和C++的一个重要区别就是在Java中无法直接操作一块内存区域，如申请内存和释放内存。但Java中的Unsafe类提供了类似C++手动管理内存的能力。从名字可以看出JDK开发人员并不希望大家使用这个类，仅作为JDK内部使用的一个专属类。

Unsafe类是“final”的，不允许继承。构造方法为私有，只能通过工厂方法获得实例，且当且仅当调用getUnsafe()方法的类为引导类加载器所加载时才合法，否则抛出SecurityException异常。
在这里插入图片描述
其他Unsafe类的相关内容可以参考：
Java中的Unsafe:https://www.jianshu.com/p/db8dce09232d

Unsafe实现CAS操作的例子

在使用AtomicInteger进行累加的例子中，i.incrementAndGet()的具体过程如下：
在这里插入图片描述compareAndSwapInt()方法是一个本地方法，var1位给定的对象，var2为对象内的偏移量，通过这两个参数可以快速定位字段。var4为期望值，var5为要设置的新值。当内存中的实际值与var4相同时，才会将内存中的值改为var5。在getAndAddInt方法中不断循环compareAndSwapInt()方法，直到设置成功。

无锁的对象引用：AtomicReference

AtomicReference与AtomicInteger类似，不同在于AtomicInteger是对整数的封装，AtomicReference是对普通对象的引用，可以保证在修改对象引用时的线程安全性。

ABA问题

ABA问题指的是：在CAS操作中，已经获得了对象的值，准备进行修改前，对象的值被多次修改但最终恢复为原值。此时无法判断该对象是否被修改过。

一般来说，发生ABA的情况很小，且在对于状态不敏感的场景中，即使发生了ABA现象也无关紧要。但某些场景，是否能修改对象的值不仅取决于当前值，还和对象的变化过程有关，此时AtomicReference就失效了。

假设这样一个场景：有一家蛋糕店为了挽留客户，决定为贵宾卡里余额小于20元的客户一次性赠送20元，来刺激客户充值和消费，但是条件是每一个顾客只能被赠送一次。

public class AtomicReferenceDemo {
    static AtomicReference<Integer> money = new AtomicReference<>();
    public static void main(String[] args) {
        // 设置账户初始值小于20，显然是一个需要被充值的账户
        money.set(19);

        // 模拟多个线程同时更新后台数据库，为用户充值
        for (int i = 0; i < 3; i++) {
            new Thread() {
                @Override
                public void run() {
                    while (true) {
                        while (true) {
                            Integer m = money.get();
                            if (m<20){
                                if (money.compareAndSet(m,m+20 )){
                                    System.out.println("余额小于20元，充值成功，余额："+money.get()+"元");
                                    break;
                                }
                            }else {
//                                System.out.println("余额大于20元，无需充值");
                                break;
                            }
                        }
                    }
                }
            }.start();
        }
        // 用户消费线程，模拟消费行为
        new Thread(){
            @Override
            public void run(){
                for (int i = 0 ;i<100;i++){
                  while (true){
                      Integer m = money.get();
                      if (m>10){
                          System.out.println("大于10元");
                          if (money.compareAndSet(m,m-10)){
                              System.out.println("成功消费10元，余额："+money.get()+"元");
                              break;
                          }
                      }else {
                          System.out.println("没有足够的资金");
                          break;
                      }
                  }
                }
            }
        }.start();
    }
}

上述代码会进行多次充值，为解决这一问题，JDK提供了AtomicStampedReference。

带有时间戳的对象引用：AtomicStampedReference

AtomicStampedReference内部不仅维护了对象值，还维护了一个时间戳（可以用任意整数表示状态值）。当AtomicStampedReference对应的数值被修改时，除了更新数据本身外，还需更新时间戳。当AtomicStampedReference设置对象的值时，对象的时间戳必须满足期望值，才会写入成功。

AtomicStampedReference的几个API在AtomicRenference的基础上新增了关于时间戳的信息。

// 比较设置，参数依次为：期望值、写入新值、期望时间戳、新时间戳
public boolean compareAndSet(V   expectedReference,
                             V   newReference,
                             int expectedStamp,
                             int newStamp)
// 获得当前对象引用
public V getReference()
// 获得当前时间戳
public int getStamp()
// 设置当前对象引用和时间戳
public void set(V newReference, int newStamp)

通过AtomicStampedReference修改AtomicReference的例子：

public class AtomicStampedReferenceDemo {
    static AtomicStampedReference<Integer> money = new AtomicStampedReference<>(19, 0);
    public static void main(String[] args) {
        // 模拟多个线程同时更新后台数据库，为用户充值
        for (int i = 0; i < 3; i++) {
            final int timestamp = money.getStamp();
            new Thread() {
                @Override
                public void run() {
                    while (true) {
                        while (true) {
                            Integer m = money.getReference();
                            if (m<20){
                                if (money.compareAndSet(m,m+20,timestamp,timestamp+1 )){
                                    System.out.println("余额小于20元，充值成功，余额："+money.getReference()+"元");
                                    break;
                                }
                            }else {
//                                System.out.println("余额大于20元，无需充值");
                                break;
                            }
                        }
                    }
                }
            }.start();
        }
        // 用户消费线程，模拟消费行为
        new Thread(){
            @Override
            public void run(){
                for (int i = 0 ;i<100;i++){
                  while (true){
                      int timestamp = money.getStamp();
                      Integer m = money.getReference();
                      if (m>10){
                          System.out.println("大于10元");
                          if (money.compareAndSet(m,m-10,timestamp,timestamp+1)){
                              System.out.println("成功消费10元，余额："+money.getReference()+"元");
                              break;
                          }
                      }else {
                          System.out.println("没有足够的资金");
                          break;
                      }
                  }
                }
            }
        }.start();
    }
}

output：
余额小于20元，充值成功，余额：39元
大于10元
成功消费10元，余额：29元
大于10元
成功消费10元，余额：19元
大于10元
成功消费10元，余额：9元
没有足够的资金
没有足够的资金
...

无锁数组：AtomicIntegerArray

JDK提供了可用的原子数组有：AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray，分别表示整数数组、long型数组和普通对象的数组。

以AtomicIntegerArray为例，本质上是对int[]类型的封装，使用Unsafe类通过CAS的方式控制int[]在多线程下的安全性。

例子：

public class AtomicIntegerArrayDemo {
    static AtomicIntegerArray array = new AtomicIntegerArray(10);

    public static class AddThread implements Runnable{
        @Override
        public void run() {
            for (int k=0;k<10000;k++){
                array.getAndIncrement(k%array.length());
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread[] ts = new Thread[10];
        for (int k = 0;k<10;k++){
            ts[k]=new Thread(new AddThread());
            ts[k].start();
        }
        for (int k=0;k<10;k++){
            ts[k].join();
        }
        System.out.println(array);
    }
}

output：
[10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000]

让普通变量也使用原子操作：AtomicIntegerFiledUpdater

由于初期考虑不周，或者后期需求发生变化，一些普通变量可能也会有线程安全的需求。如果改动不大，可以简单地修改程序中每一个使用到该变量的地方。但该种方式不符合软件设计中的开闭原则。因此可以通过Updater，以少量的代码修改使普通变量也具有线程安全性。

Updater根据数据类型不同，分为3类：AtomicIntegerFiledUpdater、AtomicLongFiledUpdater和AtomicReferenceFiledUpdater。

举例：假设进行一次选举，选民投一票记为1，否则记为0。最终选票是简单求和。

public class AtomicIntegerFieldUpdaterDemo {
    public static class Candidate {
        int id;
        volatile int score;
    }

    public final static AtomicIntegerFieldUpdater<Candidate> scoreUpdater =
            AtomicIntegerFieldUpdater.newUpdater(Candidate.class, "score");

    // 用于检查Updater是否正确
    public static AtomicInteger allScore = new AtomicInteger(0);

    public static void main(String[] args) throws InterruptedException {
        final Candidate stu = new Candidate();
        Thread[] t = new Thread[10000];
        for (int i = 0; i < 10000; i++) {
            t[i] = new Thread() {
                @Override
                public void run() {
                    if (Math.random() > 0.4) {
                        scoreUpdater.incrementAndGet(stu);
                        allScore.incrementAndGet();
                    }
                }
            };
            t[i].start();
        }
        for (int i = 0; i < 10000; i++) {
            t[i].join();
        }
        System.out.println("score=" + stu.score);
        System.out.println("allScore=" + allScore);
    }
}

output:
score=5922
allScore=5922

注意事项

  1. Updater只能修改它可见范围内的变量，因为Updater使用反射得到这个变量。比如score声明为private，就是不可行的。
  2. 为了确保变量被正确读取，它必须是volatile的。如果源代码中未声明这个类型，简单添加即可。
  3. 由于CAS操作会通过对象实例中的偏移量直接进行赋值，因此它不支持static字段（Unsafe.objectFieldOffset() 方法不支持静态变量）。

无锁的Vector

SynchronousQueue的实现

死锁

死锁：两个或多个线程相互占用对方需要的资源，而都不进行释放，导致彼此之间相互等待对方释放资源，产生无限制等待的现象。

zzypiper
关注
专栏目录
Java并发编程面试题——JUC专题
二蛋的博客
02-20 7445
1.1AQS是什么？1.2唤醒线程时，AQS为什么从后往前遍历？1.3AQS为什么用双向链表，（为啥不用单向链表）？1.4AQS为什么要有一个虚拟的head节点1.5ReentrantLock的底层实现原理1.6ReentrantLock的公平锁和非公平锁的区别1.7ReentrantReadWriteLock如何实现的读写锁2.1说下你熟悉的阻塞队列？2.2虚假唤醒是什么？3.1线程池的7个参数3.2线程池的状态有什么，如何记录的？3.3线程池常见的拒绝策略3.4线程池执行流程3.5线程池为什么添加空任务
Java正则表达式匹配的坑
MengW9的博客
08-19 441
今天在判断字符串是否存在某个字符串，直接用String.matches(regex)，死活匹配不出来，在线正则工具用了很多都是可以的，后面找到问题，总结一下，防止再次踩坑。 一、前提 java中判断一段字符串中是否包含某个字符串的方式： 1、 String.matches(regex); 阅读源码发现，这个方法本质是调用了Pattern.matches(regex, str)，而该方...
锁优化的简单思路
杏仁技术站
09-04 212
作者 | 黄书柏杏仁java开发工程师，专注后端开发。锁优化的简单思路在多核时代，多线程对系统的性能提升有着巨大的作用，但是多线程对系统也相应的产生了额外的开销，线程本身...
深入底层讲解：从 Synchronized 到锁的优化全过程解析
欢迎您访问我的公众号【前程有光】
03-15 417
我们知道 Synchronized 是 Java 中解决并发问题的一种最常用的方法, 也是最简单的一种方法. 被也被称为内置锁. Synchronized 的作用主要有三个： 确保线程互斥的访问同步代码 保证共享变量的修改能够及时可见 有效解决重排序问题。 从语法上讲, Synchronized 总共有三种用法: 修饰普通方法, 锁是当前实例对象. 修饰静态方法, 锁是当前类的 class 对象. 修饰代码块, 锁是括号中的对象. 关于使用方式, 这里就不再进行一一描述了. 我们直接进入正题, 看.
Java并发编程——Java中的锁
IT深耕十余载，大道之简
05-13 685
在Java并发编程中，锁（Lock）是一个核心概念，用于控制多个线程对共享资源的访问，以避免数据的不一致性和错误的结果。Java提供了多种锁机制，每种锁都有其特定的用途和特性。
Java并发编程——Synchronized锁升级机制
BUPTZhanggg的博客
11-28 1741
Synchronized锁升级流程
Java并发编程3——线程状态转换
m0_43424329的博客
09-17 291
Java线程的状态转换
Java并发编程——创建线程的三种方法以及区别
热门推荐
想着百万年薪努力的小赵
08-26 8万+
Java使用Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。Java可以用三种方式来创建线程，如下所示： 继承Thread类创建线程 实现Runnable接口创建线程 使用Callable和Future创建线程 下面让我们分别来看看这三种创建线程的方法。 ------------------------继承Thread类创建线程--------------------- 通过继承Thread类来创建并启动多线程的一般步骤如下 1】定义Thread类的子类，并重写该
Java并发编程的艺术(十三)——锁优化
大闲人柴毛毛
02-28 4327
自旋锁 背景：互斥同步对性能最大的影响是阻塞，挂起和恢复线程都需要转入内核态中完成；并且通常情况下，共享数据的锁定状态只持续很短的一段时间，为了这很短的一段时间进行上下文切换并不值得。 原理：当一条线程需要请求一把已经被占用的锁时，并不会进入阻塞状态，而是继续持有CPU执行权等待一段时间，该过程称为『自旋』。 优点：由于自旋等待锁的过程线程并不会引起上下文切换，因此比较高效； 缺点：自旋等待过程线程
Java并发编程——锁（干货满满）
silseven的博客
10-12 369
锁synchronizedLock接口队列同步器可重入锁（ReentrantLock） 本文参考了 黑马JUC并发编程 Java并发编程的艺术 深入理解java虚拟机 synchronized 在讲锁之前，先回顾一下synchronized的知识 在java中，最基本的互斥同步就是synchronized关键字。这是一种块结构（Block Structured）的同步语法。其经过Javac编译后，会分别形成monitorenter和monitorexit两个字节码指令。两者都需要一个reference类型的
Java并发编程总结——慎用CAS详解
09-02
Java并发编程中，CAS（Compare and Swap，比较并交换）是一种无锁算法，常用于实现原子操作，它在多线程环境下提供了数据的一致性。然而，CAS并不是万能的，过度依赖或不当使用可能会导致问题。下面我们将深入探讨...
Java并发编程之——Amino框架
08-10
Java并发编程是一个复杂而重要的主题，它涉及到多线程、同步机制、线程池和并发容器等关键概念。Amino框架是Java并发编程领域的一个工具，它旨在简化并发编程，提高程序的性能和可维护性。这篇博客文章可能详细探讨...
java并发编程——内存模型
02-24
并发——在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行，但任一个时刻点上只有一个程序在处理机上运行——源自百度百科在并发编程中，我们需要...
YOLOv11深度学习目标检测详解及应用示例
10-02
内容概要：深入剖析了最新款YOLOv11的目标检测系统，涵盖模型使用的命令集合与配置规则，并提供了一份经过详尽注释的经典应用场景实例代码。本文指导完成YOLOv11环境的配置，并演示了利用该模型执行对象探测的具体流程。 适用人群：针对有一定机器学习背景的研究员和技术开发者。 使用场景及目标：适配不同的开发环境进行物体检测系统的设定与运行，适用于安防监控、智能导航等多领域的物体自动识别。 其他说明：提供了全面的数据准备、训练指南和推论展示样例帮助使用者更好地理解和掌握该技术的实际应用技巧。
河北金融学院在江西2020-2024各专业最低录取分数及位次表.pdf
10-02
那些年，与你同分同位次的同学都去了哪里？全国各大学在江西2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
LSTM神经网络手写算法.zip
10-02
LSTM神经网络手写算法
第十章 核电学课程总结 核电学的应用
最新发布
10-02
核电子学是一门交叉学科，它结合了电子技术与核辐射探测技术，是电子学的一个重要分支。这门学科的发展始于20世纪初，随着核物理学和粒子物理学的发展而逐渐成熟。核电子学的研究对象包括辐射探测器及其相应的电子电路或系统、核信息的电子学测量技术、配有在线电子计算机的核电子系统、电子器件在核辐射下的辐射效应以及核技术应用中的辐射探测技术和电子技术。 核电子学的发展历史可以追溯到1958年，当时在贝尔格莱德召开的第一次国际核电子学会议上，核电子学的名称被正式采用。从那时起，核电子学开始广泛应用于核物理和粒子物理实验，同时也在核医学、空间科学、移动通信和全球定位系统等领域发挥着重要作用。 核电子学的研究内容包括： 1. 辐射探测器及其信号处理技术。 2. 核信息的测量技术，包括时间间隔测量、空间分辨等。 3. 核电子系统的设计与应用，如在线电子计算机系统。 4. 电子器件和系统的抗辐射加固技术。 5. 核技术在不同领域的应用，如工业、农业、医学等。 核电子学的应用非常广泛，例如在医学领域，它可以帮助诊断和治疗疾病；在工业领域，它用于检测材料的完整性和质量；在环境监测中，它用于检测放射性物质。此外
基于Java开发的angel_giftcard_app后端接口设计源码
10-02
该项目为天使礼品卡APP的后端接口设计源码，采用Java语言编写，共包含193个文件，其中Java源文件146个，XML配置文件35个，YAML文件3个，FTL模板文件3个，Git忽略文件1个，Markdown文件1个，LICENSE文件1个，Maven构建文件1个，属性文件1个，以及命令行文件1个。该后端接口负责实现天使礼品卡APP的业务逻辑和数据交互。
【RL Latest Tech】分层强化学习：MAXQ分解算法python实现
10-02
【RL Latest Tech】分层强化学习：MAXQ分解算法python实现 MAXQ分解是一种用于分层强化学习（Hierarchical Reinforcement Learning, HRL）的算法，由Thomas G. Dietterich提出。该算法通过将复杂的任务分解成更小的子任务来简化问题，并利用这些子任务来构建更复杂的策略。 MAXQ分解的主要思想是将一个复杂的Markov决策过程（MDP）分解成一系列嵌套的子MDP，以便更容易解决。MAXQ算法引入了一种分层的结构，将原始任务逐步分解为多个子任务，从而形成一个任务树（task hierarchy），并通过各个子任务的求解来最终解决整个任务。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值