java多线程（8）线程同步

最新推荐文章于 2022-08-26 11:03:01 发布
最新推荐文章于 2022-08-26 11:03:01 发布
阅读量334 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39452731/article/details/82703811
版权
  1. 由于多线程是并发执行的，这使得线程调度具有一定的随机性，一个线程执行到一半可能会被暂停。又由于线程是共享父进程的资源的，这就使得可能两个线程对一个变量的并发访问使得多线程的执行结果会出现意想不到的结局
    1. 例如线程a，b需要对成员变量A进行访问然后修改，a在访问后A然后还没有修改的时候线程b也对A进行了访问，这就可能会发生矛盾
  2. 下面这个例子就说明了上述的问题，甲进程在取了钱，并且显示取钱成功但是系统还没有对余额进行减少的时候乙取了钱，，并且显示取钱成功，然后再执行甲进程对金额的减少，再执行乙对金额的减少，虽然这只是只是有可能会发生的情况，但是这即体现出了程序的健壮性不达标，具体的讲解穿插再代码中 
    //账号类，包含了账号和余额两个成员变量
public class Account {
    private String accountNo;
    private  double balance;

    public Account(){}

    public Account(String accountNo, double balance){
        this.accountNo = accountNo;
        this.balance = balance;
    }

    public String getAccountNo() {
        return accountNo;
    }

    public void setAccountNo(String accountNo) {
        this.accountNo = accountNo;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
    public int hashCode(){
        return accountNo.hashCode();
    }
    public boolean equals(Object obj){
        if(this == obj){
            return true;
        }
        if(obj != null && obj.getClass() == Account.class){
            Account target = (Account)obj;
            return target.getAccountNo().equals(accountNo);
        }
        return false;
    }
}

    //“取钱”类，取钱的行为是在线程中的
public class DrawThread extends  Thread{
    private Account account;
    private double drawAmount;

    public DrawThread(String name, Account account, double drawAmount){
        super(name);
        this.account = account;
        this.drawAmount = drawAmount;
    }

//    在run方法中，对余额进行了判断，在余额大于取钱的金额的时候才执行取钱操作，但是在多线程中
//    由于甲线程在取钱之后还没有来得及对余额进行修改，乙又来进行取钱了，然后有进行了甲和乙对余额的
//    修改，虽然这只是有可能发生的情况
    public void run() {

            if (account.getBalance() >= drawAmount) {
                System.out.println(getName() + "取钱成功！吐出钞票：" + drawAmount);
//            try{
//                Thread.sleep(1);
//            }catch (InterruptedException e){
//                e.printStackTrace();
//            }
                account.setBalance(account.getBalance() - drawAmount);
                System.out.println("\t余额：" + account.getBalance());
            } else {
                System.out.println(getName() + "取钱失败，余额不足");
            }

    }
}

    //执行类
public class DrawTest {
    public static void main(String args[]){
        Account account = new Account("1234567", 1000);
        new DrawThread("甲", account, 800).start();
        new DrawThread("乙", account, 800).start();
    }
}
//执行这个类之后，有可能会出现以下的结果，原因在DrawThread类中给出：
//        乙取钱成功！吐出钞票：800.0
//        余额：200.0
//        甲取钱成功！吐出钞票：800.0
//        余额：-600.0

     

  3. 这个时候就需要对想成进行同步化，线程同步化可以通过synchronized(){}方法来实现同步代码块，这个方法将会对放在圆括号里的对象进行锁定，使得一个线程对圆括号里的对象进行完花括号里的操作之前，别的线程不会获得锁，也就不能对这个对象进行操作。在这个例子中，在同步化之后，在一个线程没有执行完同步化的所有操作之前，别的线程不会获得执行的机会，代码如下

    //“取钱”类，取钱的行为是在线程中的
public class DrawThread extends  Thread{
    private Account account;
    private double drawAmount;

    public DrawThread(String name, Account account, double drawAmount){
        super(name);
        this.account = account;
        this.drawAmount = drawAmount;
    }

//    在run方法中，对余额进行了判断，在余额大于取钱的金额的时候才执行取钱操作，但是在多线程中
//    由于甲线程在取钱之后还没有来得及对余额进行修改，乙又来进行取钱了，然后有进行了甲和乙对余额的
//    修改，虽然这只是有可能发生的情况
    public void run() {
        synchronized (account) {
            if (account.getBalance() >= drawAmount) {
                System.out.println(getName() + "取钱成功！吐出钞票：" + drawAmount);
//            try{
//                Thread.sleep(1);
//            }catch (InterruptedException e){
//                e.printStackTrace();
//            }
                account.setBalance(account.getBalance() - drawAmount);
                System.out.println("\t余额：" + account.getBalance());
            } else {
                System.out.println(getName() + "取钱失败，余额不足");
            }
        }
    }
}

    还有可以通过同步方法来实现，同步方法是直接在方法的名字之前加synchronized关键字修饰，代码如下

    //账号类，包含了账号和余额两个成员变量
public class Account {
    private String accountNo;
    private double balance;

    public Account() {
    }

    public Account(String accountNo, double balance) {
        this.accountNo = accountNo;
        this.balance = balance;
    }

    public String getAccountNo() {
        return accountNo;
    }

    public void setAccountNo(String accountNo) {
        this.accountNo = accountNo;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    public int hashCode() {
        return accountNo.hashCode();
    }

    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj != null && obj.getClass() == Account.class) {
            Account target = (Account) obj;
            return target.getAccountNo().equals(accountNo);
        }
        return false;
    }

    public synchronized void draw(double drawAmount) {
        if (balance >= drawAmount) {
            System.out.println(Thread.currentThread().getName() + "取钱成功！吐出钞票：" + drawAmount);
//            try{
//                Thread.sleep(1);
//            }catch (InterruptedException e){
//                e.printStackTrace();
//            }
            balance -= drawAmount;
            System.out.println("\t余额：" + balance);
        } else {
            System.out.println(Thread.currentThread().getName() + "取钱失败，余额不足");
        }
    }
}
    //“取钱”类，取钱的行为是在线程中的
public class DrawThread extends  Thread{
    private Account account;
    private double drawAmount;

    public DrawThread(String name, Account account, double drawAmount){
        super(name);
        this.account = account;
        this.drawAmount = drawAmount;
    }

//    在run方法中，对余额进行了判断，在余额大于取钱的金额的时候才执行取钱操作，但是在多线程中
//    由于甲线程在取钱之后还没有来得及对余额进行修改，乙又来进行取钱了，然后有进行了甲和乙对余额的
//    修改，虽然这只是有可能发生的情况
    public void run() {
        account.draw(drawAmount);
//        synchronized (account) {
//            if (account.getBalance() >= drawAmount) {
//                System.out.println(getName() + "取钱成功！吐出钞票：" + drawAmount);
            try{
                Thread.sleep(1);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
//                account.setBalance(account.getBalance() - drawAmount);
//                System.out.println("\t余额：" + account.getBalance());
//            } else {
//                System.out.println(getName() + "取钱失败，余额不足");
//            }
        }
    }
}

    还有一种方法是使用同步锁，每次只能有一个线程对同步锁对象加锁，线程开始访问共享资源之前应当先获得锁对象，具体讲解穿插在代码中

    //在程序中先定义了一个同步锁对象，在实现draw方法的时候，进入方法在还没有执行具体的取钱操作之前先请求对同步锁对象
//进行加锁，在执行完取钱操作之后，程序在finally中释放同步锁
import java.util.concurrent.locks.ReentrantLock;

//账号类，包含了账号和余额两个成员变量
public class Account {
    private String accountNo;
    private double balance;
    
    private final ReentrantLock lock = new ReentrantLock();
//    定义一个锁对象

    public Account() {
    }

    public Account(String accountNo, double balance) {
        this.accountNo = accountNo;
        this.balance = balance;
    }

    public String getAccountNo() {
        return accountNo;
    }

    public void setAccountNo(String accountNo) {
        this.accountNo = accountNo;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    public int hashCode() {
        return accountNo.hashCode();
    }

    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj != null && obj.getClass() == Account.class) {
            Account target = (Account) obj;
            return target.getAccountNo().equals(accountNo);
        }
        return false;
    }

    public  void draw(double drawAmount) {
        
        lock.lock();
//        这一步就是加锁操作，线程访问共享资源之前应当先获得锁对象
        
        
        try{
            if (balance >= drawAmount) {
                System.out.println(Thread.currentThread().getName() + "取钱成功！吐出钞票：" + drawAmount);
//            try{
//                Thread.sleep(1);
//            }catch (InterruptedException e){
//                e.printStackTrace();
//            }
                balance -= drawAmount;
                System.out.println("\t余额：" + balance);
            } else {
                System.out.println(Thread.currentThread().getName() + "取钱失败，余额不足");
            }
        }finally {
            
            lock.unlock();
//            在访问完共享资源之后应当释放锁对象
        }

    }
}

     

林敏锐丶
关注
专栏目录
Java(八)----多线程
MrDaKai的博客
11-22 427
- 线程概念 - Java实现多线程程序一 - Thread类的方法 - Java实现多线程程序二 - 线程安全问题 - 同步synchronized使用 - 锁对象的选择 - 死锁案例 - 生产者与消费者 - 线程通信的方法 wait() notify()
【Java多线程】线程同步
weixin_44337386的博客
05-11 265
本系列记录Java从入门开始的知识点，本文介绍线程同步：什么是线程同步、线程不安全的例子、同步块、JUC、死锁和Lock锁。
java -8多线程同步锁
imxlw00的专栏
12-28 576
同步代码块的锁对象是任意对象：（Object obj ; Demo d;）这些都行 同步方法： 把同步关键字synchronized添加到方法上,那么，同步方法的锁对象是 this 同步方法是静态方法，那么这个静态同步方法的锁对象是 类的字节码文件对象 public class SellTicket implements Runnable { // 定义100张票 p...
Java8——线程的同步与死锁
小金是个小菜鸡
06-27 244
同步问题的引出： 范例：卖票问题 class MyThread implements Runnable { private int ticket = 5; @Override public void run() { for (int x = 0; x < 20; x++) { if (ticket > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { //
java高级部分(八)-(多线程同步)
今昔何年的博客
05-28 409
多线程同步 为了模拟更真实的场景,加入延迟操作(让我们线程睡100毫秒)   会有一些问题:    1)同一张票被卖了多次    CPU的执行有一个特点(具有原子性操作:最简单最基本的操作)    2)出现了0或者负票    (延迟操作+线程的执行随机性)   出现同票的原因:CPU的执行有一个特点(具有原子性操作:最简单最基本的操作)   t1线程进来,睡完了,100张...
Java 8 并发之同步与锁
ShuSheng007的程序人生
07-08 1311
前言 点击查看原文： 原文地址第一部分：线程（Thread）与执行体（Executors） 第二部分：同步（Synchronization）与锁（Locks） 第三部分：原子变量与ConcurrentMap 欢迎浏览Java 8 并发教程的第二部分.本教程致力于使用简单而易于理解的代码实例来教授你关于java8中并发编程一些知识。接下来你会学到在并发编程中使用synchronized关键字，锁
[Java笔记]多线程（二）——线程同步
CSQQWeChat的博客
03-20 135
同步代码块 一、问题的出现        run()方法的方法体不具有同步安全性，因为当多条语句在操作共享数据时，其中一个线程的多条语句只执行了一个部分，还没有执行完，另外一个线程参与了执行，导致共享数据结果的错误。        例如问题——银行取钱问题 //账户类，该类封装了账户编号和余额两个实例变量 public class Account { // 封装账户编
详解java多线程的同步控制
01-20
同步控制是并发程序必不可少的重要手段，本文我们将通过重入锁、读写锁、信号量、倒计数器和循环栅栏以及他们的实例来介绍Java并发程序中的同步控制。 目录线程安全 Thread Safety重入锁 ReentrantLock读写锁 ...
以银行取钱为例模拟Java多线程同步问题完整代码
08-28
Java 多线程同步问题完整代码 本文主要介绍了Java 多线程同步问题完整代码，以银行取钱为例，通过代码实例来演示多线程同步问题的解决方案。多线程同步是指在同一程序中有多个顺序流在执行，并且这些顺序流之间需要...
Java多线程-线程的同步与锁的问题
09-01
Java多线程编程中，线程同步是一种解决并发问题的关键技术。当多个线程同时访问共享资源时，可能会引发数据不一致性和竞态条件。线程同步的主要目标是确保同一时间只有一个线程能够访问特定的代码段，以避免数据损坏...
Java多线程 线程同步与死锁
08-30
Java多线程 线程同步与死锁 Java多线程是一种编程技术，允许多个线程同时执行，以提高程序的执行效率和响应速度。但是，多线程编程也存在一些安全问题，例如线程同步和死锁问题。 线程同步是指多个线程之间的协作...
详解Java多线程处理List数据
08-26
详解Java多线程处理List数据 Java多线程处理List数据是指在Java编程中，使用多线程技术来处理List数据的操作。这种操作可以提高程序的执行效率和性能，特别是在处理大规模数据时。下面将详细介绍Java多线程处理List...
Java 多线程系列(8) —— 线程同步基础
qq_38219153的博客
08-26 309
Synchronized 关键字提供了一种锁机制，可以实现一个简单的策略来防止线程的干扰和内存一致性错误。即 Synchronized 能够确保共享变量之间的互斥访问，从而防止数据不一致的问题出现。Synchronized 关键字包括 moniter enter 和 moniter exit 两个 JVM 命令，他能够保证在任何线程执行到moniter enter 成功之前都必须从主存中获取数据，而不是从缓存中。在 moniter exit 运行成功之后，共享变量被更新后的值必须被刷入主存中。...
JAVA(8)多线程
BLOG CodingJiang = new BLOG (“hello world”);
07-11 375
方法1实现runnable接口 方法2实现Thread接口 public class CreateThread implements Runnable { void run(){ } } 匿名类 没有构造函数 Class A{ int i; A(int j){i=j;} public static void main(String[] a...
java8-多线程
dhlwcs的专栏
04-18 1213
------- android培训、java培训、期待与您交流！ ---------- 进程：就是一个正在执行中的程序。每个进程都有一个执行顺序，叫一个执行路径，或一个控制单元。 线程：就是进程中的一个独立的控制单元，线程在控制着进程的执行。一个进程中至少有一个线程。 Java VM 启动时会有一个进程java.exe 进程中至少有一个线程在负责程序的执行，并且运行的代码存
Java-08多线程
Jerry&Crj的博客
04-17 125
文章目录Java-08多线程一、基本概念：程序、进程、线程1.单核CPU和多核CPU的理解2.并行和并发3.多线程的优点二、线程的创建和使用1.Thread类的特性2.Thread类2.1 构造器3.API中创建线程的两种方式3.1 方式一：继承Thread类3.2 注意点：3.3 代码3.2 方式二：实现Runnable接口代码4.继承方式和实现方式的联系与区别三、Thread类的有关方法线程的生命周期四、线程的同步4.1 问题引入4.2 `Synchronized`4.2.1 用法4.2.2 同步的范围
java(八)多线程
dxyLqgz的博客
03-28 192
多线程 线程 线程是程序执行的一条路径, 一个进程中可以包含多条线程。 多线程并发执行可以提高程序的效率, 可以同时完成多项工作。 多线程 从软件或硬件上实现多个线程并发执行的技术。 多线程并行和并发的区别 并行就是两个任务同时运行，就是甲任务进行的同时，乙任务也在进行。(需要多核CPU) 并发是指两个任务都请求运行，而处理器只能按受一个任务，就把这两个任务安排轮流进行，由于...
Java线程详解(8)-线程的同步
勇往直前的专栏
10-29 222
Java线程：线程的同步-同步方法         线程的同步是保证多线程安全访问竞争资源的一种手段。         线程的同步是Java多线程编程的难点，往往开发者搞不清楚什么是竞争资源、什么时候需要考虑同步，怎么同步等等问题，当然，这些问题没有很明确的答案，但有些原则问题需要考虑，是否有竞争资源被同时改动的问题？         在本部分之前，请参阅《Java线程：线程的同步与锁》部分...
spark_3_2_0-master-3.2.3-1.el7.noarch.rpm
最新发布
09-16
Ambari+Bigtop 一站式编译和部署解决方案 https://gitee.com/tt-bigdata/ambari-env
Java多线程：Synchronized同步类方法解析
"Java多线程编程中，`synchronized`关键字是用于解决并发访问时的数据安全性问题，尤其是处理共享资源时防止“脏数据”出现的关键。本文将深入探讨如何使用`synchronized`关键字同步类方法，确保线程安全。" 在Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值