java并发和锁,自己动手(一)

157.并发编程(一):基础概念,java线程,管程,synchronized锁,ReentrantLock锁 基础概念,java线程,锁 阅读详情

CAS(乐观锁)

cas属于轻量级锁(无锁,自旋锁)
底层实现是lock cmpxchg

CAS,是Compare and Swap的简称,在这个机制中有三个核心的参数:
主内存中存放的共享变量的值:V(一般情况下这个V是内存的地址值,通过这个地址可以获得内存中的值)
工作内存中共享变量的副本值,也叫预期值:A
需要将共享变量更新到的最新值:B
请添加图片描述
如上图中,主存中保存V值,线程中要使用V值要先从主存中读取V值到线程的工作内存A中,然后计算后变成B值,最后再把B值写回到内存V值中。多个线程共用V值都是如此操作。CAS的核心是在将B值写入到V之前要比较A值和V值是否相同,如果不相同证明此时V值已经被其他线程改变,重新将V值赋给A,并重新计算得到B,如果相同,则将B值赋给V。

值得注意的是CAS机制中的这步步骤是原子性的(从指令层面提供的原子操作),所以CAS机制可以解决多线程并发编程对共享变量读写的原子性问题。

AtomicInteger

Unsafe

Unsafe是位于sun.misc包下的一个类,主要提供一些用于执行低级别、不安全操作的方法,如直接访问系统内存资源、自主管理内存资源等,这些方法在提升Java运行效率、增强Java语言底层资源操作能力方面起到了很大的作用。但由于Unsafe类使Java语言拥有了类似C语言指针一样操作内存空间的能力,这无疑也增加了程序发生相关指针问题的风险。在程序中过度、不正确使用Unsafe类会使得程序出错的概率变大,使得Java这种安全的语言变得不再“安全”,因此对Unsafe的使用一定要慎重。
AtomicInteger中使用unsafe
在这里插入图片描述
AtomicInteger 的源码

public class AtomicInteger extends Number implements java.io.Serializable {
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;
    static {
        try {
            //用于获取value字段相对当前对象的“起始地址”的偏移量
            valueOffset = unsafe.objectFieldOffset(AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    private volatile int value;

    //返回当前值
    public final int get() {
        return value;
    }

    //递增加detla
    public final int getAndAdd(int delta) {
        //三个参数,1、当前的实例 2、value实例变量的偏移量 3、当前value要加上的数(value+delta)。
        //增加的时候遇到其他线程使用会自旋,见下文unsafe类的介绍
        return unsafe.getAndAddInt(this, valueOffset, delta);
    }

    //递增加1
    public final int incrementAndGet() {
    	//增加的时候遇到其他线程使用会自旋,见下文unsafe类的介绍
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }
...
}

unsafe中的cas,

    public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
        	//通过var1和var5找到主内存中的值
            var5 = this.getIntVolatile(var1, var2);
            //比较var5是否改变,如果没变就直接赋值并返回,改变了继续循环
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
    }
    public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

在cpp中compareAndSwapInt是这样的

UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x))
  UnsafeWrapper("Unsafe_CompareAndSwapInt");
  oop p = JNIHandles::resolve(obj);
  jint* addr = (jint *) index_oop_from_field_offset_long(p, offset);
  return (jint)(Atomic::cmpxchg(x, addr, e)) == e;
UNSAFE_END

最终c++层是lock cmpxchg
cmpxchg不是原子性的,因为compare的时候有可能其他cpu修改内存值
lock能够保证原子性

所以说cas属于轻量级锁(无锁,自旋锁),可以说他不是锁,因为确实没有上锁,但是又有锁的效果,说他是自旋锁,是因为他呈现出来的就是自旋的样子

锁升级

在这里插入图片描述

偏向锁

当一个线程使用未被访问过的资源的时候,给资源贴上标签,属于这个线程。而这种情况下也是这个线程访问这个资源,无竞争。而这个贴标签的过程就是使用一个54位的指针指向当前线程

轻量级锁

只要发生任何竞争,就从偏向锁升级成轻量级锁。首先会撤销偏向锁,然后每个线程栈中增加一个LR(Lock Record)指针,每个线程通过自旋的方式去访问资源。具体情况如下:

假设线程A和线程B
线程A先获取公共锁到自己的内存中,假设此时锁的指针是指向1
然后A把自己的LR指针赋值到锁中,此时锁指向A
A再去获取一下公共锁的指针,此时1的状态是可改变,就把当前的指向A的锁放回去。否则如果获取的锁改变,就重新来,自旋。
类似于上面的cas图片

自适应自旋锁

竞争的线程太多,或者某个线程占用的时间太长,导致其他锁自旋的时间太长,消耗cpu资源。
jdk1.6之前,如果自旋次数超过10次,或者自旋线程数量超过cpu核数的一半的时候,就变成重量级锁。
jdk1.6之后引入了自适应自旋锁

重量级锁

竞争的线程太多,或者某个线程占用的时间太长,导致其他锁自旋的时间太长,消耗cpu资源。升级成重量级锁。重量级锁需要向操作系统申请

锁消除

public void add(String a, String b){
	StringBuffer sb = new StringBuffer();
	sb.append(a).append(b);
}

例如stringbuffer,是线程安全的,如果在使用他的时候,正常内部会上锁。但是如果JVM判断sb并不会被其他代码引用,则将该代码带默认为线程独有的资源,并不需要同步,所以执行了锁消除操作。

锁粗化

public void test(String a){
	int i = 0;
	StringBuffer sb = new StringBuffer();
	while(i < 100){
		sb.append(a);
		i++
	}
	return sb.toString();
}

锁会加到while上

根据例子学习锁

Object在内存对象中占用多少字节?
在这里插入图片描述
markword -> 8
classpointer -> 4(compressed)
null对齐 -> 4(凑到8的倍数,8字节64位)
o引用本身 -> 4
一共20字节
在这里插入图片描述
classpointer和简单对象指针都进行了压缩,从8变成4
在这里插入图片描述

超线程

JMM(java内存模型)

多线程中就是三个性质1.可见性, 2.原子性,3.有序性。下面的锁对应不同的特性

锁原理使用场景
final实现了Java内存模型的,有序性一个变量要被多个线程访问(类私有)
volatile实现了Java内存模型的,可见性、有序性一个变量要被多个线程访问(存放在共享内存内,共享)
synchronized实现了Java内存模型的,原子性、可见性、有序性
AtomicCAS一个变量要被多个线程访问

synchronized

synchronized是重量级锁
synchronized实现了多线程的有序性,可见性,原子性
代码块使用锁block,其他代码块需要使用block的时候需要等待锁释放。
在代码块处的锁可以是this当前实例。
可以是某个类AnyClass.class,这样所有的实例公用一把锁。

	synchronized (block) {
            System.out.println("block1锁,我是线程" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("block1锁,"+Thread.currentThread().getName() + "结束");
   }
	synchronized (this) {
		...
   }
   	synchronized (AnyClass.class) {
		...
   }

synchronized用在普通方法上,默认的锁就是this,当前实例,不同的实例可以同时访问。
如果作用在static修饰的方法上那就代表着任何实例访问都有一个公共锁。

    public synchronized void method() {
        System.out.println("我是线程" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "结束");
    }
    public static synchronized void method() {
		...
    }

注意事项

性能问题:多线程竞争一个锁时,其余未得到锁的线程只能不停的尝试获得锁,而不能中断。高并发的情况下会导致性能下降。
1.锁对象不能为空,因为锁的信息都保存在对象头里
2.作用域不宜过大,影响程序执行的速度,控制范围过大,编写代码也容易出错
3.避免死锁
4.在能选择的情况下,既不要用Lock也不要用synchronized关键字,用java.util.concurrent包中的各种各样的类,如果不用该包下的类,在满足业务的情况下,可以使用synchronized关键,因为代码量少,避免出错

缺陷

1.效率低:锁的释放情况少,只有代码执行完毕或者异常结束才会释放锁;试图获取锁的时候不能设定超时,不能中断一个正在使用锁的线程,相对而言,Lock可以中断和设置超时
2.不够灵活:加锁和释放的时机单一,每个锁仅有一个单一的条件(某个对象),相对而言,读写锁更加灵活
3.无法知道是否成功获得锁,相对而言,Lock可以拿到状态,如果成功获取锁,…,如果获取失败,…

volatile

volatile实现了可见性,有序性,但是不能保证原子性比如i++在多线程中i使用volatile就不行

线程间可见性

如下代码,如果running不加上volatile,那么程序就会卡住。如果加上了,主线程和t1线程之间就可共享running值。修改会重新写入内存,读取会重新从内存中拿
在这里插入图片描述

有序性(happens-before)

//假设线程A执行writer方法,线程B执行reader方法
class VolatileExample {
    int a = 0;
    volatile boolean flag = false;
    
    public void writer() {
        a = 1;              // 1 线程A修改共享变量
        flag = true;        // 2 线程A写volatile变量
    } 
    
    public void reader() {
        if (flag) {         // 3 线程B读同一个volatile变量
        int i = a;          // 4 线程B读共享变量
        ……
        }
    }
}

根据程序次序规则:1 happens-before 2 且 3 happens-before 4。
根据 volatile 规则:2 happens-before 3。
根据 happens-before 的传递性规则:1 happens-before 4。

上面这个happens-before规则是怎么来的呢,想要深入理解,还得先看下文

DCL例子,禁止重排序

下面的例子为例
多线程下的单例模式(DCL)下的双重检查

public class Singleton {
    public static volatile Singleton singleton;
    /**
     * 构造函数私有,禁止外部实例化
     */
    private Singleton() {};
    public static Singleton getInstance() {
    	//检查1
        if (singleton == null) {
            synchronized (singleton.class) {
            	//检查2
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

可以模拟一下两个线程访问未初始化的资源,最终这种双重检查不会出现问题。

这种可以不使用volatile吗?你看我这个是单例模式,多线程下访问的也只有这一个singleton对象,为什么还要加入volatile呢?
答案是,通过内存屏障防止重排序

Java中的指令重排序有两次,第一次发生在将字节码编译成机器码的阶段,第二次发生在CPU执行的时候,也会适当对指令进行重排。
重排序意思就是,代码执行的顺序可能不是你自己定义的,可能是一个乱序,只不过执行的逻辑不变。单线程没问题,但是多线程就会有问题。
上面的代码重排序可能发生在对象new的时候,字节码编译成机器码时重排序。比如正常的new过程是先半初始化Singleton类为null(0),然后再初始化赋值(4),最后singleton变量和实例关联(7)
在这里插入图片描述
如果4和7被重排了,那么多个线程获取singleton的时候有可能有获取值为null的可能,这是另一个线程在初始化的时候还没执行完,同时被重排指令了。这个时候再看上面的代码,就可能new 两个单例变量

什么是内存屏障呢?
详细文章看看:https://segmentfault.com/a/1190000038355290
前后两个操作之间的屏障。
简单理解就是屏障是墙,阻挡前后。volatile读不可以和下面的任何写重排序。volatile写不可以和下面的读,上面的写重排序。
下面是具体的规则
请添加图片描述
在每个 volatile 写操作的前面插入一个 StoreStore 屏障。
在每个 volatile 写操作的后面插入一个 StoreLoad 屏障。
在每个 volatile 读操作的后面插入一个 LoadLoad 屏障。
在每个 volatile 读操作的后面插入一个 LoadStore 屏障。

内存屏障说明
StoreStore 屏障禁止上面的普通写和下面的 volatile 写重排序。
StoreLoad 屏障防止上面的 volatile 写与下面可能有的 volatile 读/写重排序。
LoadLoad 屏障禁止下面所有的普通读操作和上面的 volatile 读重排序。
LoadStore 屏障禁止下面所有的普通写操作和上面的 volatile 读重排序。

final

final基础部分比较容易理解

写重排序规则

写final域的重排序规则可以确保:在对象引用为任意线程可见之前,对象的final域已经被正确初始化过了

其中变量a可以重排序到初始化函数之外,而变量b一定在初始化函数之内,因为构造函数return之前,插入一个storestore屏障。并且在reader都b之前保证先初始化了。

public class FinalDemo {
    private int a;  //普通域
    private final int b; //final域
    private static FinalDemo finalDemo;

    public FinalDemo() {
        a = 1; // 1. 写普通域
        b = 2; // 2. 写final域
    }

    public static void writer() {
        finalDemo = new FinalDemo();
    }

    public static void reader() {
        FinalDemo demo = finalDemo; // 3.读对象引用
        int a = demo.a;    //4.读普通域
        int b = demo.b;    //5.读final域
    }
    public static void main(String[] args){
    	//读写线程
    	Tread(FinalDemo::writer,"t1").start();
    	Tread(FinalDemo::reader,"t2").start();
    }
}

读重排序规则

读final域的重排序规则可以确保:在读一个对象的final域之前,一定会先读这个包含这个final域的对象的引用。
还是上面的代码,意思是在执行int b = demo.b的时候一定先执行FinalDemo demo = finalDemo,这个是final变量,读取引用和读取变量之间有一个LoadLoad屏障。
相反int a = demo.a可以窜到FinalDemo demo = finalDemo前面执行(不是很理解)

final是否有线程可见性?

最后想说一点,final无法保证线程间可见性
举例:线程线程A执行wirterOne方法,执行完后线程B执行writerTwo方法,然后线程C执行reader方法

public class FinalReferenceDemo {
    final int[] arrays;
    private FinalReferenceDemo finalReferenceDemo;

    public FinalReferenceDemo() {
        arrays = new int[1];  //1
        arrays[0] = 1;        //2
    }

    public void writerOne() {
        finalReferenceDemo = new FinalReferenceDemo(); //3
    }

    public void writerTwo() {
        arrays[0] = 2;  //4
    }

    public void reader() {
        if (finalReferenceDemo != null) {  //5
            int temp = finalReferenceDemo.arrays[0];  //6
        }
    }
}

其中可以保证temp读取的内容=1,但是arrays[0] = 2在哪块执行就未必了

参考:
https://segmentfault.com/a/1190000022904663
https://pdai.tech/md/java/thread/java-thread-x-key-volatile.html#volatile-%E7%9A%84-happens-before-%E5%85%B3%E7%B3%BB
https://segmentfault.com/a/1190000038355290

zabbix系列:内存VM.MEMORY.SIZE监控之total、free、pused、available 参数说明 free -m buffer是即将要被写入磁盘的,而cache是被从磁盘中读出来的. zabbix Web total:1046/1024=1.02G Available:216/1046=20.65% zabbix参数 total- 总物理内存. free- 可用内存. active- 内存当前使用或最近使用,所以它在RAM中。 inactive- 未使用内存. wired- 被标记为始终驻留在RAM中的内... 阅读详情

相关推荐

Unity2D像素刀光实现:粒子方向控制与像素级渲染规范

像素风游戏中的刀光特效并非普通粒子动画,而是需严格遵循像素艺术原理的视觉暂留模拟。其核心在于将‘瞬时切割感’转化为程序可执行的渲染逻辑:通过禁用纹理滤波保障1:1像素锐度,绑定刀锋向量控制粒子运动方向,限定≤0.15秒生命周期匹配人眼暂留阈值,并采用Stretched Billboard实现动态拉伸拖影。该方案兼顾美术语义(如直劈、横扫、突刺)与工程约束(Sorting Layer分层、对象池复用、单粒子GPU优化),广泛适用于Unity2D平台的动作反馈系统,尤其适配《空洞骑士》《死亡细胞》类高节奏像素R

weixin_32390647的博客 288

java并发-锁

轻量级锁的使用场景:如果一个对象虽然有多线程访问,但多线程访问的时间是错开的(也就是没有竞争),那么可以使用轻量级锁来优化。轻量级锁对使用者是透明的,即语法仍然是synchronizd假设有两个方法同步块,利用同一个对象加锁。创建锁记录(Lock Record)对象,每个线程的栈帧都会包含一个锁记录的结构,内部可以存储锁定对象的Mark Word让锁记录中的Object reference 指向锁对象,并尝试用cas替换Object的Mark word,将Mark Word的值存入锁记录。

weixin_54401017的博客 629

Shopee App加密算法逆向实战:从抓包到libshpssdk.so的深度解析

本文详细解析了Shopee App加密算法的逆向过程,从网络抓包发现加密参数入手,通过Frida动态Hook定位到Java层关键方法,并深入追踪至Native层的libshpssdk.so核心函数。文章结合实战演示了如何利用Unidbg模拟执行环境进行算法分析与验证,并探讨了核心参数生成逻辑及风控规避要点,为移动安全与逆向工程研究提供了完整的技术路径。

weixin_28347369的博客 533

构建高性能服务(二)java高并发锁的3种实现

提高系统并发吞吐能力是构建高性能服务的重点和难点。通常review代码时看到synchronized是我都会想一想,这个地方可不可以优化。使用synchronized使得并发的线程变成顺序执行,对系统并发吞吐能力有极大影响,我的博文 http://maoyidao.iteye.com/blog/1149015 介绍了可以从理论上估算系统并发处理能力的方法。   那么对于必须使用synchron...

移动互联网后端技术 2097

2025年人形机器人产业研究

人形机器人是一种模仿人类外形、动作和行为的机器人,旨在替代或辅助人类完成各种任务。其显著特征包括人类外形、动作模仿和智能交互能力。根据形态和功能,人形机器人可分为小型、中型、大型以及服务型、工业型、救援型和娱乐型等类别。发展历程经历了初始阶段、高度集成系统阶段和突破性进展阶段,技术不断进步。关键技术包括执行系统、控制系统和感知与交互系统,涉及机械结构、运动控制、平衡控制、任务执行控制以及感知与交互能力。主要研究方向包括外部仿人化和内部仿生,前者关注外观设计、动作控制和任务执行能力,后者致力于模拟人类核心机制

一名80后IT人的成长记录,记录自己在工作、学习中的点点滴滴,在成长的喜悦与忧心的故事里,铭记反脆弱的勇气。 1575

新能源知识库(68)复叠压缩式热泵蒸汽系统介绍

复叠压缩式热泵蒸汽系统通过多级压缩技术将低品位热能转化为高品位蒸汽,在汽车电镀场景中实现了高效、精准的能源利用。随着超高温工质与智能联供系统的发展,该技术将深度赋能电镀行业的高质量可持续发展。​:±1℃控温保障镀层均匀性,提升产品良率;多台复叠热泵+储热装置(如纺织厂6台热泵)复叠热泵+余热回收+智能控制(化工厂案例)​:无燃烧设计契合汽车行业ESG目标。单台高温热泵机组(如92P型号)复叠压缩式热泵蒸汽系统以。67.4万元(↓22%)600万–1200万元。事故率 ↓90%​​。150万–600万元。

竹君子之家 1426

java高并发锁的3种实现

提到锁,大家可能都会想到synchronized关键字,使用它的确可以解决一切并发问题,但是对于系统吞吐要求更高的,在这里提供了几个小技巧,帮助大家减小锁粒度,提高系统并发能力。 初级技巧 - 乐观锁 乐观锁适合这样的场景:读不会冲突,写会冲突。同时读的频率远大于写。 以下面的代码为例,悲观锁的实现: 乐观锁的实现: 中级技巧 - String.intern() 乐观锁不能很好...

qq_38972548的博客 8187

【DICOM后处理】qt+vs 实现DICOM数据四视图显示

方法用于 设置 2D 视图的“向上”方向,即定义图像在屏幕坐标系中的朝向。该方法直接影响影像的显示方向,尤其在多平面重建(MPR)或非标准切面显示时至关重要。:方法用于 设置渲染窗口在屏幕上的显示位置(以像素为单位)。它控制的是 VTK 渲染窗口的左上角在屏幕坐标系中的坐标位置。DICOM四视图通常指同时显示医学影像的四个不同平面或视角,用于全面分析三维数据(如CT、MRI等)。:基于 标量值 设置不透明度(控制不同组织的显示),显示骨骼or显示高密度流体等。默认朝向原点 (0, 0, 0)

weixin_41804847的博客 1326

java防止并发的几种方法

java防止并发的几种方法 2018\7\19   使用synchronized关键字 3种使用方法: 修饰类方法,作用于当前实例加锁,进入方法要获取当前实例的锁 修饰静态方法,作用于当前实例加锁,进入方法要获取当前实例的锁 修饰代码块,指定加锁对象,给指定对象加锁,进入代码块要先获取指定对象的锁(synchronized参数要传入固定的对象才能起到作用) 使...

baidu_32895877的博客 7907

【OpenClaw从入门到精通】第12篇:OpenClaw 2026子代理实战全攻略:用ACP架构搭建多智能体协作网络(附完整代码)

本文聚焦OpenClaw 2026.3.2版本默认启用的ACP(Agent Communication Protocol)子代理机制,从核心概念、底层原理到企业级实操全流程拆解。先解析子代理的定义、ACP协议通信原理及主从代理分工逻辑,再提供环境准备的详细步骤(版本验证、配置调整、技能安装);随后通过三个递进式虚拟案例(客服分流、智能文档处理、企业级招聘全流程),提供可直接运行的完整代码、执行结果及技术要点解析;最后补充子代理管理运维、性能优化与避坑指南。

专注于人工智能、软件开发、工控自动化、工厂数字化及智能化等领域,希望和大家共同进步! 2385

Cesium雷达追踪追踪(圆锥体效果)

【代码】Cesium雷达追踪追踪(圆锥体效果)

God's asylum的博客 2931

java并发场景下的锁机制

java多线程并发场景下,如何实现锁机制,使得线程安全

grily5的博客 726

华为防火墙——本地Portal认证

配置IP地址、路由、Nat策略使得内网主机可以访问公网服务器对网段不进行认证,对网段进行portal认证。

m0_49864110的博客 3265

Java并发编程:自己动手写一把可重入锁

线程不安全例子 public class Sequence { private int value; public void increament(int number) { int newValue = value + number; try { Thread.sleep((long) (Math.random() *...

张翠山的博客 6700

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

贝叶斯统计 [韦来生编]

贝叶斯(Bayes)统计是近几十年来迅速发展起来的数理统计的一个重要分支。贝叶斯方法与经典统计方法的主要不同之处是进行统计推断时除了利用样本信息外,还要利用参数的先验信息,因此可以提高统计推断或统计决策的效果。它在经济、金融、生物、医学、自然科学和社会科学等许多领域具有广泛的应用。贝叶斯方法的研究已渗透到了统计学的几乎所有领域。作者在给中国科学技术大学概率论与数理统计专业本科生开设的“数理统计”课程中有一章专门讲授“贝叶斯方法和统计决策理论”,近十年来也给中国科学技术大学概率统计专业研究生开设过几次“贝叶斯分析”课。本书是在对过去讲稿的内容作了适当的增减和调整的基础上完成的。  本书共分六章。第1章是绪论,介绍了贝叶斯统计的若干基本概念,同时对必要的数理统计的基础知识有重点地作了回顾。第二章介绍了确定先验分布的若干可供选择的方法。第三章介绍了几类常见统计模型参数的后验分布的主要结果和计算方法。第四章和第五章分别介绍了“贝叶斯统计推断”和“贝叶斯统计决策”的内容。第六章介绍了贝叶斯统计计算的若干方法,包括蒙特卡洛方法和马尔可夫链蒙特卡洛(MCMC)方法以及相关统计软件的简介。本书的每一章附右大量的例题和习题,书末附有常用的几个表格和部分习题解答供读者查用。  大约可在54学时内讲授本书的第1章至第六章的主要内容,教师可根据学时需要选讲本书第1章至第六章的部分内容。书中标“*”号的章节可略去不讲,留给读者作为阅读材料。第六章例题中的R代码和部分例题的数据文件等可从作者个人主页下载。  作者在编写本书的过程中参考了J.O.Berger教授的《统计决策论及贝叶斯分析》和茆诗松教授编写的《贝叶斯统计》等书中的一些内容,以及《贝叶斯分析》一书中由张伟平博士编写的有关贝叶斯统计计算的一些内容。在此表示衷心感谢。  本书编写准备过程中,中国科学技术大学统计与金融系的几个研究生帮助完成了本书部分中文的录入和排版,作者对他们的辛勤工作表示真诚的感谢。高等教育出版社为本书的出版给予了大力支持。在此一并致谢。

java中无锁并发数组队列及其应用

在java中,无锁并发数据结构已经有一大堆了,例如,ConcurrentLinkedQueue、ConcurrentSkipListSet、ConcurrentSkipListMap、ConcurrentHashMap(ConcurrentHashMap实际上是有锁的,只是锁的粒度更小)等。 但是在某个应用中,我需要一种无锁并发的数组容器,并且在容器生成时就指定容量,不需要动态扩展(以避免jvm

景奇的专栏 3938

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

java并发总结

一、并发基础 ㅤ 1、进程与线程 ㅤ 进程 程序由指令和数据组成,但这些指令要运行,数据要读写,就必须将指令加载至 CPU,数据加载至内存。在指令运行过程中还需要用到磁盘、网络等设备。进程就是用来加载指令、管理内存、管理 IO 的 当一个程序被运行,从磁盘加载这个程序的代码至内存,这时就开启了一个进程。 进程就可以视为程序的一个实例。大部分程序可以同时运行多个实例进程(例如记事本、画图、浏览器等),也有的程序只能启动一个实例进程(例如网易云音乐、360 安全卫士等) 线程 一个进程之内可以分为一到多个

liujiqing123的博客 1万+

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

死磕 java同步系列之自己动手写一个锁Lock

问题 (1)自己动手写一个锁需要哪些知识? (2)自己动手写一个锁到底有多简单? (3)自己能不能写出来一个完美的锁? 简介 本篇文章的目标一是自己动手写一个锁,这个锁的功能很简单,能进行正常的加锁、解锁操作。 本篇文章的目标二是通过自己动手写一个锁,能更好地理解后面章节将要学习的AQS及各种同步器实现的原理。 分析 自己动手写一个锁需要准备些什么呢? 首先,在上一章学习synchronized的...

java1856905的博客 250

java并发排它锁_并发系列-Java中对锁的性能优化了解吗?

本章概述 上一篇已经分析过Java中的各种类型的锁,用心的小伙伴会发现上篇文章中已经引出了一些锁的转换过程,多各种锁的性能肯定是存在差异的,本章我们就主要对锁的性能做一些测试,并介绍一些需要注意的细节。性能对比偏向锁和轻量级锁:package org.xinhua.cbcloud.jol;public class Test { //boolean flag = false; //占一个字节 ...

weixin_30529683的博客 168

java自己动手写一个锁Lock

问题 (1)自己动手写一个锁需要哪些知识? (2)自己动手写一个锁到底有多简单? (3)自己能不能写出来一个完美的锁? 简介 本篇文章的目标一是自己动手写一个锁,这个锁的功能很简单,能进行正常的加锁、解锁操作。 本篇文章的目标二是通过自己动手写一个锁,能更好地理解后面章节将要学习的AQS及各种同步器实现的原理。 分析 自己动手写一个锁需要准备些什么呢? 首先,在上一章学习synch...

凡是过往,皆为序章 854

Java并发编程:用AQS写一把可重入锁

测试类 /** * MyAqsLock的测试类 */ public class Main { private int value; private Lock lock = new MyAqsLock(); private Lock lock1 = new ReentrantLock(); public int increment() { ...

张翠山的博客 6725

Java中有多少种锁?

同理,在Java多线程中,如果多个线程同时访问同一段代码或数据,没有“锁”来约束,结果就是数据乱飞,Bug满天。说到锁,有的同学可能会头大:“锁这个东西太难了,每次学完过几天就忘了,还搞得代码跟一锅粥似的。”别急,老韩今天不但帮你梳理清楚Java中到底有多少种锁,还教你一套学习方法,让你学完就能运用,而且不容易遗忘!同学们,锁的本质,是为了解决多线程中的同步问题,但它从来不是用来“炫技”的工具。• 偏向锁:适合线程竞争少的场景,比如某个线程连续操作同一个锁对象时,锁直接“偏向”这个线程,无需加锁和解锁。

m0_61562916的博客 380

【Java 面试 八股文】并发编程篇

是多线程中的队列同步器(AbstractQueuedSynchronizer)。是一种锁机制,它是做为一个基础框架使用的,像ReentrantLock、Semaphore都是基于AQS实现的AQS内部维护了一个先进先出的双向队列,队列中存储的排队的线程在AQS内部还有一个属性state,这个state就相当于是一个资源,默认是0 (无锁状态),如果队列中的有一个线程修改成功了state为1,则当前线程就相等于获取了资源在对state修改的时候使用的 CAS 操作,保证多个线程修改的情况下原子性。

Luo_LA的博客 1314
上一篇: Tomcat类加载,自己看源码
下一篇: 新版jdk的LinkedHashMap源码和LRU
小健健健
博客等级 码龄8年 101粉丝 68原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值