多线程同步问题,锁Lock,synchronized
发布日期:2022-04-11 08:53:01
浏览次数:1
分类:博客文章
本文共 12489 字,大约阅读时间需要 41 分钟。
线程同步机制
并发:同一个对象被多个线程同时操作
处理多线程问题时,多个线程访问同一个对象,并且某些线程还想修改这个对象。这时候我们就需要线程同步。线程同步其实就是一种等待机制,多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面线程使用完毕,下一个县城再使用
线程同步形成条件:队列+锁
由于同一进程的多个线程共享同一块存储空间,在带来方便的同时,也带来了访问冲突问题,为了保证数据在方法中被访问时的正确性,在访问时加入锁机制synchronized,当一个线程获得对象的排他锁,独占资源,其他线程必须等待,使用后释放锁即可。存在以下问题:
- 一个线程持有锁会导致其他所有需要此锁的线程挂起;
- 在多线程竞争下,加锁,释放锁会导致比较多的上下文切换和调度延时,引起性能问题;
- 如果一个优先级高的线程等待一个优先级低的线程释放锁,会导致优先级倒置,引起性能问题。
三个多线程不安全案例
//不安全的买票//线程不安全,有负数public class UnsafeBuyTicket { public static void main(String[] args) { BuyTicket station = new BuyTicket(); new Thread(station,"苦逼的我").start(); new Thread(station,"牛逼的你们").start(); new Thread(station,"可恶的黄牛党").start(); }}class BuyTicket implements Runnable{ //票 private int ticketNums = 10; boolean flag = true;//外部停止方式 @Override public void run() { //买票 while (flag){ try { buy(); } catch (InterruptedException e) { e.printStackTrace(); } } } private void buy() throws InterruptedException { //判断是否有票 if (ticketNums<=0){ flag = false; return; } //模拟延时 Thread.sleep(100); //买票 System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--); }}================================================================================//不安全的取钱//两个人去银行取钱,账户public class UnsafeBank { public static void main(String[] args) { //账户 Account account = new Account(100,"结婚基金"); Drawing you = new Drawing(account,50,"你"); Drawing girlFriend = new Drawing(account,100,"girlFriend"); you.start(); girlFriend.start(); }}//账户class Account{ int money;//余额 String name;//卡名 public Account(int money, String name){ this.money = money; this.name = name; }}//银行:模拟取款class Drawing extends Thread{ Account account;//账户 //取了多少钱 int drawingMoney; //现在手里有多少钱 int nowMoney; public Drawing(Account account,int drawingMoney,String name){ super(name); this.account = account; this.drawingMoney = drawingMoney; } //取钱 @Override public void run() { //判断有没有钱 if (account.money-drawingMoney<0){ System.out.println(Thread.currentThread().getName()+"钱不够,取不了"); return; } //sleep可以放大问题的发生性 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } //卡内余额 = 余额 - 你取的钱 account.money = account.money - drawingMoney; //你手里的钱 nowMoney = nowMoney + drawingMoney; System.out.println(account.name+"余额为:"+account.money); //Thread.currentThread().getName() = this.getName() System.out.println(this.getName()+"手里的钱"+nowMoney); }}=================================================================================import java.util.ArrayList;import java.util.List;//线程不安全的集合//不同线程同时向集合中添加元素时,有些元素可能被覆盖public class UnsafeList { public static void main(String[] args) throws InterruptedException { Listlist = new ArrayList (); for (int i = 0; i < 10000; i++) { new Thread(()->{ list.add(Thread.currentThread().getName()); }).start(); } Thread.sleep(3000); System.out.println(list.size()); }}
多线程同步的方法
- 由于我们可以通过private关键字来保证数据对象只能被方法访问,所以我们只需要针对方法提出一套机制,这套机制就是synchronized关键字,它包括两种用法:synchronized方法和synchronized块。
//同步方法:public synchronized void method(int args){}
- synchronized方法控制对“对象”的访问,每个对象对应一把锁,每个synchronized方法都必须获得调用该方法的对象的锁才能执行,否则线程会阻塞,方法一旦执行,就独占该锁,直到该方法返回才释放锁,后面被阻塞的线程才能获得这个锁,继续执行
//缺陷:若将一个大的方法声明为synchronized将会影响效率
- 方法里面需要修改的内容才需要锁,锁的太多,浪费资源(只读代码部分可不锁,只锁需要修改的代码部分)
同步块
同步块:synchronized(Obj){}
Obj称之为同步监视器
- Obj可以是任何对象,但是推荐使用共享资源作为同步监视器
- 同步方法中无需指定同步监视器,因为同步方法的同步监视器就是this,就是这个对象本身,或者是class【反射中讲解】
同步监视器的执行过程
- 第一个线程访问,锁定同步监视器,执行其中代码
- 第二个线程访问,发现同步监视器被锁定,无法访问
- 第一个线程访问完毕,解锁同步监视器
- 第二个线程访问,发现同步监视器没有锁,然后锁定并访问
使用synchronized修改三大案例
//不安全的买票//线程不安全,有负数public class UnsafeBuyTicket { public static void main(String[] args) { BuyTicket station = new BuyTicket(); new Thread(station,"苦逼的我").start(); new Thread(station,"牛逼的你们").start(); new Thread(station,"可恶的黄牛党").start(); }}class BuyTicket implements Runnable{ //票 private int ticketNums = 10; boolean flag = true;//外部停止方式 @Override public void run() { //买票 while (flag){ try { buy(); } catch (InterruptedException e) { e.printStackTrace(); } } } //synchronized 同步方法,锁的是this private synchronized void buy() throws InterruptedException { //判断是否有票 if (ticketNums<=0){ flag = false; return; } //模拟延时 Thread.sleep(100); //买票 System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--); }}==================================================================================//不安全的取钱//两个人去银行取钱,账户public class UnsafeBank { public static void main(String[] args) { //账户 Account account = new Account(100,"结婚基金"); Drawing you = new Drawing(account,50,"你"); Drawing girlFriend = new Drawing(account,100,"girlFriend"); you.start(); girlFriend.start(); }}//账户class Account{ int money;//余额 String name;//卡名 public Account(int money, String name){ this.money = money; this.name = name; }}//银行:模拟取款class Drawing extends Thread{ Account account;//账户 //取了多少钱 int drawingMoney; //现在手里有多少钱 int nowMoney; public Drawing(Account account,int drawingMoney,String name){ super(name); this.account = account; this.drawingMoney = drawingMoney; } //取钱 //synchronized 默认锁的是this @Override public void run() { //锁的对象就是变化的量,需要增删改的对象 synchronized (account){ //判断有没有钱 if (account.money-drawingMoney<0){ System.out.println(Thread.currentThread().getName()+"钱不够,取不了"); return; } //sleep可以放大问题的发生性 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } //卡内余额 = 余额 - 你取的钱 account.money = account.money - drawingMoney; //你手里的钱 nowMoney = nowMoney + drawingMoney; System.out.println(account.name+"余额为:"+account.money); //Thread.currentThread().getName() = this.getName() System.out.println(this.getName()+"手里的钱"+nowMoney); } }}=======================================================================================import java.util.ArrayList;import java.util.List;//线程不安全的集合//不同线程同时向集合中添加元素时,有些元素可能被覆盖public class UnsafeList { public static void main(String[] args) throws InterruptedException { Listlist = new ArrayList (); for (int i = 0; i < 10000; i++) { new Thread(()->{ synchronized (list){ list.add(Thread.currentThread().getName()); } }).start(); } Thread.sleep(3000); System.out.println(list.size()); }}
CopyOnWriteArrayList(java.util.concurrent(JUC)包下的安全类型的集合)
import java.util.concurrent.CopyOnWriteArrayList;//测试JUC安全类型的集合public class TestJUC { public static void main(String[] args) { CopyOnWriteArrayListlist = new CopyOnWriteArrayList (); for (int i = 0; i < 10000; i++) { new Thread(()->{ list.add(Thread.currentThread().getName()); }).start(); } try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(list.size()); }}
死锁
- 多个线程各自占有一些共享资源,并且互相等待其他线程占有的资源才能运行,而导致两个或多个线程都在等待对方释放资源,都停止执行的情形。某一个同步块同时拥有“两个以上对象的锁”时,就可能会发生“死锁”的问题。
//死锁:多个线程互相抱着对方需要的资源,然后形成僵持public class DeadLock { public static void main(String[] args) { Makeup g1 = new Makeup(0,"灰姑凉"); Makeup g2 = new Makeup(1,"白雪公主"); g1.start(); g2.start(); }}//口红class Lipstick{}//镜子class Mirror{}class Makeup extends Thread{ //需要的资源只有一份,用static来保证只有一份 static Lipstick lipstick = new Lipstick(); static Mirror mirror = new Mirror(); int choice;//选择 String girlName;//使用化妆品的人 Makeup(int choice, String girlName){ this.choice = choice; this.girlName = girlName; } @Override public void run() { //化妆 try { makeup(); } catch (InterruptedException e) { e.printStackTrace(); } } //化妆,互相持有对方的锁,就是需要拿到对方的资源 private void makeup() throws InterruptedException { if (choice==0){ synchronized (lipstick){//获得口红的锁 System.out.println(this.girlName+"获得口红的锁"); Thread.sleep(1000); synchronized (mirror){//一秒钟后想获得镜子 System.out.println(this.girlName+"获得镜子的锁"); } } }else { synchronized (mirror){//获得镜子的锁 System.out.println(this.girlName+"获得镜子的锁"); Thread.sleep(2000); synchronized (lipstick){//一秒钟后想获得口红的锁 System.out.println(this.girlName+"获得口红的锁"); } } } }}============================================================================//解决方法://死锁:多个线程互相抱着对方需要的资源,然后形成僵持public class DeadLock { public static void main(String[] args) { Makeup g1 = new Makeup(0,"灰姑凉"); Makeup g2 = new Makeup(1,"白雪公主"); g1.start(); g2.start(); }}//口红class Lipstick{}//镜子class Mirror{}class Makeup extends Thread{ //需要的资源只有一份,用static来保证只有一份 static Lipstick lipstick = new Lipstick(); static Mirror mirror = new Mirror(); int choice;//选择 String girlName;//使用化妆品的人 Makeup(int choice, String girlName){ this.choice = choice; this.girlName = girlName; } @Override public void run() { //化妆 try { makeup(); } catch (InterruptedException e) { e.printStackTrace(); } } //化妆,互相持有对方的锁,就是需要拿到对方的资源 private void makeup() throws InterruptedException { if (choice==0){ synchronized (lipstick){//获得口红的锁 System.out.println(this.girlName+"获得口红的锁"); Thread.sleep(1000); } synchronized (mirror){//一秒钟后想获得镜子 System.out.println(this.girlName+"获得镜子的锁"); } }else { synchronized (mirror){//获得镜子的锁 System.out.println(this.girlName+"获得镜子的锁"); Thread.sleep(2000); } synchronized (lipstick){//一秒钟后想获得口红的锁 System.out.println(this.girlName+"获得口红的锁"); } } }}
- 死锁避免方法
- 产生死锁的四个必备条件:
- 互斥条件:一个资源每次只能被一个进程使用。
- 请求与保持条件:一个进程因请求资源而阻塞时,对已获得的资源保持不放。
- 不剥夺条件:进程已获得的资源,在未使用完之前,不能强行剥夺。
- 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。
- 只要破坏其中任意一个或多个条件就可以避免死锁发生
- 产生死锁的四个必备条件:
Lock(锁)
- 从JDK5.0开始,Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当
- java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问,每次只能有一个线程对Lock对象加锁,线程开始访问共享资源之前应先获得Lock对象
- ReentrantLock类(可重入锁)实现了Lock,它拥有与synchronized相同的并发行和内存语义,在实现线程安全的控制中,比较常用的是ReentrantLock,可以显式加锁、释放锁。
import java.util.concurrent.locks.ReentrantLock;//测试Lock锁public class TestLock { public static void main(String[] args) { TestLock2 testLock2 = new TestLock2(); new Thread(testLock2).start(); new Thread(testLock2).start(); new Thread(testLock2).start(); }}class TestLock2 implements Runnable{ int ticketName = 10; //定义lock锁 private final ReentrantLock lock = new ReentrantLock(); @Override public void run() { while (true){ try { lock.lock();//加锁 if (ticketName>0){ try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(ticketName--); }else { break; } }finally { //解锁 lock.unlock(); } } }}
synchronized与Lock的对比
- Lock是显式锁(手动开启和关闭锁,别忘记关闭锁)synchronized是隐式锁,出了作用域自动释放
- Lock只有代码块锁,synchronized有代码块锁和方法锁
- 使用Lock锁,JVM将花费较少的时间来调度线程,性能更好。并且具有更好的扩展性(提供更多的子类)
- 优先使用顺序
- Lock > 同步代码块(已经进入了方法体,分配了相应资源) > 同步方法(在方法体之外)
转载地址:https://www.cnblogs.com/wydilearn/p/15689610.html 如侵犯您的版权,请留言回复原文章的地址,我们会给您删除此文章,给您带来不便请您谅解!
发表评论
最新留言
做的很好,不错不错
[***.243.131.199]2024年03月13日 14时13分01秒
关于作者
喝酒易醉,品茶养心,人生如梦,品茶悟道,何以解忧?唯有杜康!
-- 愿君每日到此一游!
推荐文章
mysql查询当天记录_sql查询当天记录
2019-04-21
java 远程调试 端口_JAVA远程调试
2019-04-21
java redis 面试题_Java面试题(Redis篇)
2019-04-21
java 正则表达式分类功能_JAVA正则表达式4种常用功能
2019-04-21
java3d立方体_3d立方体贴图
2019-04-21
java ajax教程_(转)JAVA AJAX教程第三章—AJAX详细讲解
2019-04-21
java operators_A guide to Java Operators
2019-04-21
java socket调试_JAVA实现SOCKET多客户端通信的案例
2019-04-21
java 使用或覆盖了已过时的api_JAVA使用或覆盖了已过时的 API
2019-04-21
java 图片旋转保存_Java 对图片90度旋转
2019-04-21
用java实现文学研究助手_数据结构文学研究助手 C语言代码实现(带源码+解析)...
2019-04-21
java gc的几种方式_GC 的三种基本实现方式
2019-04-21
babylonjs 设置面板位置_babylonjs 空间坐标转为屏幕坐标
2019-04-21
oracle 查询中用case,oracle case when 在查询时候的用法。
2019-04-21
oracle正在运行的程序包,ORACLE PL/SQL编程详解之程序包的创建与应用
2019-04-21
php局部页面滚动,在访问另一页面后保留浏览器滚动位置 - php
2019-04-21