多线程同步问题,锁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 {        List
list = 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【反射中讲解】
  • 同步监视器的执行过程

    1. 第一个线程访问,锁定同步监视器,执行其中代码
    2. 第二个线程访问,发现同步监视器被锁定,无法访问
    3. 第一个线程访问完毕,解锁同步监视器
    4. 第二个线程访问,发现同步监视器没有锁,然后锁定并访问
  • 使用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 {        List
list = 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) {        CopyOnWriteArrayList
list = 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+"获得口红的锁");            }        }    }}
  • 死锁避免方法
    • 产生死锁的四个必备条件:
      1. 互斥条件:一个资源每次只能被一个进程使用。
      2. 请求与保持条件:一个进程因请求资源而阻塞时,对已获得的资源保持不放。
      3. 不剥夺条件:进程已获得的资源,在未使用完之前,不能强行剥夺。
      4. 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。
    • 只要破坏其中任意一个或多个条件就可以避免死锁发生

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 如侵犯您的版权,请留言回复原文章的地址,我们会给您删除此文章,给您带来不便请您谅解!

上一篇:多线程和cpu得关系
下一篇:多线程同步的方法

发表评论

最新留言

做的很好,不错不错
[***.243.131.199]2024年03月13日 14时13分01秒

关于作者

    喝酒易醉,品茶养心,人生如梦,品茶悟道,何以解忧?唯有杜康!
-- 愿君每日到此一游!

推荐文章

mysql查询当天记录_sql查询当天记录 2019-04-21
java 远程调试 端口_JAVA远程调试 2019-04-21
java 获取 html 图片路径_JAVA-替换html中图片的路径-从html代码中提取图片路径并下载(完整版)... 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
wget linux java 32_通过wget在Linux上下载Java JDK会显示在许可证页面上 2019-04-21
babylonjs 设置面板位置_babylonjs 空间坐标转为屏幕坐标 2019-04-21
oracle里面如何查询sqlid,CSS_oracle中如何查看sql, --查询表状态:  select uo.O - phpStudy... 2019-04-21
oracle 查询中用case,oracle case when 在查询时候的用法。 2019-04-21
oracle正在运行的程序包,ORACLE PL/SQL编程详解之程序包的创建与应用 2019-04-21
php局部页面滚动,在访问另一页面后保留浏览器滚动位置 - php 2019-04-21
jmeter运行linux命令行,Jmeter在linux上运行(命令行运行Jmeter) 2019-04-21