多线程同步锁的使用范例

最新推荐文章于 2024-07-29 19:48:37 发布
最新推荐文章于 2024-07-29 19:48:37 发布
阅读量5.5k 收藏 13
点赞数 1
分类专栏： Java 文章标签： 多线程 锁 synchroniz 同步
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fenggering/article/details/53166354
版权

用一个卖票的例子来示范多线程操作一个对象时，同步锁的使用。

先新建一个SaleRunnable类实现Runnable接口，用于表示“卖票”过程：

    class SaleRunnable implements Runnable {

        private int ticket = 20;

        @Override
        public void run() {
            while(ticket > 0) {
                Log.d("Test", Thread.currentThread().getName() + "卖出了第" + (20-ticket+1) + "张票");
                ticket--;
            }
        }
    }

如上，一共有20张票，每卖出一张票，则打印卖出此票的线程名和票的序号。这个代码里没有加锁。

然后在主程序创建三个线程，传入同一个SaleRunnable对象，三个线程名分别为老王，老张，老李：

        SaleRunnable r = new SaleRunnable();
        Thread t1 = new Thread(r,"老王");
        Thread t2 = new Thread(r,"老张");
        Thread t3 = new Thread(r,"老李");

然后调用线程的start()方法启动三个线程：

        t1.start();
        t2.start();
        t3.start();

运行结果如下：

08-26 12:55:56.011 28300-28315/? D/Test: 老王卖出了第1张票
08-26 12:55:56.011 28300-28315/? D/Test: 老王卖出了第2张票
08-26 12:55:56.011 28300-28315/? D/Test: 老王卖出了第3张票
08-26 12:55:56.011 28300-28315/? D/Test: 老王卖出了第4张票
08-26 12:55:56.011 28300-28315/? D/Test: 老王卖出了第5张票
08-26 12:55:56.011 28300-28315/? D/Test: 老王卖出了第6张票
08-26 12:55:56.011 28300-28315/? D/Test: 老王卖出了第7张票
08-26 12:55:56.011 28300-28315/? D/Test: 老王卖出了第8张票
08-26 12:55:56.011 28300-28315/? D/Test: 老王卖出了第9张票
08-26 12:55:56.011 28300-28315/? D/Test: 老王卖出了第10张票
08-26 12:55:56.011 28300-28315/? D/Test: 老王卖出了第11张票
08-26 12:55:56.011 28300-28316/? D/Test: 老张卖出了第12张票
08-26 12:55:56.011 28300-28316/? D/Test: 老张卖出了第13张票
08-26 12:55:56.011 28300-28316/? D/Test: 老张卖出了第14张票
08-26 12:55:56.011 28300-28316/? D/Test: 老张卖出了第15张票
08-26 12:55:56.011 28300-28316/? D/Test: 老张卖出了第16张票
08-26 12:55:56.011 28300-28316/? D/Test: 老张卖出了第17张票
08-26 12:55:56.011 28300-28316/? D/Test: 老张卖出了第18张票
08-26 12:55:56.011 28300-28316/? D/Test: 老张卖出了第19张票
08-26 12:55:56.011 28300-28316/? D/Test: 老张卖出了第20张票
08-26 12:55:56.011 28300-28315/? D/Test: 老王卖出了第12张票

可见其结果是乱的，重复运行多次，结果不一，但是都没实现正常的卖票效果。为什么呢，因为三个线程在并行操作同一个对象，所以会出现老张的线程和老王的线程都卖出了第12张票的情况，但是这显然是不对的。

怎么办呢，修改下SaleRunnable类，加上锁试试：

    class SaleRunnable implements Runnable {

        private int ticket = 20;

        @Override
        public void run() {
            while(ticket > 0) {
                synchronized(this) {//把锁加在这里行不行呢？
                    Log.d("Test", Thread.currentThread().getName() + "卖出了第" + (20 - ticket + 1) + "张票");
                    ticket--;
                }
            }
        }
    }

如上面所示，把锁加在判断条件里面，运行结果：

08-26 13:15:08.621 15256-15271/？ D/Test: 老王卖出了第1张票
08-26 13:15:08.621 15256-15271/？ D/Test: 老王卖出了第2张票
08-26 13:15:08.621 15256-15271/？ D/Test: 老王卖出了第3张票
08-26 13:15:08.621 15256-15271/？ D/Test: 老王卖出了第4张票
08-26 13:15:08.621 15256-15271/？ D/Test: 老王卖出了第5张票
08-26 13:15:08.621 15256-15271/？ D/Test: 老王卖出了第6张票
08-26 13:15:08.621 15256-15271/？ D/Test: 老王卖出了第7张票
08-26 13:15:08.621 15256-15271/？ D/Test: 老王卖出了第8张票
08-26 13:15:08.621 15256-15271/？ D/Test: 老王卖出了第9张票
08-26 13:15:08.621 15256-15271/？ D/Test: 老王卖出了第10张票
08-26 13:15:08.621 15256-15271/？ D/Test: 老王卖出了第11张票
08-26 13:15:08.621 15256-15271/？ D/Test: 老王卖出了第12张票
08-26 13:15:08.621 15256-15271/？ D/Test: 老王卖出了第13张票
08-26 13:15:08.621 15256-15271/？ D/Test: 老王卖出了第14张票
08-26 13:15:08.621 15256-15271/？ D/Test: 老王卖出了第15张票
08-26 13:15:08.621 15256-15271/？ D/Test: 老王卖出了第16张票
08-26 13:15:08.621 15256-15271/？ D/Test: 老王卖出了第17张票
08-26 13:15:08.621 15256-15271/？ D/Test: 老王卖出了第18张票
08-26 13:15:08.621 15256-15271/？ D/Test: 老王卖出了第19张票
08-26 13:15:08.621 15256-15271/？ D/Test: 老王卖出了第20张票
08-26 13:15:08.631 15256-15273/？ D/Test: 老李卖出了第21张票
08-26 13:15:08.631 15256-15272/？ D/Test: 老张卖出了第22张票

结果看，虽然卖票顺序对了，但卖多了也是不正常的，再改下：

    class SaleRunnable implements Runnable {

        private int ticket = 20;

        @Override
        public void run() {
            synchronized(this){//把锁加在循环判断外面，行不行呢？
            while(ticket > 0) {
                Log.d("Test", Thread.currentThread().getName() + "卖出了第" + (20 - ticket + 1) + "张票");
                ticket--;
            }
            }
        }
    }

运行结果：

08-26 13:31:41.061 31687-31724/？ D/Test: 老王卖出了第1张票
08-26 13:31:41.061 31687-31724/？ D/Test: 老王卖出了第2张票
08-26 13:31:41.061 31687-31724/？ D/Test: 老王卖出了第3张票
08-26 13:31:41.061 31687-31724/？ D/Test: 老王卖出了第4张票
08-26 13:31:41.061 31687-31724/？ D/Test: 老王卖出了第5张票
08-26 13:31:41.061 31687-31724/？ D/Test: 老王卖出了第6张票
08-26 13:31:41.061 31687-31724/？ D/Test: 老王卖出了第7张票
08-26 13:31:41.061 31687-31724/？ D/Test: 老王卖出了第8张票
08-26 13:31:41.061 31687-31724/？ D/Test: 老王卖出了第9张票
08-26 13:31:41.061 31687-31724/？ D/Test: 老王卖出了第10张票
08-26 13:31:41.061 31687-31724/？ D/Test: 老王卖出了第11张票
08-26 13:31:41.061 31687-31724/？ D/Test: 老王卖出了第12张票
08-26 13:31:41.061 31687-31724/？ D/Test: 老王卖出了第13张票
08-26 13:31:41.061 31687-31724/？ D/Test: 老王卖出了第14张票
08-26 13:31:41.061 31687-31724/？ D/Test: 老王卖出了第15张票
08-26 13:31:41.061 31687-31724/？ D/Test: 老王卖出了第16张票
08-26 13:31:41.061 31687-31724/？ D/Test: 老王卖出了第17张票
08-26 13:31:41.061 31687-31724/？ D/Test: 老王卖出了第18张票
08-26 13:31:41.061 31687-31724/？ D/Test: 老王卖出了第19张票
08-26 13:31:41.061 31687-31724/？ D/Test: 老王卖出了第20张票

结果是没错，但是票全让老王给卖了，这也不正常，因为我们把锁加在整个卖票操作外面了，一旦老王开始卖票，其他人都没法卖了。再改：


    class SaleRunnable implements Runnable {

        private int ticket = 20;

        @Override
        public void run() {
            while(true) {//判断条件做了修改
                synchronized(this) {//锁加在循环判断里面，只有满足条件才能执行卖票操作
                    if (ticket > 0) {
                        Log.d("Test", Thread.currentThread().getName() + "卖出了第" + (20 - ticket + 1) + "张票");
                        ticket--;
                    } else {
                        break;
                    }
                }

                try {//这里的操作是为了方便线程间自动切换，如果不加的话，可能结果也是票全让老王线程给卖了
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

这样修改后结果正常了：

08-26 13:43:24.181 12176-12199/? D/Test: 老王卖出了第1张票
08-26 13:43:24.181 12176-12200/? D/Test: 老张卖出了第2张票
08-26 13:43:24.181 12176-12201/? D/Test: 老李卖出了第3张票
08-26 13:43:27.181 12176-12199/？D/Test: 老王卖出了第4张票
08-26 13:43:27.181 12176-12200/？D/Test: 老张卖出了第5张票
08-26 13:43:27.181 12176-12201/？D/Test: 老李卖出了第6张票
08-26 13:43:30.181 12176-12199/？D/Test: 老王卖出了第7张票
08-26 13:43:30.181 12176-12200/？D/Test: 老张卖出了第8张票
08-26 13:43:30.181 12176-12201/？D/Test: 老李卖出了第9张票
08-26 13:43:33.181 12176-12199/？D/Test: 老王卖出了第10张票
08-26 13:43:33.181 12176-12200/？D/Test: 老张卖出了第11张票
08-26 13:43:33.181 12176-12201/？D/Test: 老李卖出了第12张票
08-26 13:43:36.181 12176-12199/？D/Test: 老王卖出了第13张票
08-26 13:43:36.181 12176-12200/？D/Test: 老张卖出了第14张票
08-26 13:43:36.191 12176-12201/？D/Test: 老李卖出了第15张票
08-26 13:43:39.181 12176-12199/？D/Test: 老王卖出了第16张票
08-26 13:43:39.181 12176-12200/？D/Test: 老张卖出了第17张票
08-26 13:43:39.191 12176-12201/？D/Test: 老李卖出了第18张票
08-26 13:43:42.181 12176-12199/？D/Test: 老王卖出了第19张票
08-26 13:43:42.181 12176-12200/？D/Test: 老张卖出了第20张票

因此多个线程对同一个线程进行操作时，加锁是有效的解决冲突的方式，但是加到哪里一定要多多思考。

此去正年少
关注
专栏目录
C#多线程同步范例
09-06
总之，C#多线程同步范例提供了一个宝贵的学习平台，通过实际操作，初学者能够更好地掌握多线程同步的原理和实践。通过深入研究并运行示例代码，你将能够为你的编程技能增添重要的一环，从而编写出更健壮、高效的多...
20220522_多线程同步锁的用法
ClarkGable的博客
05-22 203
一.同步代码块锁 账户类代码 锁在此 public class Account { private String accID; private double balance; public Account() { } public Account(String accID, double balance) { this.accID = accID; this.balance = balance; } public
多线程--线程同步锁Lock锁
qq_31142237的博客
03-11 1468
多线程–线程同步锁–Lock锁-ReentrantLock 之前说了线程同步机制Synchronize锁，其实除此之外还有一种JUC的Lock锁也能实现线程同步。而且Lock实现类ReentrantLock相比Synchronize有更大的灵活性，更加丰富，更是适合大多场景的使用。 先来简单的对比下ReentrantLock和Synchronize吧。 Synchronsize锁是独占锁，加锁和释放锁都是自动的，只要加上关键字synchronize或者代码块就行。使用起来很简单，但是呢灵活性较差。Ree
【多线程】常见锁策略，CAS和synchronized
最新发布
daweidi的博客
07-29 1084
假设在大多数情况下并发操作不会发生冲突，因此允许多个线程同时进行操作，只有在真正更新数据时才进行冲突检测。：假设并发操作会发生冲突，因此在读取和修改数据时会进行加锁操作，保证同一时间只有一个线程能够操作数据。，可以提高并发性能，但可能会导致重复操作或数据丢失的问题。，能够确保数据的一致性，但并发性能相对较低。
多线程--synchronized同步锁用法及作用范围
qq_41799291的博客
01-23 1085
Java 中的 synchronized 关键字可以在多线程环境下用来作为线程安全的同步锁。 synchronized 关键字主要有以下几种用法： 非静态方法的同步； 静态方法的同步； 代码块。 下面分对象锁和类锁来分别说明 synchronized 用法： 1.对象锁 对象锁在一个类中可以有很多个 案例1：两个线程同时访问一个对象里的用synchronized关键字修饰的方 法 packa...
java 多线程之线程同步锁
chennengqing的专栏
07-17 162
我们在开发过程中， 为了提高效率往往都会采用多线程，但是多个线程同时运行的时候可能调用线程函数，在多个线程对同一个内存地址进行修改的时候， 写入数据会被多次的覆盖， 所以就要使用线程同步， 同步就是协同步调， 按照先后顺序进行运行。 那么在 java 中， 我们一般使用同步锁一般采用synchronized实现， 也可以通过Lock实现 package com...
多线程开发--同步锁
冰点契约的博客
06-29 223
同步锁 同步就是协同步调，按预定的先后次序进行运行。如:你说完，我再说。"同"字从字面上容易理解为一起动作，其实不是，"同"字应是指协同、协助、互相配合。 如进程、线程同步，可理解为进程或线程A和B一块配合，A执行到一定程度时要依靠B的某个结果，于是停下来，示意B运行;B依言执行，再将结果给A;A再继续操作。这既是同步 python对线程加锁主要有Lock和Rlock模块 注意： 加锁还可以使用with 效果一样 必须使用同一把锁 如果使用锁，程序会变成串行，因此应该是在适当的地方加锁 线程调度本质上是不
c#多线程编程范例
01-16
本资源"**c#多线程编程范例**"提供了全面的C#多线程开发示例，旨在帮助开发者深入理解和掌握多线程的代码编写方法。 ### 一、多线程基础 1. **线程定义**：线程是操作系统分配CPU时间的基本单元，一个进程可以有多...
POSIX规范多线程代码示例
06-05
在这个名为"POSIX规范多线程代码示例"的压缩包中，你将找到六个使用C++的POSIX线程库（pthread）编写的示例，它们逐步展示了如何在Linux和Windows环境下（使用Visual Studio，需添加-lpthread链接选项）创建和管理多...
c#多线程之生产者消费者
09-01
1. **Monitor**：C#中的Monitor类提供了基于对象锁的线程同步，使用`Monitor.Enter`和`Monitor.Exit`方法获取和释放锁。生产者在向队列添加元素时会获取锁，完成后再释放；消费者在取元素时同样需要获取锁，确保同一...
多线程编程范例
10-07
本篇文章将深入探讨多线程编程范例在MFC中的实现与应用。 首先，我们要理解什么是多线程。在单线程程序中，所有任务都按顺序执行，而多线程允许同时执行多个任务，提高了系统资源利用率和程序的并发性。在MFC中，多...
多线程8锁案例演示
KEELON的博客
08-31 311
比如代码中A线程持有A锁，希望获得B锁，B锁又被B线程持有，B锁又希望或者A，他们都获得不得想要的锁，只能等待了。非公平锁是，是指的多个线程获取锁的顺序并不是按照申请锁的顺序，有个后申请锁的顺序的线程优先或许锁。在方法上加的锁，都是对象锁，一旦一个线程进入某个被锁的方法，其他线程也不能进入其他枷锁的方法。公平锁 是指多个线程按照申请锁的顺序来获取锁。可冲入锁，又名递归锁。wait进入等待是时候，释放所持有的锁，等待其他线程notify唤醒。类锁锁的事整个类，即该类new出来的其他对象都是持有相同的锁。...
多线程 & 线程经典案例 &锁 详细笔记
GangsterChen & Codes
02-11 221
1 多线程概念 2 经典案例--售票 3 锁的应用
Java笔记-多线程中同步加锁相关
IT1995的博客
12-30 5234
Java程序入口就是由JVM启动的main线程： main线程又可以启动其他线程。当所有线程都运行结束时JVM退出，进程结束。 守护线程（Daemon）：守护线程是为其他线程服务的线程，所有的非守护线程都执行完毕后，虚拟机才会退出。 守护线程的特点：不能持有资源（如打开文件等） 创建守护线程： setDaemon(true); 下面来演示下，子线程中有死循环，而主线程退出...
Java多线程同步(锁)的实现方法(synchronised 与reentrantlock)
西湖有大葱的专栏
11-04 3530
synchronised synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：  1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；  2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；  3. 修改一个静态的方法，其作用的范
Java多线程——线程同步与锁（基于狂神说的学习笔记）
whale_cat的博客
10-10 155
处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改对象。这个时候我们就需要线程同步。线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个形成队列，等待前面的线程使用完毕，下一个线程再使用。
多线程中的锁
qq_66292058的博客
03-13 1569
在了解什么是锁之前，我们先来看一下这样一段代码//创建变量i//我们创建两个线程,分别让i自增10000次j < 10000;j++) {i++;});j < 10000;j++) {i++;});t1.start();t2.start();try {//等待两个线程执行完成t2.join();t1.join();//打印i的值按照正常的逻辑，两个线程都让i自增了10000次，i最终的结果应该是20000才对，但事实真是如此吗？我们来看一下代码的运行结果。
多线程同步锁synchronized(对象锁与全局锁)总结
qq_40409115的博客
05-05 9086
1.synchronized同步锁的引入/* * 非线程安全 * */ //多个线程共同访问一个对象中的实例变量，则会出现"非线程安全"问题 class MyRunnable1 implements Runnable{ private int num = 10; public void run() { try { if(num &gt; 0) { System.out.p...
synchronized
kaka
07-30 277
在上篇多线程安全的文章中，我曾推荐过大家使用@synchronized来使得代码获得原子性，从而保证多线程安全。这篇文章向大家介绍一些@synchronized的知识点和应该避免的坑。 @synchronized原理 @synchronized是几种iOS多线程同步机制中最慢的一个，同时也是最方便的一个。 苹果建立@synchronized的初衷就是方便开发者快速的实现代码同步，
C#编程：Timer与多线程实战指南
同时，通过Mutex、Monitor、锁和事件等同步机制，确保了多线程环境下的数据安全。 文档中还特别提到了断点续传和多线程上传，这是文件传输领域的一个重要功能。断点续传允许用户在上传或下载过程中中断后从上次停止...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值