多线程入门03 —— 浅谈线程同步问题
发布日期:2022-04-11 08:52:52 浏览次数:1 分类:博客文章

本文共 4267 字,大约阅读时间需要 14 分钟。

线程同步问题

  • 并发:同一个对象被多个线程同时操作

  • 处理多线程问题时,常会遇到多个线程访问同一个对象的情况,并且其中的某些线程还需要对这个对象进行修改。这时就需要线程同步,以避免数据出错。

1.没有线程同步的例子

  • 代码

    package com.pbx.lesson02;/** * 模拟两个人同时从一个银行账户中取钱 * * @author BruceXu * @date 2020/9/13 */public class ThreadNotSync {
    public static void main(String[] args) {
    Account account = new Account("棺材本", 100);
    new Bank(account, 50, "我").start();
    new Bank(account, 100, "老婆").start();
    }}class Account {
    String name;
    int Money;
    public Account(String name, int Money) {
    this.name = name;
    this.Money = Money;
    }}class Bank extends Thread {
    private final Account account;
    private final int drawing;
    private int currentMoney = 0;
    public Bank(Account account, int drawing, String name) {
    super(name);
    this.account = account;
    this.drawing = drawing;
    }
    // 取钱
    @Override
    public void run() {
    // 判断还有钱吗
    if (account.Money - drawing < 0) {
    System.out.println("没钱了,别取了" + this.getName());
    return;
    }
    //模拟延迟
    try {
    Thread.sleep(500);
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    account.Money -= drawing;
    currentMoney += drawing;
    // 结果查看
    System.out.println(this.getName() + "取了:" + drawing + ",账户还剩:" + account.Money);
    }}
  • 结果


出现了负数,也就是说不符合实际情况的。

  • 内存分析

    • 例如:线程1和线程2都需要操作主内存中的共享变量A,当线程1已经在工作内存中修改了共享变量A副本的值但是还没有写回主内存,这时线程2拷贝了主内存中共享变量A到自己的工作内存中,紧接着线程1将自己工作内存中修改过的共享变量A的副本写回到了主内存,很明显线程2加载的共享变量A是之前的旧状态的数据,这样就产生了数据状态不一致的问题。

2.线程同步问题的解决——使用队列+锁

  • 线程同步其实就是一种等待机制 , 多个需要同时访问此对象的线程进入这个对象的等待池形成队列, 等待前面线程使用完毕 , 下一个线程再使用
  • 在Java中,每个对象都有一个锁,这个锁的信息储存在类的头部信息中。当一个线程需要使用这个对象的话,那么对象便把自己的锁给这个对象。当其他线程再来调用这个对象的时候,就拿不到这个锁,也就是拿不到相应的权限。这样的话便保证了线程安全

3. 关键字synchronized

  • synchronized的使用有两种方法:synchronized 方法 synchronized 块
  • synchronized方法:
    • synchronized方法控制对 “对象” 的访问 , 每个对象对应一把锁 , 每个ynchronized方法都必须获得调用该方法的对象的锁才能执行 , 否则线程会阻塞 ,方法一旦执行 , 就独占该锁 , 直到该方法返回才释放锁 , 后面被阻塞的线程才能获得这个锁 , 继续执行
    • 缺陷:
      • synchronized 在执行时,涉及到操作系统的线程调用,会降低执行效率。如果将一个复杂的方法申明为synchronized,则会对执行效率有较大的影响
  • synchronized 代码块(同步块)
    • 在涉及到多线程操作时,将涉及到数据操作的动作使用synchronized代码块进行包裹,这样可以避免因方法使用synchronized而导致的性能降低过多
    • 使用方法
      • 同步块 : synchronized (Obj ) { }
      • Obj 称之为 同步监视器
      • Obj 可以是任何对象 , 但是推荐使用共享资源作为同步监视器
      • 同步方法中无需指定同步监视器 , 因为同步方法的同步监视器就是this , 就是这个对象本身
  • synchronized 的使用原则:哪个对象要被改动,就给哪个对象上synchronized关键字

4. 死锁

  • 描述:

    • 多个线程各自占有一些共享资源 , 并且互相等待其他线程占有的资源才能运行 , 而导致两个或者多个线程都在等待对方释放资源 , 都停止执行的情形 . 某一个同步块同时拥有 “ 两个以上对象的锁 ” 时 , 就可能会发生 “ 死锁 ” 的问题 .
    • 比喻
      • 我看你还没睡,那我在玩会手机再睡。你看我没睡,就想再玩会手机再睡。这样你和我两个人都看对方还没睡,都想等对方睡觉之后再睡,这样两个人之间就形成了死循环。。。
  • 产生死锁的四个必要条件:

    1. 互斥条件:一个资源每次只能被一个进程使用。
    2. 请求与保持条件:一个进程因请求资源而阻塞时,对已获得的资源保持不放。
    3. 不剥夺条件 : 进程已获得的资源,在末使用完之前,不能强行剥夺。
    4. 循环等待条件 : 若干进程之间形成一种头尾相接的循环等待资源关系。
  • 避免:破坏上述条件中的任意一个或多个

5. 锁机制(lock()、和unlock()方法)

  • 从JDK 5.0开始,Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当

  • java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问,每次只能有一个线程对Lock对象加锁,线程开始访问共享资源之前应先获得Lock对象

  • ReentrantLock 类实现了 Lock ,它拥有与 synchronized 相同的并发性和内存语义,在实现线程安全的控制中,比较常用的是ReentrantLock,可以显式加锁、释放锁。

  • 代码示例

    class A {
    private final ReentrantLock lock = new ReenTrantLock();
    public void m(){
    // 上锁,锁定资源
    lock.lock();
    try{
    //保证线程安全的代码;
    }
    finally{
    // 解锁、释放资源
    lock.unlock();
    //如果同步代码有异常,要将unlock()写入finally语句块
    }
    }}

6. Lock vs synchronized

  • Lock是显式锁(手动开启和关闭锁,别忘记关闭锁),synchronized是隐式锁,出作用域自动释放
  • Lock只有代码块锁,synchronized有代码块锁和方法锁
  • 使用Lock锁,JVM将花费较少的时间来调度线程,性能更好。并且具有更好的扩展性(提供更多的子类)
  • 优先使用顺序:
    • Lock > 同步代码块(已经进入了方法体,分配了相应资源)> 同步方法(在方
      法体之外)

7. 安全的代码示例

package com.pbx.lesson02;/** * 模拟两个人同时从一个银行账户中取钱 * * @author BruceXu * @date 2020/9/13 */public class ThreadNotSync {
public static void main(String[] args) {
Account account = new Account("棺材本", 100);
new Bank(account, 50, "我").start();
new Bank(account, 100, "老婆").start();
}}class Account {
String name;
int Money;
public Account(String name, int Money) {
this.name = name;
this.Money = Money;
}}class Bank extends Thread {
private final Account account;
private final int drawing;
private int currentMoney = 0;
public Bank(Account account, int drawing, String name) {
super(name);
this.account = account;
this.drawing = drawing;
}
// 取钱
@Override
public void run() {
// synchronized 加锁原则:谁要被改,给谁加锁
synchronized (account) {
// 判断还有钱吗
if (account.Money - drawing < 0) {
System.out.println("没钱了,别取了" + this.getName());
return;
}
//模拟延迟
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
account.Money -= drawing;
currentMoney += drawing;
// 结果查看
System.out.println(this.getName() + "取了:" + drawing + ",账户还剩:" + account.Money);
}
}}

转载地址:https://www.cnblogs.com/primabrucexu/p/13694072.html 如侵犯您的版权,请留言回复原文章的地址,我们会给您删除此文章,给您带来不便请您谅解!

上一篇:多线程入门04 —— 浅谈线程通信
下一篇:多线程入门02 —— 线程的状态

发表评论

最新留言

第一次来,支持一个
[***.36.148.44]2022年06月18日 04时36分15秒

关于作者

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

最新文章

多线程的创建方式 2019-07-14 12:19:53
Git远程操作详解 2019-07-14 12:19:52
Git操作基本命令 2019-07-14 12:19:51
Git深度使用经验总结 2019-07-14 12:19:50
从 SVN 迁移到 Git 2019-07-14 12:19:50
git命令之git clone用法 2019-07-14 12:19:49
MySQL binlog 2019-07-14 12:19:49
IntelliJ IDEA使用git的问题总结 2019-07-14 12:19:48
设置IE兼容模式 2019-07-14 12:19:47
maven的profile设置 2019-07-14 12:19:47
关于mysql函数GROUP_CONCAT 2019-07-14 12:19:47
只读事务 2019-07-14 12:19:46
不得不提的volatile及指令重排序(happen-before) 2019-07-14 12:19:45
理解HTTP session原理及应用 2019-07-14 12:19:45
JAVA中session实现原理 2019-07-14 12:19:44
MySQL事务隔离级别详解 2019-07-14 12:19:44
HashSet与TreeSet对重复元素的判断不同之处 2019-07-14 12:19:43
正确理解ThreadLocal 2019-07-14 12:19:43
ThreadLocal,ThreadLocalMap,Thread 的相互关系以及设计原理分析 2019-07-14 12:19:42
Java中单例模式和静态类的区别 2019-07-14 12:19:41