Java多线程——同步（一）

最新推荐文章于 2020-05-30 20:42:33 发布
最新推荐文章于 2020-05-30 20:42:33 发布
阅读量852 收藏 1
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq710262350/article/details/43085439
版权
        可能我们在开发项目进行过程中，通常会冒出这样的困惑：应该选择效率，还是选择质量？会不会有偷懒的思维，觉得把一些摸不清头绪，不知道怎么写的代码片段去掉，可以节省许多时间，更早的完成项目计划，其实以前我也是这么想的，但最近我开始意识到，这个问题的纠结之处不在于选择困难，而在于问题本身是个伪命题。
        什么是“质量”呢？对于我们程序员来说可能是测试通过率，变量命名，代码格式化，组件化，查找bug，程序测试等。也有可能是程序的可扩展性，服务延时，产品功能的完整程度。前一种围绕代码的问题可以看成“代码质量”问题，第二种可以看成“执行质量”。
从“代码质量”来看，走捷径的偷懒思维，其实是种十分短视的做法。含糊绕过某个问题，你可能一时觉得省事不少，但到头来，往往发现因此搅乱了系统而要花费更多的时间来一行行的检查代码，找出bug，甚至重新调整整理逻辑框架。所以牺牲代码质量换取速度通常是得不偿失的。
        相反地，高质量的代码其实是可以帮助你节省时间的。统一代码规范和变量命名，不仅可以帮到别的程序员，还可以帮到以后的你，更好地理解你现在写下的代码，经过严密思考而设计出的轻量级代码架构，则可以让你在迭代产品的时候获得更高的效率，更清晰地了解该从何入手，而不是到数据库里找需要替代的地方，而高测试通过率还可以给你充足的自信去调整代码，减少bug数量，减少QA时间。

       我们现阶段还是注重好代码的质量，执行质量就不多说啦，当然这些都是题外话，想和各位分享！接下来还是进入正题。


什么是竞争条件


       在大多数实际的多线程应用中，两个或两个以上的线程需要共享对同一数据的存取。如果两个线程存取相同的对象，并且每一个线程都调用了修改该对象的方法，将会发生什么？可能就会产生错误的对象。这样的情况通常称为竞争条件。

       我们来模拟一个有若干账户的银行，随机在这些账户之间转账，每一个账户一个线程。每一次交易，会从线程所服务的账户中随机转移一定的金额到另一个账户中。

       这是Bank类中转账的方法：

    public void transfer(int from, int to, double amount) {
        if (accounts[from] < amount) {
            return;
        }
        System.out.print(Thread.currentThread());
        accounts[from] -= amount;
        System.out.printf("转账金额： %10.2f 转出账户：  %d 转入账户： %d", amount, from, to);
        accounts[to] += amount;
        System.out.printf("  最后的金额: %10.2f%n", getTotalBalance());
    }

      这是转账线程类中run方法（随机选择一个目标账户和一个随机账户调用转账方法，然后睡眠）： 

@Override
    public void run() {
        while (true) {
            int toAccount = (int) (bank.size() * Math.random());
            double amount = maxAmount * Math.random();
            bank.transfer(fromAccount, toAccount, amount);
            try {
                Thread.sleep((int) (DELAY * Math.random()));
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }

      当它运行时，我们不清楚某一时间某一个账户有多少钱，但是，所有账户的总金额应该是保持不变的。

      下面是例子的完整代码：

      Bank类：

/**
 * @author XzZhao
 */
public class Bank {

    private final double[] accounts;

    public Bank(int n, double initialBalance) {
        accounts = new double[n];
        for (int i = 0; i < accounts.length; i++) {
            accounts[i] = initialBalance;
        }
    }

    public void transfer(int from, int to, double amount) {
        if (accounts[from] < amount) {
            return;
        }
        System.out.print(Thread.currentThread());
        accounts[from] -= amount;
        System.out.printf("转账金额： %10.2f 转出账户：  %d 转入账户： %d", amount, from, to);
        accounts[to] += amount;
        System.out.printf("  最后的金额: %10.2f%n", getTotalBalance());
    }

    public double getTotalBalance() {
        double sum = 0;
        for (double a : accounts) {
            sum += a;
        }
        return sum;
    }

    public int size() {
        return accounts.length;
    }

}

     TransferRunnable类： 

/**
 * @author XzZhao
 */
public class TransferRunnable implements Runnable {

    private final Bank   bank;
    private final int    fromAccount;
    private final double maxAmount;
    private final int    DELAY = 10;

    public TransferRunnable(Bank bank, int fromAccount, double maxAmount) {
        super();
        this.bank = bank;
        this.fromAccount = fromAccount;
        this.maxAmount = maxAmount;
    }

    @Override
    public void run() {
        while (true) {
            int toAccount = (int) (bank.size() * Math.random());
            double amount = maxAmount * Math.random();
            bank.transfer(fromAccount, toAccount, amount);
            try {
                Thread.sleep((int) (DELAY * Math.random()));
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}
  Test: 

/**
 * @author XzZhao
 */
public class UnsynchBankTest {
    public static final int    NACCOUNTS       = 100;
    public static final double INITIAL_BALANCE = 1000;

    public static void main(String[] args) {
        Bank b = new Bank(NACCOUNTS, INITIAL_BALANCE);
        for (int i = 0; i < NACCOUNTS; i++) {
            TransferRunnable r = new TransferRunnable(b, i, INITIAL_BALANCE);
            Thread t = new Thread(r);
            t.start();
        }
    }
}
程序出错：总金额发生变化


锁对象


有两种机制防止代码块受并发访问的干扰。一个是ReentrantLock类，还有一个是synchronized关键字。

用ReentrantLock保护代码块的结构：

        Lock myLock = new ReentrantLock();
        myLock.lock();
        try {
            // work code
        } finally {
            myLock.unlock();
        }

        这一结构确保任何时刻只有一个线程进入。一旦一个线程封锁了锁对象，其他任何线程都无法通过lock语句。当其他线程调用lock时，它们被阻塞，直到第一个线程释放锁对象。

        使用一个锁来保护Bank类的transfer方法：

/**
 * @author XzZhao
 */
public class Bank {

    ...
    private final Lock     bankLock = new ReentrantLock();

    public void transfer(int from, int to, double amount) {
        if (accounts[from] < amount) {
            return;
        }
        bankLock.lock();
        try {
            System.out.print(Thread.currentThread());
            accounts[from] -= amount;
            System.out.printf("转账金额： %10.2f 转出账户：  %d 转入账户： %d", amount, from, to);
            accounts[to] += amount;
            System.out.printf("  最后的金额: %10.2f%n", getTotalBalance());
        } finally {
            bankLock.unlock();
        }
    }
    ...
}

        再次运行程序后，发现不会出现错误，线程之间不会互相影响了。

        锁是可重入的，因为线程可以重复地获得已经持有的锁。锁保持一个持有计数来跟踪lock方法的嵌套调用。线程在每一次调用lock都要调用unlock来释放锁。所以，被一个锁保护的代码可以调用另一个使用相同的锁的方法。


条件对象


       当线程进入区域，却发现在某一条件满足之后才能执行。要使用一个条件对象来管理那些已经获得了一个锁但是却不能做有用工作的线程。

       我们来修改一下例子，我们使用条件对象来避免选择没有足够资金的账户作为转出账户。

      Bank类：

/**
 * @author XzZhao
 */
public class Bank {

    private final double[]  accounts;
    private final Lock      bankLock;
    private final Condition sufficientFunds;

    public Bank(int n, double initialBalance) {
        accounts = new double[n];
        for (int i = 0; i < accounts.length; i++) {
            accounts[i] = initialBalance;
        }
        bankLock = new ReentrantLock();
        sufficientFunds = bankLock.newCondition(); // 获取一个和该锁相关的条件对象
    }

    public void transfer(int from, int to, double amount) throws InterruptedException {
        bankLock.lock();
        try {
            while (accounts[from] < amount) {
                sufficientFunds.await(); // 将该线程放到条件的等待集中
            }
            System.out.print(Thread.currentThread());
            accounts[from] -= amount;
            System.out.printf("转账金额： %10.2f 转出账户：  %d 转入账户： %d", amount, from, to);
            accounts[to] += amount;
            System.out.printf("  最后的金额: %10.2f%n", getTotalBalance());
            sufficientFunds.signalAll(); // 解除该条件的等待集中的所有线程的阻塞状态
        } finally {
            bankLock.unlock();
        }
    }

    public double getTotalBalance() {
        bankLock.lock();
        try {
            double sum = 0;
            for (double a : accounts) {
                sum += a;
            }
            return sum;
        } finally {
            bankLock.unlock();
        }
    }

    public int size() {
        return accounts.length;
    }

}
 TransferRunnable类： 

/**
 * @author XzZhao
 */
public class TransferRunnable implements Runnable {

    private final Bank   bank;
    private final int    fromAccount;
    private final double maxAmount;
    private final int    DELAY = 10;

    public TransferRunnable(Bank bank, int fromAccount, double maxAmount) {
        super();
        this.bank = bank;
        this.fromAccount = fromAccount;
        this.maxAmount = maxAmount;
    }

    @Override
    public void run() {
        try {
            while (true) {
                int toAccount = (int) (bank.size() * Math.random());
                double amount = maxAmount * Math.random();
                bank.transfer(fromAccount, toAccount, amount);
                Thread.sleep((int) (DELAY * Math.random()));
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}


     

Even丶
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程——线程同步
u010759175的专栏
12-28 2807
1.不安全的买票 //不安全的买票 //线程不安全，有负数或者多人买到同一张票 public class UnsafeBuyTicket { public static void main(String[] args) { BuyTicket buyTicket = new BuyTicket(); new Thread(buyTicket,"苦逼的我").start(); new Thread(buyTicket,"牛逼的你们").start(); new Thread(buyTic
Java 多线程 —— 同步代码块（解决线程安全问题)
一纸春秋的博客
10-23 1万+
目录火车站抢票问题同步代码块同步方法（this锁）同步方法，在public的后面加上synchronized关键字this锁静态同步方法 火车站抢票问题 由于现实中买票也不会是零延迟的，为了真实性加入了延迟机制，也就是线程休眠语句 package test.MyThread.ticketDemo; public class RunnableThread implements Runnable{ private int ticket = 100; @Override public v
JAVA多线程——实现同步
weixin_38719347的博客
07-26 1万+
转载(https://www.cnblogs.com/soundcode/p/6295910.html)加上了自己的补充和理解 为何要使用同步？ java允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查）， 将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用， 从而保证了该变量的唯一性和准确性。 线程同步的方...
java多线程 —— 面试题集合（最全集合）
热门推荐
Charles Ren's Tech Blog
10-12 2万+
文章目录导读1. 多线程基本概念多线程有什么用？线程、进程、协程的区别什么是多线程上下文切换？什么是线程安全2. java多线程创建创建线程的方式Runnable和Callable的区别Thread类中的start()和run()方法有什么区别?什么导致线程阻塞？3. 多线程同步和锁怎么检测一个线程是否持有对象监视器Condition？4. 线程池CyclicBarrier和CountDownLa...
java多线程 —— 多线程同步器
向来缘浅，奈何情深
05-30 2330
1、什么是多线程同步器？ 可以理解为，用于控制多线程之前同步动作的工具。 2、为什么使用多线程同步器？ 在实际应用中，我们希望多线程根据某些一些特定的规则执行。因此有了多线程同步器，通过不同的多线程同步器，可以让多线程实现多样的行为。 3、多线程同步器介绍 3.1、Samaphore 应用场景：对于一组有限制都资源访问。比如餐厅有2个位置但同时有10个人要吃饭，则要控制10个人对餐位的并发实用。即当餐位有空余时，就会有人用餐，没有空余时，则进入阻塞等待。 用法：定义Semaphore变量sem
Java多线程基础——Lock类
08-31
Lock类是Java类来提供的功能，丰富的api使得Lock类的同步功能比synchronized的同步更强大。本文对此进行详细介绍，下面跟着小编一起来看下吧
JAVA内存模型——同步操作规则1
08-08
JAVA 数据在内存中的执行流程执行规则：Read和Load ，Store和Write必须顺序执行，但是不必连续执行；一个变量同时只能被一条线程操作，可以被多条
Java多线程之并发工具类
12-22
　主要参考资料：java并发编程的艺术、Java并发——同步工具类 　二、CountDownLatch（同步倒数计数器）–不仅仅用于多线程 　1.作用：允许一个或多个线程等待其他线程完成操作。 　CountDownLatch的构造函数...
Java线程间同步互斥
03-17
Java 语言内在强大的多线程支持使得处理这类问题变得相对来说比较简单。本例将模仿经典的线程同步互斥例子——生产者和消费者问题，来演示 　java 强大的多线程机制。生产者和消费者共享一个数据，当数据为0 时，...
[Java]多线程:共享资源同步——不认真看你会后悔的
12-21
在进行多线程开发时最令人头痛的问题估计就是对共享资源的控制了吧，今天就让我们谈一谈这个问题吧。 共享资源顾名思义就是需要被多个线程使用的资源，但是很多情况下我们是不能允许多个线程同时使用这个资源的。这...
Java多线程——阻塞队列
Even丶的专栏
02-03 1138
现在，通过前几篇的总结，我们对Java多线程已经有所了解了，但是都是一些Java并发程序设计基础的底层构建块。对于实际编程来说，我们应该尽可能的远离底层结构。使用那些由并发处理的专业人士实现的较高层次的结构要方便的多，安全的多。 阻塞队列         对于许多线程问题。可以通过使用一个或多个队列以优雅且安全的方式将其形式化。生产者线程向队列插入元素，消费者线程则取出他们。使用队列，可以安全
Java对象克隆——浅拷贝与深拷贝
Even丶的专栏
01-19 1100
今天收到经理的一封Email，里面是关于对象拷贝的东西，实例代码是C#的，大概看了下，基本还是能看明白！下来觉得还是总结下Java中的对象克隆的知识点以便日后查阅。 对象克隆       当我们拷贝一个变量时，原始变量与拷贝变量引用同一个对象，这就是说，改变一个变量所引用的对象将会对另一个变量产生影响。 Employee类： /** * @author XzZhao */ publ
Java多线程——执行器（Executor）
Even丶的专栏
03-08 931
Markdown编辑器上线啦，终于等到你！ 执行器 构建一个新的线程是有一定的代价的，因为涉及到和操作系统的交互。如果程序中创建了大量的生命周期很短的线程，应该使用线程池（thread pool）。 另一个使用线程池的理由是减少并发线程的数目。线程数量太多会大大降低性能甚至会使虚拟机崩溃。如果有一个会创建许多线程的算法，应该使用一个线程数“固定的”线程池以限制并发线程的总数。
Java多线程——Thread
Even丶的专栏
01-22 892
今天工作上用到了一些线程方面的知识，有些知识点学了不用一段时间后就会被忘记的，所以下来后觉得还是应该总结一下基础知识，方面以后回顾。 什么是线程        大家都很熟悉操作系统中的多任务：在同一刻运行多个程序的能力。       多线程程序在较低的层次上扩展了多任务的概念：一个程序同时执行多个任务。通常，每一个任务称为一个线程，它是线程控制的简称。可以同时运行一个以上线程的程序称
Java多线程——同步（二）
Even丶的专栏
01-29 851
在前面的一篇中，总结了如何使用Lock和Condition对象。我们先总结一下有关锁和条件的关键之处： 锁用来保护代码片段，任何时刻只能有一个线程执行被保护的代码。锁可以管理试图进入被保护代码段的线程。 锁可以拥有一个或多个相关的条件对象。每个条件对象管理那些已经进入被保护的代码段但还不能运行的线程。 synchronized关键字        Java中的每一个对象都有一个内部锁；
Java多线程——Callable与Future
Even丶的专栏
03-08 771
二月份回家过年了，家里没网，所以博客也停了一段时间，上班已经一周了，总的来说还是比较忙吧！周末还是把没总结完的知识点总结一下，方便日后翻阅！ Callable与Future Runnable封装一个异步运行的任务，可以把它想象成一个没有参数和返回值的异步方法。Callable与Runnable类似，但是有返回值。Callable接口是一个参数化的类型，只有一个方法call。 public i
infrared-remote-candroid studiodemo
最新发布
05-05
android studio下载
java 确保线程安全的单例模式
03-25
这是一种比较好的实现方式，使用了双重校验锁，既保证了线程安全，又实现了按需初始化，同时也减少了同步开销。 ```java public class Singleton { private volatile static Singleton instance; private ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值