4 Java 线程同步 详解

于 2022-12-15 17:30:14 发布
阅读量63 收藏
点赞数
分类专栏： 多线程与JUC 文章标签： java 开发语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/miudashu/article/details/128332932
版权

介绍

多个线程操作同一个资源
并发：同一个对象被多个线程同时操作

线程使用的总结：1. 先把业务逻辑拆成方法 2. 在run方法中配合synchronized去调用方法

线程同步

  1. 现实生活中，我们会遇到“同一个资源，多个人都想使用”的问题，比如，食堂排队打饭，每个人都想吃饭，最天然的解决办法就是，排队，一个个来
  2. 处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，这时候我们就需要线程同步。线程同步其实就是一种等待，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。

队列和锁

由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可，存在以下问题：

  • 一个线程持有锁会导致其他所有需要此锁的线程挂起
  • 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题
  • 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题。

不安全的线程案例

买票案例：

import java.security.PrivateKey;

public class Demo24_UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();
        new Thread(buyTicket, "张三").start();
        new Thread(buyTicket, "李四").start();
        new Thread(buyTicket, "王五").start();
    }
}

class BuyTicket implements Runnable {
    //票
    private int ticketNums = 10;
    boolean flag = true;

    @Override
    public void run() {
        while (flag) {
            try {
                buy();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }


    }

    private  void buy() throws InterruptedException {
        //判断是否有票
        if (ticketNums <= 0) {
            flag = false;
            return;
        }

        //延迟
        Thread.sleep(1);

        //买票
        System.out.println(Thread.currentThread().getName() + "拿到第" + ticketNums-- + "张票!");
    }
}

取款案例

import java.lang.reflect.AccessibleObject;

public class Demo25_UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(100, "结婚基金");
        Drawing you = new Drawing(account, 50, "展堂");
        Drawing girlFrient = new Drawing(account, 100, "sad");
        you.start();
        girlFrient.start();
    }

}

class Account{
    int money;//余额
    String cardName;//卡名

    public Account(int money, String cardName) {//有参构造
        this.money = money;
        this.cardName = cardName;
    }
}

class Drawing extends Thread{//模拟银行取款线程
    Account account;//账户
    int drawingMoney;//取款金额
    int nowMoney;//你手里的钱

    public Drawing(Account account, int money, String name) {
        super(name);
        this.account = account;
        this.drawingMoney = money;
    }

    @Override
    public void run() {
        //判断是否有钱
        if (account.money - drawingMoney < 0) {
            System.out.println("余额不足,不能取款");
            return;
        }
        try {
            Thread.sleep(1000);//放大问题发生性
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //卡内金额 = 余额-取的金额
        account.money -= drawingMoney;
        //手里的钱
        nowMoney += drawingMoney;
        System.out.println("余额为:" + account.money);
        System.out.println(this.getName() + "手里的钱:" + nowMoney);

    }
}

输出：
余额为:0
余额为:0
sad手里的钱:100
展堂手里的钱:50

线程不安全的集合：

public class Demo26_UnsafeList {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        for (int i = 0; i < 1000; i++) {
            new Thread(() -> {
                list.add(Thread.currentThread().getName());
            }).start();
        }
        System.out.println(list.size());
    }
}
//可能是线程里面的顺序不一致了

同步方法

  1. 由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法：synchronized方法和synchronized块。
  2. synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行

    缺陷：若将一个大的方法申明为synchronized将会影响效率
    方法里面有需要修改的内容才需要锁，锁的太多，浪费资源
    同步方法：锁的是this

import java.security.PrivateKey;

public class Demo24_UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();
        new Thread(buyTicket, "张三").start();
        new Thread(buyTicket, "李四").start();
        new Thread(buyTicket, "王五").start();
    }
}

class BuyTicket implements Runnable {
    //票
    private int ticketNums = 10;
    boolean flag = true;

    @Override
    public void run() {
        while (flag) {
            try {
                buy();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }


    }

    //synchronized同步方法,锁的是this
    private  synchronized void buy() throws InterruptedException {
        //判断是否有票
        if (ticketNums <= 0) {
            flag = false;
            return;
        }

        //延迟
        Thread.sleep(1);

        //买票
        System.out.println(Thread.currentThread().getName() + "拿到第" + ticketNums-- + "张票!");
    }
}

同步块

  1. 同步块：synchronized(obj){}
  2. Obj称之为同步监视器
    • Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
    • 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this这个对象，或者是class
  3. 同步监视器的执行过程
    • 第一个线程访问，锁定同步监视器，执行其中代码
    • 第二个线程访问，发现同步监视器被锁定，无法访问
    • 第一个线程访问完毕，解锁同步监视器
    • 第二个线程访问，发现同步监视器没有锁，然后锁定并访问

锁的对象就是变量的量,需要增删改查的对象
代码清单：

public class Demo25_UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(100, "结婚基金");
        Drawing you = new Drawing(account, 50, "展堂");
        Drawing girlFrient = new Drawing(account, 100, "sad");
        you.start();
        girlFrient.start();
    }

}

class Account{
    int money;//余额
    String cardName;//卡名

    public Account(int money, String cardName) {//有参构造
        this.money = money;
        this.cardName = cardName;
    }
}

class Drawing extends Thread{//模拟银行取款线程
    Account account;//账户
    int drawingMoney;//取款金额
    int nowMoney;//你手里的钱

    public Drawing(Account account, int money, String name) {
        super(name);
        this.account = account;
        this.drawingMoney = money;
    }

    @Override
    public void run() {
        //锁的对象就是变量的量,需要增删改查的对象
        synchronized (account) {
            //判断是否有钱
            if (account.money - drawingMoney < 0) {
                System.out.println("余额不足,不能取款");
                return;
            }
            try {
                Thread.sleep(1000);//放大问题发生性
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            //卡内金额 = 余额-取的金额
            account.money -= drawingMoney;
            //手里的钱
            nowMoney += drawingMoney;
            System.out.println("余额为:" + account.money);
            System.out.println(this.getName() + "手里的钱:" + nowMoney);
        }

    }
}
crayon_ycj
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值