线程同步：锁的初步认识（三）

最新推荐文章于 2026-01-06 12:00:34 发布
原创 最新推荐文章于 2026-01-06 12:00:34 发布 · 235 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #线程 #对象

本文详细介绍了Java中的同步机制，包括synchronized关键字的多种使用方式及其作用范围，通过具体示例展示了如何实现线程间的同步，避免共享资源访问冲突。

  • 同步机制介绍

    • 一个资源被多个执行线程共享，为了防止这个资源可能出现的错误或者数据不一致，人们引入了临界区（critical section）概念。临界区是一个用于访问共享资源的代码块，在统一时间内该代码块只能有一个线程执行
    • Java语言提供了两种基本同步机制
      1.synchronized关键字机制
      2.Lock接口及其实现机制

  • 使用synchronized实现同步

    1. 修饰一个代码块，作用范围是synchronized(this){…}扩起来的代码；
    2. 修饰一个方法，作用范围是整个方法，作用对象是调用这个方法的对象
    3. 修饰静态方法，其作用范围是整个静态方法，作用对象是这个类的所有对象；
    4. 修饰一个类，其作用范围是synchronized(className.Class){…}扩起来的部分，作用的对象是这个类的所有对象

1.修饰一个代码块


1.修饰对象里的代码

public class SyncThread implements Runnable {

    private int number = 0;

    @Override
    public void run() {
        // TODO Auto-generated method stub
            for (int i = 0; i < 3; i++) {
        synchronized (this) {
                this.number++;
                System.out.printf("Thread name: %s number=%d\n", Thread.currentThread().getName(), this.number);
            }
        }
    }
}

执行：

SyncThread syncThread = new SyncThread();
Thread thread = new Thread(syncThread, “syncThread1”);
Thread thread2 = new Thread(syncThread, “syncThread2”);
thread.start();
thread2.start();

结果如下：

Thread name: syncThread1 number=1
Thread name: syncThread1 number=2
Thread name: syncThread1 number=3
Thread name: syncThread2 number=4
Thread name: syncThread2 number=5
Thread name: syncThread2 number=6

当两个并发线程访问同一个对象的同步代码块时，只有上一个线程执行完之后释放该对象锁下一个线程才能执行该代码块并获得该对象的锁。

对以上执行做如下调整：

执行：
Thread thread = new Thread(new SyncThread(), “syncThread1”);
Thread thread2 = new Thread(new SyncThread(), “syncThread2”);
thread.start();
thread2.start();
结果如下：
Thread name: syncThread2 number=1
Thread name: syncThread1 number=1
Thread name: syncThread1 number=2
Thread name: syncThread2 number=2
Thread name: syncThread2 number=3
Thread name: syncThread1 number=3

发现执行结果并未与上一个执行一致。究其原因，两个线程中的对象并不一致，而synchronized (this) {…}锁定的是对象，thread与thread2拿到的锁并不相同，两个对象的锁是互不干扰，所以线程同时执行。

2.修饰对象


1.创建一个账户信息类 

/**
 * @Desciption 创建一个账号类
 * @Author Baozi
 */
public class Account {
    private float balance;

    public Account(float balance) {
        this.balance = balance;
    }

    public double getBalance() {
        return balance;
    }

    public void addAmount(float amount) {
        try {
            Thread.sleep(10);
        } catch (Exception e) {
            e.printStackTrace();
        }
        this.balance += amount;
    }

    public void subtractAmount(float amount) {
        try {
            Thread.sleep(10);
        } catch (Exception e) {
            e.printStackTrace();
        }
        this.balance -= amount;
    }
}

2.创建一个消费者

public class Bank implements Runnable {
    private Account account;

    public Bank(Account account) {
        super();
        this.account = account;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 10; i++) {
            synchronized (account) {
                this.account.subtractAmount(1000);
            }
        }
    }
}

3.创建一个存款人

public class Company implements Runnable {
    private Account account;

    public Company(Account account) {
        this.account = account;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 10; i++) {
            synchronized (account) {
                this.account.addAmount(1000);
            }
        }
    }
}

执行

    Account account = new Account(1000);

        Bank bank = new Bank(account);
        Thread t = new Thread(bank);
        Company company = new Company(account);
        Thread t1 = new Thread(company);
        System.out.printf("Account : Initial Balance: %f\n", account.getBalance());
        t.start();
        t1.start();

        try {
            t.join();
            t1.join();
            System.out.printf("Account : Final Balance: %f\n", account.getBalance());

        } catch (InterruptedException e) {
            e.printStackTrace();
        }

结果：

Account : Initial Balance: 1000.000000
Account : Final Balance: 1000.000000

以上结果可以看出修饰对象相当于将同步代码块的大小扩大到整个实例化对象。

修饰一个方法

public class SyncMethod implements Runnable {
    private int number = 0;
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            String name = Thread.currentThread().getName();
            switch (name) {
            case "1":
                this.addNumber(name);
                break;
            default:
                this.printfNumber(name);
                break;
            }
        }
    }

    private void printfNumber(String name) {
        System.out.printf("Thread name: %s number=%d\n", name, this.number);
    }

    private synchronized void addNumber(String name) {
        this.number++;
        System.out.printf("Thread name: %s number++=%d\n", name, this.number);
    }
}

执行：

SyncMethod method = new SyncMethod();
Thread thread = new Thread(method, “syncThread1”);
Thread thread2 = new Thread(method, “syncThread2”);
thread.start();
thread2.start();

结果如下：

Thread name: 2 number=1
Thread name: 1 number++=1
Thread name: 1 number++=2
Thread name: 2 number=1
Thread name: 2 number=3
Thread name: 1 number++=3

以上结果可以看出一个线程访问同步方法的情况下，另一个线程是可以访问非同步方法而不受阻塞，但是存在获取共享变量时可能存在线程安全问题。

修饰一个静态方法

public class SyncStatic implements Runnable {
    private static int number = 0;
    @Override
    public void run() {
        addNumber();
    }

    public synchronized static void addNumber() {
        for (int i = 0; i < 3; i++) {
            SyncStatic.number++;
            System.out.printf("Thread name: %s number=%d\n", Thread.currentThread().getName(), number);
        }
    }
}

执行：

Thread thread = new Thread(new SyncStatic(), “syncStatic1”);
Thread thread2 = new Thread(new SyncStatic(), “syncStatic2”);
thread.start();
thread2.start();

结果如下：

Thread name: syncStatic1 number=1
Thread name: syncStatic1 number=2
Thread name: syncStatic1 number=3
Thread name: syncStatic2 number=4
Thread name: syncStatic2 number=5
Thread name: syncStatic2 number=6

以上结果结合静态修饰符的特性可以看出，两个线程虽然两个线程的对象不一致，但是引用的方法都是静态方法，而静态修饰符使该方法拥有唯一属性，所以两个线程使用的是同一个锁

修饰一个类

SyncClass implements Runnable {
    private int number;

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 3; i++) {
            synchronized (SyncThread.class) {
                this.number++;
                System.out.printf("Thread name: %s number=%d\n", Thread.currentThread().getName(), this.number);
            }
        }
    }
}

执行：

Thread thread = new Thread(new SyncThread(), “syncThread1”);
Thread thread2 = new Thread(new SyncThread(), “syncThread2”);
thread.start();
thread2.start();

结果如下：

Thread name: syncThread1 number=1
Thread name: syncThread1 number=2
Thread name: syncThread1 number=3
Thread name: syncThread2 number=1
Thread name: syncThread2 number=2
Thread name: syncThread2 number=3

以上结果与修饰对象类似，不同在于synchronized作用于一个类C时，所有C对象是哟同一个锁。

总结

  1. synchronized修饰符作用与非静态方法或者类上时，锁的基本单位是对象，不同对象获取到的锁是不一致的；
  2. synchronized修饰的代码块越小阻塞的时间越短，造成死锁的可能性越小，效率越高；
鸿蒙多线程编程：如何实现线程同步
操作系统内核探秘的博客
05-04 1090
随着鸿蒙操作系统(HarmonyOS)的快速发展，越来越多的开发者开始基于鸿蒙平台开发应用。在多核处理器普及的今天，多线程编程已成为提升应用性能的关键技术。然而，多线程环境下的资源共享和线程同步问题一直是开发中的难点和痛点。理解鸿蒙系统的线程模型和调度机制掌握各种线程同步工具的使用方法避免常见的多线程编程陷阱编写高效、安全的并发代码本文涵盖的范围包括鸿蒙系统的线程管理API、同步原语、性能优化技巧等，适用于鸿蒙2.0及以上版本。第2章介绍鸿蒙线程模型和同步机制的核心概念。
【多线程】初步认识Thread类及其应用
acm_pn的博客
08-18 1176
操作系统针对多个线程的执行，是一个“随机调度”，抢占式执行的过程。线程的调度执行是随机的，我们无法确定两个线程的调度顺序，但是可以控制谁先结束谁后结束。 线程等待就是确定两个线程的结束顺序，通过让后结束的线程等待先结束的线程执行，进入阻塞状态，直到先结束的线程执行完毕，此时阻塞解除，后结束的线程开始执行。这样就能使两个线程的结束顺序得以确定
7. 初步认识线程同步
十三阿哥的博客
01-26 414
初步认识线程同步的含义，通过一个实际案例去更好的认识线程同步。
一文读懂 Linux 线程同步：了解同步原语的设计哲学与实现
2301_80236968的博客
12-22 786
我们可以想一下在生活中，有哪些场景是符合生产和消费的场景？例如：网上购物，去超市购物，在游戏中买皮肤等等，这些都是具有生产者和消费者的场景，那么下面我就用超市来举例。我们首先先思考一个问题：超市是生产者吗？我们经常会去超市购物，所以我们都知道超市并不是生产者，而是起到一个商品汇聚，商品派发，是一个中间场所。而真正的生产者我们想必也都能想到，那就是超市这些商品的供应商，所以：所以完整的生产者和消费者就如上图所示，
locks包：AbstractQueuedSynchronizer初步认识
埃泽漫笔
10-27 1109
和AQS有关的Semaphore进一步理解锁和同步器的关系锁，面向锁的使用者：定义了程序员和锁交互的使用层API，隐藏了实现细节，你调用即可同步器，面向锁的实现者：Java并发大神DoungLee，提出了统一规范并简化了锁的实现，将其抽象出来，屏蔽了同步状态管理、同步队列的管理和维护、阻塞线程排队和通知、唤醒机制等，是一切锁和同步组件实现的----公共基础部分AQS同步队列的基本结构。
初步认识线程
2303_77303297的博客
03-08 627
同时,我们让A和B分别负责组装的一部分(比如一个负责车身,一个负责引擎),这样他们只需要培训他们负责的部分就可以了,培训成本就节省了。同时,我们让A和B分别负责组装的一部分(比如一个负责车身,一个负责引擎),这样他们只需要培训他们负责的部分就可以了,培训成本就节省了。当一个组装人员来完成这个任务时,我们需要很长的时间,于是此时,我们另外又聘请了一位组装人员B,B和A一样,分配了一个组装台,需要自己组装完整的车,在这种共同执行的条件下,每个人只需要组装50台车就可以完成任务。
java如何使用线程锁的_Java线程知识：二、锁的简单使用
weixin_39646658的博客
02-25 313
锁的初步认识说到锁，相信大家都不陌生，这是我们生活中非常常见的一种东西，它的形状也各式各样。在生活中，我们通常用锁来锁住房子的大门、装宠物的笼子、装衣服的衣柜、以及装着我们一些小秘密的小抽屉......那么相同的，Java中的锁也各式各样，我们往往按照是否含有某一特性来定义锁，并将锁进行归、分组，具体可分为以下几种：而这些锁在Java中的具体实现都离不开synchronized 关键字和java....
Java-初步认识-第十三章-多线程(验证同步函数的锁)
纵横阡陌
05-16 273
一.至于同步函数用的是哪个锁，我们可以验证一下，借助原先卖票的例子 对于程序中的num，从100改为400，DOS的结果显示的始终都是0线程，票号最小都是1。票号是没有问题的，因为同步了。有人针对只出现0线程，说是票数太少，0线程都给操作完了。即使改成四万张票，也是0线程操作。正常来说，四个线程0~3，谁抢到谁就运行。问题出现在哪儿？程序中run函数是public synchronized voi...
【JavaEE】初步认识多线程
2302_79806056的博客
08-08 1769
下面是一些关于线程的关键点：控制流：线程是进程内单一顺序的控制流，每个线程有自己的执行栈和寄存器状态，但共享所属进程的资源，如内存空间、文件句柄和信号。资源共享：在同一进程中，多个线程共享相同的虚拟地址空间、全局变量和其他进程级别的资源，这使得线程间的通信和数据共享比进程间更加高效和简单。独立调度：线程是独立调度和分派的基本单位，这意味着它们可以被操作系统调度来利用CPU时间，从而实现并行或并发执行。类型：
线程应用，主要展示初学者同步线程的认识与介绍
04-16
附件为视频案例。主要对初学者展示了同步线程的认识 案例介绍了兔子与乌龟赛跑的同步线程，比较形象的介绍了大家对线程的初步理解
线程同步进阶：深入理解C# Monitor的Enter和Exit方法
# 1. C#线程同步基础 在C#编程中，线程同步是保证多线程应用程序稳定运行的关键。...本章内容会以浅显易懂的方式介绍同步的基础知识，通过简单的代码示例和逻辑分析，帮助初学者建立起对线程同步的初步认识。
USB通信中的多线程技术：VC++同步与并发的高级应用
![USB通信中的多线程技术：VC++同步与并发的高级应用]...最后，文章对多核处理器技术的影响、新型同步机制的发展趋势，以及多线程技术在USB通信领域的未来应用进行了展望，强调了性能优
【线程池 + Socket 服务器】
2401_86718044的博客
01-01 1261
通过线程池 + Socket 的组合，我们可以轻松构建高并发、可扩展的网络服务器。Flush 机制看似小细节，却直接影响数据是否及时、正确到达客户端。掌握自动与手动两种方式，就能应对从简单聊天到文件上传的各种场景。这两个示例代码都已经过完整测试，直接复制运行即可。欢迎在评论区分享你的实践经验，或者提出想看的进阶话题（如 NIO、非阻塞、HTTP 协议解析）
01.05.01 Java 基础系列｜深入理解 BIO：从核心 API 到实战设计
u010105645的专栏
01-03 568
摘要：本文深入解析Java BIO（阻塞式I/O）编程，从核心API到生产级实现。BIO作为Java网络编程基础，采用同步阻塞模型，通过ServerSocket监听连接、Socket进行数据传输。文章演示了BIO的三个演进阶段：单线程模型（性能低下）、多线程模型（易资源耗尽）到最终的线程池伪异步模型（生产级方案）。重点讲解了线程池配置、资源管理、异常处理等实战技巧，并提供了完整的线程池BIO服务器实现代码，帮助开发者理解传统IO模型的核心原理及其适用场景。
面向微服务事件驱动与异步消息可靠处理的互联网系统高可用设计与多语言工程实践分享
2501_94180531的博客
01-05 281
事件驱动解耦服务，提高吞吐可靠投递与幂等消费保证消息一致性监控、重试与顺序控制是稳定性的关键微服务事件驱动与异步消息可靠处理，使系统在高并发和复杂业务场景下保持稳定与可控。通过在多语言系统中统一幂等语义、结合可靠投递、顺序控制和监控策略，互联网系统能够在异步流程中实现高可用和长期可维护性。这篇关于事件驱动与异步消息可靠处理的工程实践分享，希望为你在微服务高可用设计中提供可落地、长期有效的参考思路。
TDengine JAVA 语言连接器入门指南
TDengine(老段）专注时序数据库领域
01-04 1518
JAVA 语言连接器
windows下的守护进程|nssm
最新发布
slongzhang的博客
01-06 608
NSSM（Non-Sucking Service Manager）是Windows系统中将普通程序封装为系统服务的工具。使用步骤包括：下载解压NSSM，以管理员身份运行CMD/PowerShell；通过图形界面或命令行安装服务，配置可执行文件路径、参数等；使用start/stop/restart命令管理服务；支持通过edit命令修改配置或remove删除服务；建议配置日志功能方便排查问题。核心功能是实现进程守护，确保程序异常退出后自动重启。
全局异常处理器（Global Exception Handler）
u010448530的博客
12-31 640
/ 统一返回结构// getter/setter 省略// getter优势说明✅ 统一错误格式前端无需处理各种异常结构✅ 解耦业务逻辑Controller 只关注业务，不写 try-catch✅ 提升可维护性异常处理集中管理✅ 增强安全性避免敏感信息泄露通过全局异常处理器，你的 Spring Boot 应用将具备更专业、稳定的 API 行为。建议结合自定义异常 + 参数校验 + 日志监控构建完整异常体系。
调用embedding生成向量并存储到milvus中，进行查询
java
01-04 204
先按装docker ,milvus,attu。Attu 是 milvus 的可视化界面，第一步：操作milvus 的工具类。第二步：对应操作的实体对象。这里需要jdk21.三个节点都需要起动。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值