线程同步问题，引出锁的概念

已于 2022-05-18 17:17:04 修改
阅读量547 收藏
点赞数
分类专栏： java基础 多线程 文章标签： java
于 2022-05-04 18:35:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bo_wei/article/details/124573508
版权

前言

什么是线程同步

线程同步： 即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作， 其他线程才能对该内存地址进行操作，而其他线程又处于等待状态

常用锁

  • 同步锁，使用关键字 synchronized
  • 可重入锁 ReentrantLock

使用场景

java 编程中，多个线程，同时对一个对象进行操作，会引发出数据不一致的问题，也就是 高并发 场景，要确保数据的安全

例子说明

多用户购票场景

不安全例子
package com.wei.sync;

/**
 * @author: wei
 * @date 2022/5/4 16:59
 * 说明：
 **/
public class UnSafeBuyTicket {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        new Thread(ticket, "用户1").start();
        new Thread(ticket, "用户2").start();
        new Thread(ticket, "用户3").start();
    }
}

class Ticket implements Runnable {

    int ticketNums = 10;

    boolean flag = true;

    @Override
    public void run() {
        try {
            while (flag) {
                Thread.sleep(200);
                buy();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void buy() {
        if (ticketNums <= 0) {
            flag = false;
            return;
        }
        System.out.println(Thread.currentThread().getName() + "买到票No:" + ticketNums);
        ticketNums--;
    }
}
安全的改进方案

方式1：在buy()方法上，增加关键字 synchronized，表示 锁 Ticket2 对象的 buy() 方法

package com.wei.sync;

/**
 * @author: wei
 * @date 2022/5/4 16:59
 * 说明：
 **/
public class SafeBuyTicket {
    public static void main(String[] args) {
        Ticket2 ticket = new Ticket2();
        new Thread(ticket, "用户1").start();
        new Thread(ticket, "用户2").start();
        new Thread(ticket, "用户3").start();
    }
}

class Ticket2 implements Runnable {

    int ticketNums = 10;

    boolean flag = true;

    @Override
    public void run() {
        try {
            while (flag) {
                Thread.sleep(1000);
                buy();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    // 方式1：使用 synchronized 锁 Ticket2 对象的 buy 方法
    public synchronized void buy() {
        if (ticketNums <= 0) {
            flag = false;
            return;
        }
        System.out.println(Thread.currentThread().getName() + "买到票No:" + ticketNums);
        ticketNums--;
    }
}

方式2：使用关键字 synchronized，括住buy()方法块代码，表示 锁 Ticket2 对象的 buy() 方法

package com.wei.sync;

/**
 * @author: wei
 * @date 2022/5/4 16:59
 * 说明：
 **/
public class SafeBuyTicket {
    public static void main(String[] args) {
        Ticket2 ticket = new Ticket2();
        new Thread(ticket, "用户1").start();
        new Thread(ticket, "用户2").start();
        new Thread(ticket, "用户3").start();
    }
}

class Ticket2 implements Runnable {

    int ticketNums = 10;

    boolean flag = true;

    @Override
    public void run() {
        try {
            while (flag) {
                Thread.sleep(200);
                // this 表示当前对象，此处锁的是 Ticket2 这个对象的buy方法
                synchronized (this) {
                    buy();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void buy() {
        if (ticketNums <= 0) {
            flag = false;
            return;
        }
        System.out.println(Thread.currentThread().getName() + "买到票No:" + ticketNums);
        ticketNums--;
    }
}

方式3：使用可重入锁ReentrantLock，显式加锁与解锁代码块

package com.wei.sync;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @author: wei
 * @date 2022/5/4 16:59
 * 说明：
 **/
public class SafeBuyTicket {
    public static void main(String[] args) {
        Ticket2 ticket = new Ticket2();
        new Thread(ticket, "用户1").start();
        new Thread(ticket, "用户2").start();
        new Thread(ticket, "用户3").start();
    }
}

class Ticket2 implements Runnable {

    int ticketNums = 10;

    boolean flag = true;

    ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        try {
            while (flag) {
                Thread.sleep(200);
                
                // 方式3：使用可重入锁，显式加锁与解锁代码块
                try {
                    lock.lock();
                    buy();
                } finally {
                    lock.unlock();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void buy() {

        if (ticketNums <= 0) {
            flag = false;
            return;
        }
        System.out.println(Thread.currentThread().getName() + "买到票No:" + ticketNums);
        ticketNums--;
    }
}

两个人同时取一个账户的钱

不安全例子
package com.wei.sync.account;

import java.util.concurrent.TimeUnit;

/**
 * @author: wei
 * @date 2022/5/4 17:37
 * 说明：
 **/
public class UnsafeDraw {
    public static void main(String[] args) {
        Account account = new Account(100);
        Bank bank = new Bank(account, 50, "小王");
        Bank bank2 = new Bank(account, 80, "小明");

        bank.start();
        bank2.start();
    }
}

class Bank extends Thread {

    Account account;
    int draw;

    public Bank(Account account, int draw, String name) {
        super(name);
        this.account = account;
        this.draw = draw;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "取钱 " + draw + "，初始金额=" + account.initMoney);
        try {
            TimeUnit.MILLISECONDS.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //synchronized (account) {
        System.out.println(Thread.currentThread().getName() + "取钱 " + draw + "，再次确认初始金额=" + account.initMoney);
        if (account.initMoney < this.draw) {
            System.out.println(Thread.currentThread().getName() + "取钱 " + draw + "，余额不足");
            return;
        }
        int nowMoney = account.initMoney - this.draw;
        account.initMoney = nowMoney;
        System.out.println(Thread.currentThread().getName() + "取完钱，剩余金额=" + nowMoney);
        //}
    }
}

class Account implements Runnable {
    int initMoney;

    public Account(int initMoney) {
        this.initMoney = initMoney;
    }

    @Override
    public void run() {

    }
}
安全的改进方案

方式1：使用synchronized (account) 对账户进行加锁，不能写 synchronized (this) this 是对银行对象加锁，没用

package com.wei.sync.account;

import java.util.concurrent.TimeUnit;

/**
 * @author: wei
 * @date 2022/5/4 17:37
 * 说明：
 **/
public class UnsafeDraw {
    public static void main(String[] args) {
        Account account = new Account(100);
        Bank bank = new Bank(account, 50, "小王");
        Bank bank2 = new Bank(account, 80, "小明");

        bank.start();
        bank2.start();
    }
}

class Bank extends Thread {

    Account account;
    int draw;

    public Bank(Account account, int draw, String name) {
        super(name);
        this.account = account;
        this.draw = draw;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "取钱 " + draw + "，初始金额=" + account.initMoney);
        try {
            TimeUnit.MILLISECONDS.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 对账户 account 进行加锁，不能写 synchronized (this)  this 是对银行对象加锁，没用
        synchronized (account) {
            System.out.println(Thread.currentThread().getName() + "取钱 " + draw + "，再次确认初始金额=" + account.initMoney);
            if (account.initMoney < this.draw) {
                System.out.println(Thread.currentThread().getName() + "取钱 " + draw + "，余额不足");
                return;
            }
            int nowMoney = account.initMoney - this.draw;
            account.initMoney = nowMoney;
            System.out.println(Thread.currentThread().getName() + "取完钱，剩余金额=" + nowMoney);
        }
    }
}

class Account implements Runnable {
    int initMoney;

    public Account(int initMoney) {
        this.initMoney = initMoney;
    }

    @Override
    public void run() {

    }
}

多线程往集合存放数据

不安全例子

资料上说是不安全的，但是~~~，我电脑没重现出来

package com.wei.sync;

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

/**
 * @author: wei
 * @date 2022/5/4 18:20
 * 说明：
 **/
public class array {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                // 往list写数据
                list.add(UUID.randomUUID().toString());
                // println方法调用toString()方法，会遍历list对象，然后抛异常：java.util.ConcurrentModificationException
                System.out.println(list);
            }).start();
        }
    }
}
安全的改进方案

方式1：使用 CopyOnWriteArrayList

package com.wei.java.basic.sync.array;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * @author: wei
 * @date 2022/5/4 18:20
 * 说明：ArrayList 不安全
 * 多个线程操作同一个对象，对数据又读又写，就会有并发修改数据异常
 **/
public class array {
    public static void main(String[] args) throws InterruptedException {
        // ArrayList 不安全
        //List list = new ArrayList<>();

        // 推荐使用CopyOnWriteArrayList
        /**
         * 原理：
         * 线程读取该list的数据时，会先 copy 一份副本到工作内存，然后读副本中的数据
         * 其他线程往 list 中写入数据，不影响当前副本的数据，所以不会出现并发读写异常
         */
        List list = new CopyOnWriteArrayList();
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                list.add(UUID.randomUUID().toString());
                System.out.println(list);
            }).start();
        }
    }
}
fengshangzhuzhu
关注
专栏目录
多线程 及线程同步问题详解
C_CXY2333的博客
08-02 483
多线程 ###  多线程： - 程序：一个可执行文件 - 进程：一个正在运行的程序，也可以理解成为内存中的开辟的存储空间 - 线程：负责程序的运行，可以看作是一条执行的通道或执行单元，所以我们通常将进程的工作理解成线程的工作。 进程中可不可以没有线程？必须有线程，至少有一个，当有一个线程的时候我们称为单线程（唯一的线程就是主线程）当有一个以上的线程...
线程间同步（QT）
LLJ_DS的博客
02-25 1897
多个线程同时访问共享数据时可能会冲突，出现意料之外的结果，这源于操作的原子性问题，关于操作原子性可问度娘，这里不多做解释。
线程同步问题和互斥锁mutex
城南花已开的博客
02-21 213
我们通过下例程序，引出线程同步的概念： 该代码功能为两个线程不断向STDOUT打印hello world，子线程是小写的，主线程是大写的 #include<stdio.h> #include<string.h> #include<pthread.h> #include<stdlib.h> #include<unistd.h> ...
Java多线程创建及同步锁的理解
MYY的博客
07-21 1034
多线程顾名思义就是多个线程在程序中运行，就比如我们的虚拟机JVM，启动的时候不止启动一个线程，至少有一个是负责Java程序的执行还有一个是垃圾回收机制GC的线程。一个进程中至少有一个线程。
【Linux】线程——线程互斥的概念、锁的概念、互斥锁的使用、死锁、可重入和线程安全、线程同步、条件变量的概念和使用
Crocodile1006的博客
07-16 955
Linux线程、线程互斥、线程互斥的概念、锁的概念、互斥锁的概念、互斥锁的使用、死锁、可重入和线程安全、线程同步、条件变量的概念、条件变量的使用
线程安全与线程同步
Xue95111的博客
08-24 806
线程安全与线程同步 文章目录线程安全与线程同步前言一、什么是线程安全二、线程同步线程同步与原子操作volatile关键字保证线程安全的操作1. synchronized2. synchronized方法3. 手动使用Lock总结 前言 前面已经学习了线程的使用，在使用线程的时候还要注意线程安全。 一、什么是线程安全 假设这样一种场景，如果一个客户在银行有一个账户，客户可以通过柜台，手机app，自助取款机尽情存取款操作。如果某一天客户同一时间点在手机APP和自助取款机进行取钱操作，这个时候就必须有一个机制保证
聊聊C++线程同步机制
JamesDa的博客
11-10 668
  线程同步是一个经常出现的场景，考虑一个生产者消费者模式，一个线程作为生产，一个线程作为消费。生产者往一个队列中加入元素，消费者往一个队列中取元素。实现对一个公共区域的同时访问操作，是C++多线程经常会遇到的问题，所以C++提供了线程同步的机制。   1.消费者轮询。 参考下面代码：一个线程运行Producer，一个线程运行Comsumer，共同操作一个队列，这会导致严重问题：CPU会被跑满...
java单线程上锁,Java多线程详解-锁
weixin_35711852的博客
03-15 674
前言最近工作有点忙，周末也一直在996加班，所以没有时间来写博客，今早忙里偷闲来写一下多线程的第二篇。废话不多说，开始这次的主题。复习上一张我们学习了Java多线程的基础知识。回顾一下：1：实现多线程的两种方式，继承Thread类以及实现Runable接口，然后重写里面的run方法即可。2：线程的状态：新建状态，就绪状态，运行状态，阻塞状态，死亡状态。其中最重要的地方，也是难点就是线程的阻塞状态，...
java多线程系列 ---- 第四篇 数据同步与线程锁
技术熊的博客小窝
09-12 273
终于到了深入的线程内容了。数据同步，线程安全，锁等这些概念是多线程中最复杂也是最重要的内容之一。串行化没那么多麻烦事，但也相对的运行效率低，不能最大化利用CPU。我们想要实现更高效的处理，多线程是必须的。但多线程就出现了 多个线程访问一个资源，出现数据不一致或者错误的情况，接下来就深入探讨如何安全的高效的处理共享数据。 数据同步 数据不一致问题 synchronize关键字 深入学习synchro...
Python多线程同步与通信详解：状态转换与锁、条件变量的应用
这就引出了锁（Lock）的概念，它用于保护共享资源，确保在同一时间只有一个线程可以访问。 锁有锁定和未锁定两种状态，线程在访问共享资源前必须获取锁。如果已有其他线程持有锁，新线程会被阻塞，直到锁被释放。...
Mybatis
庸不易的博客
11-15 645
1、定义不同：#{} 预处理：而 ${} 是直接替换2、使用不同：#{} 适用于所有类型的参数匹配；但 ${} 只适用于数值类型。3、安全性不同：#{} 性能高，并且没有安全问题；但 $ {} 存在 SQL 注入的安全问题。4、使用场景不同：当传递的是一个 SQL 关键字 的时候，只能 使用 ${}。当传递的是一个字段，总之，就是需要获取到参数类型 与 内容，只能使用 #{}。（PS：数字类型，#{} 和 ${} 都是可以使用的！5、 ${} 不能用于 模糊匹配查询；
1112--接口
kequanrrr的博客
11-12 445
interface + 接口名{ }。。。。implements 接口名{ }接口：接口中的抽象方法可以省略 abstract 关键字使用：要实现接口中的所有 抽象方法隐含三个修饰符：public+static+final2.单继承 多接口。
【JavaSE线程知识总结】
最新发布
qq_63713328的博客
11-16 605
本章主要讲解了线程几种线程的创建方式,线程安全问题出现的场景,以及线程安全的解决方式
java加锁问题详解
qq_74056922的博客
11-14 527
java(JVAM)对加锁的API进行了封装,通过使用synchronized关键字来完成加锁操作。
什么是面向对象编程？什么是面向过程编程？
m0_70208894的博客
11-15 493
不同的编程范式适用于不同的场景，选择合适的范式可以提高代码的可维护性、可读性和效率。Java 和 Go 的选择反映了不同的设计哲学，Java 更加注重封装和对象的使用，而 Go 更加简洁，强调过程和函数的使用。
HashMap源码分析下
L25000的专栏
11-16 532
如果这个cap刚好是2的幂次方呢，即4,8,16,32,64等这样的，这样的数已经满足条件了，再减去1，把数变成3,7,31,63。，即hash值的第5为是1，这样在扩容到32后，取索引得出来的结果就和16的不一样了，索引位置比oldCap大了一个oldCap值；,求余数，n是一个2的幂次方数，减去1，即后面全是1，前面全是0，与上这个hash，只能保证经过运算，结果都会在。，即hash值的第5为是0，这样在扩容到32后，取索引得出来的结果还是和16的一样；cap=1，2的0次方就等于1，返回的是就是4。
BP新增页签增强
BinGeneral的博客
11-15 870
以上就是BP新增页签的介绍，希望对您有所帮助。在总结过程中，该篇文档给予了极大的帮助和借鉴。
深入理解Java的类加载与卸载机制
Luffy的博客
11-12 1200
类加载是指JVM将.class文件中的二进制数据读入内存中，经过一系列验证、解析和初始化，最终在JVM中生成可以被使用的Class对象。JVM会为每个类加载并生成一个唯一的Class对象，这个对象封装了类的所有信息，包括方法、属性等。类加载的三大步骤：1.加载（Loading）：从不同的源（如文件、网络）获取类的二进制字节码，并生成Class对象。2.链接（Linking）：对类的二进制进行校验和解析，确保类文件格式正确。验证（Verification）：检查字节码是否符合JVM的规范。
基于java的二手图书交易系统
源码好优多
11-16 68
项目编号：springbootA069现代二手图书交易系统综合了共享信息、电子化、智能化等多种技术，对二手图书交易系统的多个流程了实现整合。信息化的二手图书交易系统是由多个分布式子系统组成的，各分布式子系统既可以完全独立运作，又有一定的联系。只有提高二手图书交易系统的各环节、各子系统的信息化水平，才能提高整个二手图书交易系统的运行效率。使用网络化智能分析技术后，可以实时的获取图书信息或用户需求等数据，对海量的数据进行过滤和分析，就能得到有价值的信息。
Java线程锁与条件对象深度解析
本文将深入讲解Java中的线程同步技术，特别是线程锁和条件对象的概念以及其在并发编程中的应用。在多线程环境中，避免数据竞争和并发问题至关重要。Java提供了多种同步机制，其中synchronized关键字是最基础的，它会...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值