JavaSE-多线程（2.1）- 锁举例1（synchronized）

原创 已于 2025-10-07 22:56:49 修改 · 370 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言 #后端

于 2021-11-26 00:38:07 首次发布
本文详细介绍了如何在Java SE中使用`synchronized`关键字确保在SynchronizedTest4类的put和get方法中，多线程间的操作不会导致数据不一致。通过实例演示了线程安全的容器操作，包括并发put和get的互斥控制。

JavaSE-多线程（2.1）- 锁举例1（synchronized）

package com.hs.example.base.multithread.day01;

import java.util.LinkedList;

/**
 * 自定义容器，固定容量最大值为MAX_COUNT，运行多线程并发put和get
 * @param <T>
 */
public class SynchronizedTest4<T> {

    final LinkedList<T> lists = new LinkedList<>();
    final int MAX_COUNT = 10;
    private int count = 0;

    /**
     * 加锁，防止count与实际lists大小不一致
     *
     * @param t
     */
    public synchronized void put(T t) {
        System.out.println(Thread.currentThread().getName() + " put start...");
        /**
         * 这里为什么用 while 不用if，
         * 比如当前wait线程是a，线程c执行get方法后唤醒a线程，此时 lists.size() = MAX_COUNT -1 
         * a需要重新获取锁，此时线程b也执行put方法，也需要获取锁
         * 如果线程b获取锁成功，那么 lists.size() = MAX_COUNT 
         * 此时a获取锁成功，继续执行，如果不判断 lists.size() == MAX_COUNT
         * 会导致 lists.size() 超出范围
         */
        while (lists.size() == MAX_COUNT) {
            try {
                System.out.println(Thread.currentThread().getName() + " waiting...");
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        lists.add(t);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        count++;
        this.notifyAll();
        System.out.println(Thread.currentThread().getName() + " put end...");
    }

    public synchronized T get() {
        System.out.println(Thread.currentThread().getName() + " get start...");
        T t = null;
        while (lists.size() == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        t = lists.removeFirst();
        count--;
        this.notifyAll();
        System.out.println(Thread.currentThread().getName() + " get end...");
        return t;
    }

    public static void main(String[] args) {
        SynchronizedTest4 synchronizedTest4 = new SynchronizedTest4();
        for (int i = 0; i < 20; i++) {
            Thread t = new Thread(() -> {
                synchronizedTest4.put("str");
            }, "put thread" + i);
            t.start();
        }

        for (int i = 0; i < 20; i++) {
            Thread t = new Thread(() -> {
                synchronizedTest4.get();
            }, "get thread" + i);
            t.start();
        }
    }
}


put thread0 put start...
put thread0 put end...
get thread5 get start...
get thread5 get end...
get thread18 get start...
get thread19 get start...
get thread15 get start...
get thread11 get start...
get thread17 get start...
get thread10 get start...
get thread16 get start...
get thread13 get start...
get thread12 get start...
get thread9 get start...
get thread8 get start...
get thread4 get start...
get thread14 get start...
get thread7 get start...
get thread6 get start...
get thread0 get start...
get thread3 get start...
get thread1 get start...
get thread2 get start...
put thread19 put start...
put thread19 put end...
put thread18 put start...
put thread18 put end...
put thread15 put start...
put thread15 put end...
put thread14 put start...
put thread14 put end...
put thread9 put start...
put thread9 put end...
put thread16 put start...
put thread16 put end...
put thread13 put start...
put thread13 put end...
put thread12 put start...
put thread12 put end...
put thread11 put start...
put thread11 put end...
put thread10 put start...
put thread10 put end...
put thread17 put start...
put thread17 waiting...
put thread7 put start...
put thread7 waiting...
put thread6 put start...
put thread6 waiting...
put thread8 put start...
put thread8 waiting...
put thread3 put start...
put thread3 waiting...
put thread5 put start...
put thread5 waiting...
put thread4 put start...
put thread4 waiting...
put thread2 put start...
put thread2 waiting...
put thread1 put start...
put thread1 waiting...
get thread2 get end...
get thread1 get end...
get thread3 get end...
get thread0 get end...
get thread6 get end...
get thread7 get end...
get thread14 get end...
get thread4 get end...
get thread8 get end...
get thread9 get end...
put thread1 put end...
put thread2 put end...
put thread4 put end...
put thread5 put end...
put thread3 put end...
put thread8 put end...
put thread6 put end...
put thread7 put end...
put thread17 put end...
get thread18 get end...
get thread19 get end...
get thread15 get end...
get thread11 get end...
get thread17 get end...
get thread10 get end...
get thread16 get end...
get thread13 get end...
get thread12 get end...
JavaSE-多线程（2）- 锁
sql2008help的博客
11-06 263
JavaSE-多线程（2）- 锁 synchronized 举例说明：在 SynChronizedTest 类中有一个 count 变量，有两个线程同时对count进行 ++ 操作，希望结果应该为线程每访问一次count +1 ，最终count 值为 2 package com.hs.example.base.multithread.day01; public class SynChronizedTest implements Runnable{ private int count = 0;
JavaSE-多线程（4）- CAS
sql2008help的博客
11-13 803
JavaSE-多线程（4）- CAS CAS （CompareAndSwap）举例 例1：在此例中，有 THREAD_COUNT （20）个数量的线程调用 AtomicTest 对象m方法，对属性count进行自增操作，最后在主线程打印count的最终结果为20，由于存在多线程多并发访问count，所以在自增操作前使用synchronized关键字对AtomicTest对象进行了锁定。 package com.hs.example.base.multithread.day01; public class
JavaSE--多线程
Zzh1110的博客
05-05 2575
文章目录1.并发与并行2.进程与线程3.线程调度4.主线程： 1.并发与并行 ●并发：指两个或多个事件在同一时间段内发生。（交替执行） ●并行：指两个或多个事件在同一时刻发生。（同时发生） 即，并发就是你洗完澡后再听歌，并行就是你一边洗澡一边听歌。 2.进程与线程 （线程<进程） ●进程：程序的执行过程。（可在任务管理器查看） ●线程：进程中的一个执行单元。 一个程序运行后至少有一个进程，一...
JavaSE----多线程总结
qq_45729665的博客
07-04 505
JavaSE多线程总结 1.进程与线程的定义 进程：一个应用程序。 线程：一个应用程序的执行场景或是执行单元 举例： 进程1：阿里巴巴 线程A: 马老师 线程B: 前台小姐姐 进程2：京东 线程A: 刘老师 线程B: 前台小姐姐 进程1和进程2是独立不共享的 线程1和线程2堆内存和方法区共享；栈空间独立不共享 2.实现线程的方法 编写一个类，直接继承Thread，重写run方法： //定义线程类 class MyThread extends Thread{ @Override
JavaSE-多线程（2.2）- 锁举例2（Reentrant Lock ）
sql2008help的博客
11-28 159
JavaSE-多线程（2.2）- 锁举例2（Reentrant Lock ） package com.hs.example.base.multithread.day01; import java.util.LinkedList; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /**
JavaSE-线程安全
2301_81486828的博客
11-28 728
线程安全问题是整个多线程专题的最核心也是最重要的章节, 如果不理解线程的安全, 是无法写出正确的多线程的代码的, 我们之前所写的代码都是在单一的线程环境之下写出的 “玩具式” 的代码, 不存在多线程的复杂关系, 下面我们给出一段代码来引出线程安全的话题…// 定义一个计数器// 定义一个循环的次数// 重置计数器countcount = 0;// 创建线程t1i++){count++;});// 创建线程t2i++){count++;});// 开启线程t1, t2。
javaSE--多线程
weixin_45785893的博客
04-30 226
typora-copy-images-to: …\qq截图 多线程 1.基本概念 程序：是为完成特定任务，用某种语言编写的一组指令的集合，即指一段静态的代码，静态对象 进程：是程序的一次执行过程，或者是正在运行中的程序，是一个动态的过程：有它自身的产生，存在和消亡的过程---生命周期 程序是静态的，进程是动态的，进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域 线程：进程可...
JavaSE-Thread多线程知识点笔记
beekim的博客
03-23 309
注：本笔记于b站up主“遇见狂神说” https://www.bilibili.com/video/BV1V4411p7EF 处学习记录，仅供学习与参考 1，线程，进程，多线程 2，线程创建 Thread,Runnable,Callable 三种创建方式： Thread package Thread; //创建线程方式一：继承Thread类，重写run（）方法，调用start开启线程 //总结： //注意，线程开启不一定立即执行，由cpu调度执行 public class TestThread
【Java多线程进阶】synchronized工作原理
我的主页
06-07 1051
本期讲解：synchronized的工作原理，无锁、偏向锁、轻量级锁、重量级锁。
多线程基础篇 - JavaEE初阶 - 细节狂魔
DarkAndGrey的博客
04-04 9627
文章目录前言线程是什么？Java中执行多线程编程 前言 建议看一下上篇博客开头篇：计算机是如何工作的中 关于PCB【Process Control block - 进程控制块】 属性的那一部分。 线程是什么？ 谈到线程，就不得不说一下进程【进程包含线程】。 思考一个问题：为什么要有进程？ 这是因为我们的操作系统支持多任务。程序员也就需要“并发编程”。【这里并发是宏观的，包含了并发和并行】 通过多进程，是完全可以实现并发编程的。 但是存在问题：如果需要频繁的 创建 / 销毁 进程，这个事情成本是比较
【JavaEE】单例模式如何保证在多线程环境下线程安全高可用？
黄小黄的博客
01-15 1788
对于饿汉式单例模式，由于只存在对同一变量的读操作，不会导致线程安全问题。而对于懒汉式单例模式，由于其读和写操作不是原子的，在多线程环境下会导致线程安全问题。本文就如何实现线程安全的单例模式进行深入探讨，并对为何会引发线程安全问题做出了总结，希望对读者有所帮助。
【多线程】线程安全问题
程序猿教你打篮球的博客
04-25 7578
本期主要讲解： 1.—段线程不安全的代码 2.线程不安全的原因 2.1随机调度 2.2修改共享数据 2.3原子性 2.4内存可见性 2.5指令重排序 3.synchronized加锁操作 3.1针对指定对象加锁 3.2针对this加锁 3.3针对类对象加锁 3.4 synchronized疑难解答 3.5 synchronized是可重入锁
十五、多线程【黑马JavaSE笔记】
BoBooY的Java学习笔记
09-06 822
本文是博主自学b站黑马Java教程总结的笔记，本节对Java中的多线程做了基础的介绍
IntelliJ IDEA 在 Java 多线程开发中的应用
Java大师兄的博客
05-29 756
Java 多线程开发是 Java 编程中的重要组成部分，它允许程序在同一时间执行多个任务，提高程序的性能和响应速度。IntelliJ IDEA 作为一款功能强大的 Java 集成开发环境（IDE），为 Java 多线程开发提供了丰富的工具和特性。本文的目的是详细介绍 IntelliJ IDEA 在 Java 多线程开发中的各种应用，包括代码编写、调试、性能分析等方面，帮助开发者更好地利用 IntelliJ IDEA 进行高效的 Java 多线程开发。
SSM企业物资管理系统h3109(程序+源码+数据库+调试部署+开发环境)带论文文档1万字以上，文末可获取，系统界面在最后面
2509_93102542的博客
11-21 762
在技术实现上，国外多采用成熟的开发框架和技术架构，注重系统的安全性、稳定性和可扩展性，同时积极融入大数据、人工智能等新技术，实现物资需求预测、智能库存优化等功能。基于此，开发一套基于SSM框架的企业物资管理系统，整合部门、员工、物资及各类业务流程管理功能，实现物资管理的数字化、规范化和高效化，成为解决企业物资管理痛点的必然需求。本课题旨在开发一套基于SSM框架的企业物资管理系统，围绕部门、员工、物资信息、物资申请、消息提醒、物资归还、物资入库、意见反馈八大核心功能模块，实现企业物资管理的全流程数字化。
Java原生网络编程-BIO与NIO
最新发布
照母山挖洋芋
11-24 452
摘要：本文对比了Java原生JDK中的BIO(阻塞I/O)和NIO(非阻塞I/O)网络编程模型。BIO采用"一连接一线程"模式，存在线程资源浪费和性能瓶颈问题，可通过线程池优化为伪异步I/O模型。NIO通过Selector、Channel和Buffer三大核心组件实现非阻塞通信，支持单线程管理多个通道。重点介绍了NIO的Reactor模式、事件类型(OP_READ/OP_WRITE等)及服务端/客户端的不同关注点，展示了NIO相比BIO在高并发场景下的优势。（149字）
spring全局懒加载(default-lazy-init)导致的afterPropertiesSet不执行问题
豆豆的博客
11-21 508
Spring配置default-lazy-init="true"会导致所有Bean延迟初始化，影响afterPropertiesSet方法的执行时机。解决方案包括：1)为关键Bean显式设置lazy-init="false"；2)使用@Lazy(false)注解；3)编程式强制初始化；4)使用DependsOn控制顺序。最佳实践建议分层配置策略，核心组件立即初始化，业务组件懒加载，并通过配置文件分离和环境区分优化配置。实际应用中，Web应用的请求处理相关Bean和批处
Java集合框架实战：构建高效的企业管理系统
2402_83075343的博客
11-23 950
本文通过两个企业管理系统案例，详细解析了Java集合框架的核心应用。员工部门管理系统采用HashMap实现部门与员工的高效映射，具备智能添加、快速查询和动态统计功能；商品库存管理系统基于ArrayList实现精细化管控，包含智能录入、库存预警和价格排序等特性。文章对比了HashMap和ArrayList的特性差异，提供了集合选型的最佳实践，并探讨了系统扩展方向。这两个实战案例展示了集合框架在企业应用中的实际价值，为开发者掌握Java集合提供了实用参考。
Spring Boot 中使用 @Transactional 注解配置事务管理
2509_94007314的博客
11-21 1286
下面分别介绍一下的几个属性。
谷歌二维码生成工具包使用教程与javase-3.3.0.jar介绍
- **javase-3.3.0.jar**：文件名称列表中只列出了"javase-3.3.0.jar"，这意味着我们所讨论的压缩包中包含了名为"javase-3.3.0.jar"的单一JAR文件。JAR文件是Java应用程序的打包文件格式，它可以包含类文件、元数据、...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值