Java多线程之线程安全问题

Java 多线程 ⑤-线程安全问题 || 锁 || synchronized 通过使用锁,对先前的 count++ 操作就可以将其变为原子的,在加上锁后,count++ 的三个指令就会完整执行完毕后才可能被调度走。并不是加上了 synchronized 就一定保证线程安全,得要正确地使用锁,在该使用的时候使用锁,在对的地方使用锁。Java中解决线程安全问题的最主要的方案就是给代码块加锁,通过加锁,可以让不是原子的操作,打包成一个原子的操作。,这些指令的集合统称为指令集,指令集有两种,一种是..... (再讲就串台了,这是计算机组成原理的知识哦) 阅读详情

:cloud:1.线程安全概述

:snowflake:1.1什么是线程安全问题

首先我们需要明白操作系统中线程的调度是抢占式执行的,或者说是随机的,这就造成线程调度执行时线程的执行顺序是不确定的,有一些代码执行顺序不同不影响程序运行的结果,但也有一些代码执行顺序发生改变了重写的运行结果会受影响,这就造成程序会出现bug,对于多线程并发时会使程序出现bug的代码称作线程不安全的代码,这就是线程安全问题。

下面,将介绍一种典型的线程安全问题实例,整数自增问题。

:snowflake:1.2一个存在线程安全问题的程序

有一天,老师布置了这样一个问题:使用两个线程将变量 count 自增 10 万次,每个线程承担 5 万次的自增任务,变量 count 的初始值为 0 。 这个问题很简单,最终的结果我们也能够口算出来,答案就是 10 万。 小明同学做事非常迅速,很快就写出了下面的一段代码:

class Counter {
    private int count;
    public void increase() {
        ++this.count;
    }
    public int getCount() {
        return this.count;
    }
}

public class Main11 {
    private static final int CNT = 50000;
    private static final Counter counter = new Counter();
    public static void main(String[] args) throws InterruptedException {

        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < CNT; i++) {
                counter.increase();
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int j = 0; j < CNT; j++) {
                counter.increase();
            }
        });

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();

        System.out.println(counter.getCount());
    }
}
复制代码

按理来说,结果应该是 10 万,我们来看看运行结果:

运行的结果比 10 万要小,你可以试着运行该程序你会发现每次运行的结果都不一样,但绝大部分情况,结果都会比预期的值要小,下面我们就来分析分析为什么会这样。

:cloud:2.线程加锁与线程不安全的原因

:snowflake:2.1案例分析

上面我们使用多线程运行了一个程序,将一个变量值为0的变量自增10万次,但是最终实际结果比我们预期结果要小,原因就是线程调度的顺序是随机的,造成线程间自增的指令集交叉,导致运行时出现两次自增但值只自增一次的情况,所以得到的结果会偏小。

我们知道一次自增操作可以包含以下几条指令:

load
add
save

我们来画一条时间轴,来总结一下常见的几种情况:

:star:️情况1:线程间指令集,无交叉,运行结果与预期相同,图中寄存器A表示线程1所用的寄存器,寄存器B表示线程2所用的寄存器,后续情况同理。

:star:️情况2: 线程间指令集存在交叉,运行结果低于预期结果。:star:️情况3: 线程间指令集完全交叉,实际结果低于预期。根据上面我们所列举的情况,发现线程运行时没有交叉指令的时候运行结果是正常的,但是一旦有了交叉会导致自增操作的结果会少 1 ,综上可以得到一个结论,那就是由于自增操作不是原子性的,多个线程并发执行时很可能会导致执行的指令交叉,导致线程安全问题。

那如何解决上述线程不安全的问题呢?当然有,那就是对对象加锁。

:snowflake:2.2线程加锁

:zap:️2.2.1什么是加锁

为了解决由于“抢占式执行”所导致的线程安全问题,我们可以对操作的对象进行加锁,当一个线程拿到该对象的锁后,会将该对象锁起来,其他线程如果需要执行该对象的任务时,需要等待该线程运行完该对象的任务后才能执行。

举个例子,假设要你去银行的ATM机存钱或者取款,每台ATM机一般都在一间单独的小房子里面,这个小房子有一扇门一把锁,你进去使用ATM机时,门会自动的锁上,这个时候如果有人要来取款,那它得等你使用完并出来它才能进去使用ATM,那么这里的“你”相当于线程,ATM相当于一个对象,小房子相当于一把锁,其他的人相当于其他的线程。

在java中最常用的加锁操作就是使用 synchronized 关键字进行加锁。

:zap:️2.2.2如何加锁

synchronized 会起到互斥效果, 某个线程执行到某个对象的 synchronized 中时, 其他线程如果也执行到同一个对象 synchronized 就会阻塞等待。 线程进入 synchronized 修饰的代码块, 相当于 加锁 ,退出 synchronized 修饰的代码块, 相当于 解锁 。

java中的加锁操作可以使用 synchronized 关键字来实现,它的常见使用方式如下:

:star:️方式1:使用 synchronized 关键字修饰普通方法,这样会使方法所在的对象加上一把锁。 例如,就以上面自增的程序为例,尝试使用 synchronized 关键字进行加锁,如下我对 increase 方法进行了加锁,实际上是对某个对象加锁,此锁的对象就是 this ,本质上加锁操作就是修改 this 对象头的标记位。

class Counter {
    private int count;
    synchronized public void increase() {
        ++this.count;
    }
    public int getCount() {
        return this.count;
    }
}
复制代码

多线程自增的main方法如下,后面会以相同的栗子介绍 synchronized 的其他用法,后面就不在列出这段代码了。

public class Main11 {
    private static final int CNT = 50000;
    private static final Counter counter = new Counter();
    public static void main(String[] args) throws InterruptedException {

        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < CNT; i++) {
                counter.increase();
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int j = 0; j < CNT; j++) {
                counter.increase();
            }
        });

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();

        System.out.println(counter.getCount());
    }
}
复制代码

看看运行结果:

:star:️方式2: 使用 synchronized 关键字对代码段进行加锁,但是需要显式指定加锁的对象。 例如:

class Counter {
    private int count;
    public void increase() {
        synchronized (this){
            ++this.count;
        }
    }
    public int getCount() {
        return this.count;
    }
}
复制代码

运行结果:

:star:️方式3: 使用 synchronized 关键字修饰静态方法,相当于对当前类的类对象进行加锁。

class Counter {
    private static int count;
    synchronized public static void increase() {
        ++count;
    }
    public int getCount() {
        return this.count;
    }
}
复制代码

运行结果:

常见的用法差不多就是这些,对于线程加锁(线程拿锁),如果两个线程同时拿一个对象的锁,就会产生锁竞争,两个线程同时拿两个不同对象的锁不会产生锁竞争。 对于 synchronized 这个关键字,它的英文意思是同步,但是同步在计算机中是存在多种意思的,比如在多线程中,这里同步的意思是“互斥”;而在IO或网络编程中同步指的是“异步”,与多线程没有半点的关系。

:star:️synchronized 的工作过程:

lock
unlock

synchronized 同步块对同一条线程来说是可重入的,不会出现自己把自己锁死的问题,即死锁问题,关于死锁后续文章再做介绍。

综上,synchronized关键字加锁有如下性质:互斥性,刷新内存性,可重入性。

synchronized关键字也相当于一把监视器锁monitor lock,如果不加锁,直接使用 wait 方法(一种线程等待的方法,后面细说),会抛出非法监视器异常,引发这个异常的原因就是没有加锁。

:zap:️2.2.3再析案例

对自增那个代码上锁后,我们再来分析一下为什么加上了所就线程安全了,先列代码:

class Counter {
    private int count;
    synchronized public void increase() {
        ++this.count;
    }
    public int getCount() {
        return this.count;
    }
}

public class Main11 {
    private static final int CNT = 50000;
    private static final Counter counter = new Counter();
    public static void main(String[] args) throws InterruptedException {

        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < CNT; i++) {
                counter.increase();
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int j = 0; j < CNT; j++) {
                counter.increase();
            }
        });

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();

        System.out.println(counter.getCount());
    }
}

复制代码

多线程并发执行时,上一次就分析过没有指令集交叉就不会出现问题,因此这里我们只讨论指令交叉后,加锁操作是如何保证线程安全的,不妨记加锁为 lock ,解锁为 unlock ,两个线程运行过程如下: 线程1首先拿到目标对象的锁,对对象进行加锁,处于 lock 状态,当线程2来执行自增操作时会发生阻塞,直到线程1的自增操作完毕,处于 unlock 状态,线程2才会就绪取执行线程2的自增操作。

加锁后线程就是串行执行,与单线程其实没有很大的区别,那多线程是不是没有用了呢?但是对方法加锁后,线程运行该方法才会加锁,运行完该方法就会自动解锁,况且大部分操作并发执行是不会造成线程安全的,只有少部分的修改操作才会有可能导致线程安全问题,因此整体上多线程运行效率还是比单线程高得多。

:snowflake:2.3线程不安全的原因

首先,线程不安全根源是线程间的调度充满随机性,导致原有的逻辑被改变,造成线程不安全,这个问题无法解决,无可奈何。

多个线程针对同一资源进行写(修改)操作,并且针对资源的修改操作不是原子性的,可能会导致线程不安全问题,类似于数据库的事务。

由于编译器的优化,内存可见性无法保证,就是当线程频繁地对同一个变量进行读操作时,会直接从寄存器上读值,不会从内存上读值,这样内存的值修改时,线程就感知不到该变量已经修改,会导致线程安全问题(这是编译器优化的结果,现代的编译器都有类似的优化不止于Java),因为相比于寄存器,从内容中读取数据的效率要小的多,所以编译器会尽可能地在逻辑不变的情况下对代码进行优化,单线程情况下是不会翻车的,但是多线程就不一定了,比如下面一段代码:

import java.util.Scanner;

public class Main12 {
    private static int isQuit;
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            while (isQuit == 0) {

            }
            System.out.println("线程thread执行完毕!");
        });
        thread.start();

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入isQuit的值,不为0线程thread停止执行!");
        isQuit = sc.nextInt();
        System.out.println("main线程执行完毕!");
    }
}
复制代码

运行结果:

我们从运行结果可以知道,输入 isQuit 后,线程 thread 没有停止,这就是编译器优化导致线程感知不到内存可见性,从而导致线程不安全。 我们可以使用 volatile 关键字保证内存可见性。 我们可以使用 volatile 关键字修饰 isQuit 来保证内存可见性。

import java.util.Scanner;

public class Main12 {
    volatile private static int isQuit;
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            while (isQuit == 0) {

            }
            System.out.println("线程thread执行完毕!");
        });
        thread.start();

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入isQuit的值,不为0线程thread停止执行!");
        isQuit = sc.nextInt();
        System.out.println("main线程执行完毕!");
    }
}
复制代码

运行结果:

:star:️synchronized与volatile关键字的区别: synchronized 关键字能保证原子性,但是是否能够保证内存可见性要看情况(上面这个栗子是不行的),而 volatile 关键字只能保证内存可见性不能保证原子性。 保证内存可见性就是禁止编译器做出如上的优化而已。

import java.util.Scanner;

public class Main12 {
    private static int isQuit;
    //锁对象
    private static final Object lock = new Object();
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
                synchronized (lock) {
                    while (isQuit == 0) {

                    }
                    System.out.println("线程thread执行完毕!");
                }
        });
        thread.start();

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入isQuit的值,不为0线程thread停止执行!");
        isQuit = sc.nextInt();
        System.out.println("main线程执行完毕!");
    }
}
复制代码

运行结果:

编译器优化除了导致内存可见性感知不到的问题,还有指令重排序也会导致线程安全问题,指令重排序也是编译器优化之一,就是编译器会智能地(保证原有逻辑不变的情况下)调整代码执行顺序,从而提高程序运行的效率,单线程没问题,但是多线程可能会翻车,这个原因了解即可。

:cloud:3.线程安全的标准类

Java 标准库中很多都是线程不安全的。这些类可能会涉及到多线程修改共享数据, 又没有任何加锁措施。例如,ArrayList,LinkedList,HashMap,TreeMap,HashSet,TreeSet,StringBuilder。 但是还有一些是线程安全的,使用了一些锁机制来控制,例如,Vector (不推荐使用),HashTable (不推荐使用),ConcurrentHashMap (推荐),StringBuffer。 还有的虽然没有加锁, 但是不涉及 "修改", 仍然是线程安全的,例如String。

在线程安全问题中可能你还会遇到JMM模型,在这里补充一下,JMM其实就是把操作系统中的寄存器,缓存和内存重新封装了一下,其中在JMM中寄存器和缓存称为工作内存,内存称为主内存。 其中缓存分为一级缓存L1,二级缓存L2和三级缓存L3,从L1到L3空间越来越大,最大也比内存空间小,最小也比寄存器空间大,访问速度越来越慢,最慢也比内存的访问速度快,最快也没有寄存器访问快。

:cloud:4.Object类提供的线程等待方法

除了Thread类中的能够实现线程等待的方法,如 join , sleep ,在Object类中也提供了相关线程等待的方法。

序号方法说明
1public final void wait() throws InterruptedException释放锁并使线程进入WAITING状态
2public final native void wait(long timeout) throws InterruptedException;相比于方法1,多了一个最长等待时间
3public final void wait(long timeout, int nanos) throws InterruptedException相比于方法2,等待的最长时间精度更大
4public final native void notify();唤醒一个WAITING状态的线程,并加锁,搭配wait方法使用
5public final native void notifyAll();唤醒所有处于WAITING状态的线程,并加锁(很可能产生锁竞争),搭配wait方法使用

上面介绍 synchronized 关键字的时候,如果不对线程加锁会产生非法监视异常,我们来验证一下:

public class TestDemo12 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("执行完毕!");
        });

        thread.start();
        System.out.println("wait前");
        thread.wait();
        System.out.println("wait后");
    }
}
复制代码

看看运行结果:

果然抛出了一个 IllegalMonitorStateException ,因为 wait 方法的执行步骤为:先释放锁,再使线程等待,你现在都没有加锁,那如何释放锁呢?所以会抛出这个异常,但是执行 notify 是无害的。

wait 方法常常搭配 notify 方法搭配一起使用,前者能够释放锁,使线程等待,后者能获取锁,使线程继续执行,这套组合拳的流程图如下:

现在有两个任务由两个线程执行,假设线程2比线程1先执行,请写出一个多线程程序使任务1在任务2前面完成,其中线程1执行任务1,线程2执行任务2。 这个需求可以使用 wait/notify 来实现。

class Task{
    public void task(int i) {
        System.out.println("任务" + i + "完成!");
    }
}

public class WiteNotify {
    //锁对象
    private static final Object lock = new Object();
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                Task task1 = new Task();
                task1.task(1);
                //通知线程2线程1的任务完成
                System.out.println("notify前");
                lock.notify();
                System.out.println("notify后");
            }
        });
        Thread thread2 = new Thread(() -> {
            synchronized (lock) {
                Task task2 = new Task();
                //等待线程1的任务1执行完毕
                System.out.println("wait前");
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                task2.task(2);
                System.out.println("wait后");
            }
        });
        thread2.start();
        Thread.sleep(10);
        thread1.start();
    }
}

复制代码

运行结果:

Java多线程系列—线程安全问题(06) 线程安全问题 什么是线程安全 要想弄清楚线程安全问题,首先需要了解什么是线程安全,线程安全经常在工作中被提到,比如:你的对象不是线程安全的,你的线程发生了安全错误,虽然线程安全经常被提到,但我们可能对线程安全并没有一个明确的定义。 《Java Concurrency In Practice》的作者 Brian Goetz 对线程安全是这样理解的,当多个线程访问一个对象时,如果不用考虑这些线程在运行时环境下的调度和交替执行问题,也不需要进行额外的同步,而调用这个对象的行为都可以获得正确的结果,那这个对象便是线 阅读详情

相关推荐

MS1030超声波流量计电路实战:如何用15ps精度优化水表设计(附配置代码)

本文深入探讨了如何利用MS1030超声波流量计芯片实现15ps高精度测量,以优化水表设计。文章从系统误差分配出发,详细解析了硬件电路设计要点、SPI通信配置及核心优化技巧,如利用可编程偏置电压和8回波累加功能来提升抗干扰能力与测量稳定性,并附有实用的配置代码示例。

svm4gardener的博客 341

Java之线程安全

线程1获取到锁之后执行了对应的代码,线程2也要执行这个方法,但是检查锁的状态已经被持有,所以它处在堵塞(BLOCK)的状态,当线程1执行完方法之后,线程2才有可能获得到锁(并不一定),因为线程是抢占式执行的,可能线程1再次执行这个方法,再次先获得到了锁.现在举一个形象点的例子,小人1去上厕所,它获取到了锁,进入到上厕所,其他的小人要想上厕所,因为现在已经上了锁,所以他们只能处在等待堵塞的状态,当小人1出来之后,他们又在一起竞争(小人1也参与竞争),竞争到锁的就可以先上厕所,其它的小人又需要等待,

qq_64580912的博客 6227

27-eMMC电路设计

eMMC硬件电路设计

weixin_66510961的博客 4014

Java多线程安全

我们知道操作系统中线程程的调度是抢占式执行的, 宏观上上的感知是随机的, 这就导致了多线程在进行线程调度时线程的执行顺序是不确定的, 因此多线程情况下的代码的执行顺序可能就会有无数种, 我们需要保证这无数种线程调度顺序的情况下, 代码的执行结果都是正确的, 只要有一种情况下, 代码的结果没有达到预期, 就认为线程是不安全的, 对于多线程并发时会使程序出现BUG的代码称作线程不安全的代码, 这就是线程安全问题.

Code Writers 580

CS224W图神经网络实战:如何用Motifs和Graphlets分析社交网络结构?

本文基于斯坦福CS224W课程,深入探讨了如何利用网络模体(Motifs)和图元(Graphlets)分析社交网络的微观结构。通过实战代码演示,文章介绍了如何识别具有统计显著性的关键连接模式,计算节点的图元度向量以刻画局部拓扑特征,并将这些结构洞见应用于社区发现、影响力分析及图神经网络的节点特征工程,从而提升模型在虚假账号检测等任务中的性能。

2w3e4r5t6y的博客 912

STM32入门教程:WiFi通信

第四步:初始化串口 在生成的代码中,您可以找到一个名为 "USARTx_Init" 的函数,其中 "x" 是您选择的串口号。然后,我们使用 "AT+CIPSEND" 命令发送UDP数据,接收到服务器的回复,并在终端上显示收到的数据。在配置向导中,您可以选择启用USART串口功能,并根据您的硬件连接,将串口设置为与WiFi模块连接的串口。在上述代码中,我们使用了 "HAL_UART_Receive" 函数来接收串口数据,并使用 printf 来在终端上显示收到的数据。如果有任何问题,请随时向我提问。

2401_85258012的博客 1079

Java线程安全

目录 引例 不安全的情况 解决办法 加锁 内存可见性 指令重排序 总结 引例 先来一个引例 : 创建两个线程对同一个变量进行自增50000次 class Counter { // 这个 变量 就是两个线程要去自增的变量 public int count; public void increase() { count++; } } public class Demo1 { private static final Counter

m0_56620669的博客 1252

SAM3 几行代码支持任意图像分辨率,减少显存占用(针对transformers库)

几行代码让sam3支持任意图像分辨率

qq_41234663的博客 156

多线程自增运算的原子性与可见性分析

很多程序的复杂性都是由于并发引起的,如果在并发情况下,如果对象是无状态那可以很好的运行,无论是在单线程还是多线程环境下都没问题,但是很多时候对象的状态是需要上下文维护的,因此在并发情况下就很容易导致不一致性的情况。我们先看下面一个例子:class File { private int num; public void incr() throws InterruptedException

超威半导体 2177

2026年紫光同创数字IC笔试试卷带答案

FPGA基础知识与设计要点摘要 本文围绕FPGA与数字IC设计核心概念,通过单选题、波形分析题、多选题和简答题形式,系统梳理了以下关键知识点: FPGA基础架构 查找表(LUT)是实现组合逻辑的基本单元(题1) CLB包含LUT、触发器和进位链,后者加速算术运算(题6,10) 布局布线优化是减少关键路径延迟的核心方法(题7) 时序分析要点 建立时间(时钟沿前数据需稳定)与保持时间(时钟沿后需保持)的定义(题2,简答1) 亚稳态成因及两级同步器处理跨时钟域信号的方法(多选题1,波形题5) 特殊设计技术 异步复

Open 117

世界模型研究综述【20250702】

自2018年以来,世界模型研究从早期的生成式环境模型+简单控制器,发展到如今与大模型和多模态深度融合,取得了长足进展。Ha和Schmidhuber开创了让智能体“在梦中学习”的范式,随后模型式强化学习在复杂视觉任务中展现威力,如SimPLe和PlaNet将世界模型引入Atari和连续控制。Dreamer系列通过潜在空间想象将这一思路推向极致,从连续控制拓展到Atari甚至开放式3D游戏,实现了统一算法征服多领域任务的壮举。

u013250861的博客 531

多线程自增问题和内置锁

多线程自增问题和内置锁

m0_63159216的博客 439

YOLOv11改进 | 损失函数改进篇 | 2024最新高质量的目标检测边界框回归损失Unified-IoU、FocalUIoU、FocalInvUIoU(设置动态epoch参数)

本文给大家带来的改进机制是最近新提出的高质量的目标检测边界框回归损失,其通过动态调整模型对不同质量预测框的关注,优化目标检测中的边界框回归精度。UIoU引入了FocalBox方法,通过缩放预测框与真实框分配权重,并采用了退火策略(引入动态参数epoch),逐渐将模型的注意力从低质量预测框转移到高质量预测框,平衡了训练速度与检测精度。其还有一定的解决样本不平衡问题,同时该损失函数可以和现有的任何边界框回归损失函数进行结合,例如ShapeIoU和其结合可以形成二次创新,它是一种类似于之前的Inner的机制.

Snu77的博客 4591

Java【多线程】线程安全问题

而是禁止其他线程重新加上这个锁避免其他线程的操作在当前线程的执行过程中插队。反之如果一个代码在多线程并发执行的环境下也不会出现类似于上述的bug。多个线程针对同一个锁对象加锁才会产生互斥(锁冲突/锁竞争)cpu执行这三条指令的过程中,随时可能触发线程的调度切换。2.synchronized()指定的锁对象也得合适。执行任何一个指令的过程中都可能触发上述线程切换操作。当前bug是由于多线程的并发执行代码引起的bug。通过加锁操作让不是原子的操作打包成原子的操作。synchronized(锁对象){//加锁。

zrwcnm的博客 1031

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

Java多线程之线程安全问题_java 线程安全

我们知道操作系统中线程程的调度是抢占式执行的, 宏观上上的感知是随机的, 这就导致了多线程在进行线程调度时线程的执行顺序是不确定的, 因此多线程情况下的代码的执行顺序可能就会有无数种, 我们需要保证这无数种线程调度顺序的情况下, 代码的执行结果都是正确的, 只要有一种情况下, 代码的结果没有达到预期, 就认为线程是不安全的, 对于多线程并发时会使程序出现BUG的代码称作线程不安全的代码, 这就是线程安全问题.

2401_89694232的博客 1064

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

轻松掌握Java多线程 - 第四章:线程安全问题

线程安全是指在多线程环境下,程序能够正确地处理共享资源,确保数据的一致性和正确性。一个线程安全的程序,无论有多少线程并发执行,都不会出现数据破坏或者得到错误结果的情况。/*** 线程安全与非线程安全的对比*/// 演示线程不安全的计数器runCounterTest("线程不安全的计数器", unsafeCounter);// 演示线程安全的计数器runCounterTest("线程安全的计数器", safeCounter);// 线程不安全的计数器count++;

qianmoQ - 关注云计算,关注大数据 1410

Java多线程中的线程安全问题及解决方案

假设我们有一个计数器类`Counter`,它有一个`increment`方法用于增加计数器的值。从测试结果可以看出,`AtomicInteger`的性能最好,而`ReentrantLock`的性能略差。`synchronized`方法和代码块的性能相当,但代码块的粒度更细,性能略好。假设我们有一个银行账户类`BankAccount`,它有一个`deposit`方法用于存款,一个`withdraw`方法用于取款。在上述代码中,`Counter`类的`increment`方法没有进行同步处理。

gg15935728460的博客 492

JAVA中多线程的安全问题以及线程安全问题产生的原因

JAVA中多线程的安全问题 卖票例子: 这里用了无限循环while(true) 所以这里我们等运行完之后手动停止循环就行了… class Ticket implements Runnable { //Ticket票 private int num = 100; public void run() { while(true) { if(...

weixin_42947972的博客 859

深入理解 Java 中的多线程编程:解决线程安全问题

在 Java 多线程编程中,线程安全是一个关键问题。本文介绍了多种解决线程安全问题的方法,包括使用Lock接口、Atomic变量等。每种方法都有其适用的场景和优缺点。适合简单的同步需求,易于使用,但可能影响性能。Lock提供了更灵活的锁控制,但需要显式地获取和释放锁。Atomic变量适合轻量级的线程安全数值操作,性能较高。理解这些技术的适用场景,可以帮助开发者编写高效且安全的多线程程序。

HJKQS的博客 861

【Java多线程(3)】线程安全问题和解决方案

死锁的四个必要条件(重点) 1.锁具有互斥特性。(基本特点) 2. 锁不可抢占:一个线程拿到锁之后,除非它自己主动释放锁,否则别人抢不走。(基本特点) 3. 请求和保持:一个线程拿到一把锁之后,不释放这个锁的前提下,再尝试获取其他锁。(代码结构) 4. 循环等待:多个线程获取多个锁的过程中,出现了循环等待。如前面的场景2。(代码结构)

StuLearn-LJC的博客 1107

java多线程会造成线程安全问题的原因总结

众所周知,多线程会造成线程安全问题,那么多线程为什么会导致线程安全问题呢? 一:首先了解jvm内存的运行时数据区 1.堆区:存储对象实例(和实例变量),数组等 2.java虚拟机栈(方法·栈),存放方法声明,局部变量,对象的引用变量,基本数据类型变量等 3.本地方法栈:存储一些本地方法(native关键字修饰的方法,如hashCode()方法,clone方法,Thread类的star0()方法) 4.方法区:存储类元数据,常量,静态变...

m0_57713282的博客 5184

Java多线程编程中如何有效避免线程安全问题

通过Lock接口,我们可以实现更细粒度的锁控制,例如尝试获取锁(tryLock)、定时获取锁(tryLock(long time, TimeUnit unit))以及可中断的获取锁(lockInterruptibly)等操作。线程池是一种用于管理和复用线程的机制。通过合理地配置线程池的大小和任务队列,可以有效地控制并发线程的数量,避免过多的线程竞争资源导致性能下降和线程安全问题。例如,可以使用局部变量或线程本地存储(ThreadLocal)来存储线程私有的数据,避免多个线程对同一数据的并发访问。

derickForster的博客 710

Java中的多线程——线程安全问题

详细了解Java中的线程安全问题

m0_56911284的博客 2046
上一篇: Java多线程之JUC从入门到精通
下一篇: Java 日志框架,性能无敌,横扫所有对手
JavaMonsterr
博客等级 码龄4年 211粉丝 481原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值