多线程同步锁的使用范例

最新推荐文章于 2024-09-18 11:40:41 发布
最新推荐文章于 2024-09-18 11:40:41 发布
阅读量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张票

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

此去正年少
关注
专栏目录
java 多线程操作map_Java 多线程中ConcurrentHashMap并发读写操作范例
weixin_35029295的博客
02-13 1562
范例1：package com.contoso;import java.util.Random;import java.util.UUID;import java.util.concurrent.ConcurrentHashMap;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;pu...
同步控制和锁，ReenterLock和Condition的详细使用
qq_43206800的博客
12-29 1169
文章目录多线程团队合作：同步控制和锁1 synchronized的功能扩展: 重入锁1.1 中断响应1.2 锁申请等待限时1.3 公平锁2 重入锁的好搭档：Condition3 允许多个线程同时访问：信号量(Semaphore)4 ReadWriteLock 读写锁5 倒计数器：CoundownLatch6 线程阻塞工具类：LockSupport 多线程团队合作：同步控制和锁 同步控制是并发程序必不可少的重要手段。synchronized关键字就是一种最简单的控制方法。同时，wait()和notify()
多线程的同步与锁
07-20
为了避免多个线程同时读写一个数据而产生不可预料的后果，我们需要将各个线程 对同一个数据的访问做同步。所谓同步，是指在一个线程访问数据未结束的时候， 其他线程不得对同一个数据进行访问。如此，对数据的访问被原子化了
多线程实例 同步锁
weixin_34150830的博客
06-16 103
多线程实例 ：lp.c #include <pthread.h>#include <stdio.h>#include <sys/time.h>#include <string.h>#define MAX 10pthread_t thread[2];pthread_mutex_t mut;int number=0, i;void *thread1...
【多线程】常见的锁策略
最新发布
acm_pn的博客
09-18 1277
多线程之间，数据的读取⽅之间不会产⽣线程安全问题，但数据的写⼊⽅互相之间以及和读者之间都需要进⾏互斥。如果两种场景下都⽤同⼀个锁，就会产⽣极⼤的性能损耗。所以读写锁因此⽽产⽣。 读写锁（readers-writer lock），看英⽂可以顾名思义，在执⾏加锁操作时需要额外表明读写意图，重复读者之间并不互斥，⽽写者则要求与任何⼈互斥。 ⼀个线程对于数据的访问，主要存在两种操作：读数据 和 写数据.
同步锁实例
weixin_30922589的博客
06-14 114
此列统计三种同步锁并发访问时消耗的时间 public interface Counter { public long getValue(); public void increment(); } /** * 内部锁 */ public class SynchronizedBenchmarkDemo implements Counter { ...
线程锁例子
Java技术
06-26 460
Thread1类 package com.maipiao2; public class Thread1 extends Thread { static int target = 0; public static Object obj;//必须加static，否则每个线程都会产生一个obj，这样加锁就没有意义了 @Override public void run() { // TOD...
多线程 & 线程经典案例 &锁 详细笔记
GangsterChen & Codes
02-11 230
1 多线程概念 2 经典案例--售票 3 锁的应用
C#多线程同步范例
09-06
总之，C#多线程同步范例提供了一个宝贵的学习平台，通过实际操作，初学者能够更好地掌握多线程同步的原理和实践。通过深入研究并运行示例代码，你将能够为你的编程技能增添重要的一环，从而编写出更健壮、高效的多...
c#多线程编程范例
01-16
本资源"**c#多线程编程范例**"提供了全面的C#多线程开发示例，旨在帮助开发者深入理解和掌握多线程的代码编写方法。 ### 一、多线程基础 1. **线程定义**：线程是操作系统分配CPU时间的基本单元，一个进程可以有多...
多线程编程范例
10-07
本篇文章将深入探讨多线程编程范例在MFC中的实现与应用。 首先，我们要理解什么是多线程。在单线程程序中，所有任务都按顺序执行，而多线程允许同时执行多个任务，提高了系统资源利用率和程序的并发性。在MFC中，多...
Java 同步锁(synchronized)详解及实例
08-30
主要介绍了Java 同步锁(synchronized)详解及实例的相关资料,需要的朋友可以参考下
线程同步锁
弥生的博客
02-22 268
package Thread; public class Test2 { public static void main(String[] args) { //定义账户对象 Acount a = new Acount(); //多线程对象 User u_weixin = new User(a,2000); User u_zhifubao = new User(a,2000); Thread weixin = new Thread(u_weixin,"微信 "); Th
线程锁实例2---读写加锁实例
weixin_34019929的博客
07-10 127
#include <stdio.h> #include <pthread.h> #include <unistd.h> struct student { int a ; int b ; int c ; int d ; int e ; int f ; }; char stu[6] = {10,10...
多线程中的锁系统(一)-基础用法
weixin_34367257的博客
12-21 128
     平常在多线程开发中，总避免不了线程同步。本篇对net多线程中的锁系统做个简单描述。 阅读目录： lock、Monitor 作用域范围 字符串锁 Monitor的用法 Mutex Semaphore 总结 lock、Monitor Lock是Monitor语法糖简化写法，Lock在IL会生成Monitor。 //======Example 1...
多线程8锁案例演示
KEELON的博客
08-31 320
比如代码中A线程持有A锁，希望获得B锁，B锁又被B线程持有，B锁又希望或者A，他们都获得不得想要的锁，只能等待了。非公平锁是，是指的多个线程获取锁的顺序并不是按照申请锁的顺序，有个后申请锁的顺序的线程优先或许锁。在方法上加的锁，都是对象锁，一旦一个线程进入某个被锁的方法，其他线程也不能进入其他枷锁的方法。公平锁 是指多个线程按照申请锁的顺序来获取锁。可冲入锁，又名递归锁。wait进入等待是时候，释放所持有的锁，等待其他线程notify唤醒。类锁锁的事整个类，即该类new出来的其他对象都是持有相同的锁。...
多线程中的锁
qq_36419801的博客
06-22 1823
多线程锁总结
多线程的锁
CoderLai的博客
07-14 675
多线程的锁
C#编程：Timer与多线程实战指南
同时，通过Mutex、Monitor、锁和事件等同步机制，确保了多线程环境下的数据安全。 文档中还特别提到了断点续传和多线程上传，这是文件传输领域的一个重要功能。断点续传允许用户在上传或下载过程中中断后从上次停止...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值