JAVA多线程之并发和同步操作

最新推荐文章于 2022-05-23 14:03:07 发布
最新推荐文章于 2022-05-23 14:03:07 发布
阅读量180 收藏
点赞数
分类专栏： Java学习巩固 文章标签： java 多线程 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/scorpio_j/article/details/109719672
版权

1、并发和同步

  • 并发：多个进程访问同一个对象
  • 同步：多个线程想修改这个对象 需要线程同步。

2、例子

买票
public class MyThreadFour implements  Runnable {
    private int ticket = 10;
    private Boolean flag = true;
    @Override
    public void run() {
        while (flag){
            buy();
        }
    }
    public void  buy(){

        if (ticket<=0){
            flag = false;
            return;
        }
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"买到了第"+ticket--+"张票");
    }

    public static void main(String[] args) {
        MyThreadFour myThreadFour = new MyThreadFour();
        new Thread(myThreadFour,"张三").start();
        new Thread(myThreadFour,"李四").start();
        new Thread(myThreadFour,"黄牛").start();
    }
}

输出结果：

在这里插入图片描述

  • 结果分析。出现数据紊乱。
  • 需要同步。
取钱
public class SynDemo1 {
    public static void main(String[] args) {
        Account account = new Account(100,"基金");
        DrawMoney me = new DrawMoney(account,50,"我");
        DrawMoney you = new DrawMoney(account,100,"你");
        //同时取钱
        me.start();
        you.start();
    }
}

class Account{
    int money;
    String name;
    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

class  DrawMoney extends Thread{
    //账户
    Account account;
    //手里的钱
    int nowMoney;
    //取的钱
    int drawMoney;

    public DrawMoney(Account account,int drawMoney,String name){
        super(name);
        this.account = account;
        this.drawMoney = drawMoney;
    }

    @Override
    public void run() {
        //判断
        if (account.money-drawMoney<0){
            System.out.println(this.getName()+"钱不够 取不了");
            return;
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //账户余额
        account.money=account.money-drawMoney;
        //目前手里的钱
        nowMoney = nowMoney+drawMoney;
        System.out.println("账户余额"+account.money);
        System.out.println(this.getName()+"手里有"+nowMoney);
    }
}

账户余额-50
账户余额50
我手里有50
你手里有100
  • 数据紊乱
  • 线程不安全
不安全的集合
public class SynDome2 {
    public static void main(String[] args) {
        List<String > list = new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        System.out.println(list.size());
    }
}

8294
  • 会存在多个线程访问同一个add方法，将其覆盖。所以没有10000的长度/

3、形成条件

  • 队列 和 锁 保证线程的安全性，实现同步
  • synchronized 同步

4、同步方法（1） synchronized

  • 关键字 synchronized
  • 每个对象都有一个把锁。synchronized方法必须获得所操作对象的锁，才能执行，否则线程会阻塞。一旦方法执行，就会独占该锁。直到该方法返回释放该锁，后面的被阻塞的线程才能获得这把锁。
  • 缺点 会影响代码的执行效率
  • 同步方法
  • public synchronized void buy(){}
  • 同步块
    • synchronized(Obj){}
    • Obj是同步监视器
    • Obj 可以是任何对象。推荐使用共享资源作为同步监视器
  • 同步方法中 无需设置监视器，因为同步方法的同步监视就是this，这个对象本身或是class。
买票例子修改
public class MyThreadFour implements  Runnable {
    private int ticket = 10;
    private Boolean flag = true;
    @Override
    public void run() {
        while (flag){
            buy();
        }
    }
    //加锁
    public synchronized  void  buy(){

        if (ticket<=0){
            flag = false;
            return;
        }
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"买到了第"+ticket--+"张票");
    }

    public static void main(String[] args) {
        MyThreadFour myThreadFour = new MyThreadFour();
        new Thread(myThreadFour,"张三").start();
        new Thread(myThreadFour,"李四").start();
        new Thread(myThreadFour,"黄牛").start();
    }
}


张三买到了第10张票
张三买到了第9张票
黄牛买到了第8张票
李四买到了第7张票
李四买到了第6张票
黄牛买到了第5张票
张三买到了第4张票
黄牛买到了第3张票
李四买到了第2张票
黄牛买到了第1张票
取钱例子修改
class  DrawMoney extends Thread{
    //账户
    Account account;
    //手里的钱
    int nowMoney;
    //取的钱
    int drawMoney;

    public DrawMoney(Account account,int drawMoney,String name){
        super(name);
        this.account = account;
        this.drawMoney = drawMoney;
    }

    @Override
    public void run() {
        //加锁
        synchronized (account){
            //判断
            if (account.money-drawMoney<0){
                System.out.println(this.getName()+"钱不够 取不了");
                return;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            //账户余额
            account.money=account.money-drawMoney;
            //目前手里的钱
            nowMoney = nowMoney+drawMoney;
            System.out.println("账户余额"+account.money);
            System.out.println(this.getName()+"手里有"+nowMoney);
        }

    }
}

账户余额50
我手里有50
你钱不够 取不了
集合例子修改
public class SynDome2 {
    public static void main(String[] args) {
        List<String > list = new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                //加锁
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

10000
总结：锁的对象是变化的量，需要进行 增删改 的对象

5、JUC

import java.util.concurrent.CopyOnWriteArrayList;

public class TestJUC {
    public static void main(String[] args) {
        //安全类型集合
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
        for (int i = 0; i < 1000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

6、同步方法(2) Lock

  • 显示定义同步锁对象 来实现同步，用lock对象充当
  • ReentrantLock类实现了Lock。拥有和synchronized相同的并发性和内存语义。
使用
class A{
    private final ReentrantLock lock = new ReentrantLock();
    public void B(){
        lock.lock();
        try{
            //保证线程安全
        }finally {
            lock.unlock();
        }
    }
}

买票例子

import java.util.concurrent.locks.ReentrantLock;
public class SynLock {
    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 final ReentrantLock lock = new ReentrantLock();
    int ticket = 5;
    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();
                Thread.sleep(1000);
                if (ticket>0){
                    System.out.println(Thread.currentThread().getName() + "买到了第" + ticket-- + "张票");
                }else {
                    break;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
}

7、对比

  • Lock是显示锁 需要手动的打开和关闭

  • synchronized 是隐式锁，出了作用域 自动释放

  • lock 只用代码块锁

  • synchronized 有代码块锁 和 方法锁

  • 使用Lock锁 JVM将花费较少的时间，来调度线程，性能更好，并且具有更好的扩展性。
    break;
    }
    } catch (InterruptedException e) {
    e.printStackTrace();
    } finally {
    lock.unlock();
    }
    }
    }
    }


## 7、对比

- Lock是显示锁 需要手动的打开和关闭
- synchronized 是隐式锁，出了作用域 自动释放



- lock 只用代码块锁
- synchronized 有代码块锁 和 方法锁
- 使用Lock锁 JVM将花费较少的时间，来调度线程，性能更好，并且具有更好的扩展性。
- 使用顺序：lock > 同步代码块 > 同步方法
scorpio_j
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java基础巩固之线程的同步synchronized
xuhu的专栏
04-27 628
Java中的synchronized关键字，可以用来修饰方法
java多线程详解(并发,并行,同步)
热门推荐
fly_zhyu的博客
07-04 2万+
并行和并发: 引子:前面讲到程序的运行流程的时候，说程序在没有流程控制前提下，代码都是从上而下逐行执行的。 需求:现在需要设计一个程序想要完成边运行游戏,边播放歌的功能，怎么设计？ 要解决上述问题,咱们得使用多进程或者多线程来解决. 并发和并行是即相似又有区别(微观概念)： 并行：指两个或多个事件在同一时刻点发生； 并发：指两个或多个事件在同一时间段内发生。 在操作系统中，在
java多线程——线程同步
qq_38256736的博客
08-30 128
线程同步 并发：同一个对象被多个线程同时操作，如上万人同时抢100张票，两个银行同时取钱。 线程同步：是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面的线程使用完毕，下一个线程再使用。 锁机制：由于同一进程的多个线程共享同一块存储空间，在带来方便的同时也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制（synchronized），当一个线程获得对象的排它锁，独占资源，其它线程必须等待，使用后释放锁即可。存在以下问题： 一个线程持有锁会导致其他所
Java多线程（并发,并行,同步）
CancerCao
06-06 476
并行和并发: 引子:前面讲到程序的运行流程的时候，说程序在没有流程控制前提下，代码都是从上而下逐行执行的。 需求:现在需要设计一个程序想要完成边运行游戏,边播放歌的功能，怎么设计？ 要解决上述问题,咱们得使用多进程或者多线程来解决. 并发和并行是即相似又有区别(微观概念)： 并行：指两个或多个事件在同一时刻点发生； 并发：指两个或多个事件在同一时间段内发生。 在操作系统中，在多道程序环境下，并发性是指在一段时间内宏观上有多个程序在同时运行，但在单CPU系...
多线程编程---同步并发操作
u201012980的专栏
07-31 3335
线程同步， 简单的说，就是在第一个线程完成前，需要等待另一个线程执行完成。通常情况下，线程会等待一个特定事件发生，或者等待某一条件达成(true).等待一个事件或者其他条件 假设你在旅游，而且正在一辆在夜间运行的火车上。在夜间，如何在正确的站点下车呢？一种方法是整晚都要醒着，然后注意到了哪一站。这样，你就不会错过你要到达的站点，但是这样会让你感到很疲倦。另外，你可以看一下时间表，估计一下火车到达目
Java多线程之并发工具类
12-22
Java并发工具类是Java多线程编程中必不可少的一部分，它们为开发者提供了更加高效和灵活的线程同步机制。本文将详细介绍三个重要的并发工具类：CountDownLatch、CyclicBarrier和Semaphore。 首先，CountDownLatch是...
Java多线程并发执行demo代码实例
08-18
"Java多线程并发执行demo代码实例" ...通过这个demo代码实例，我们学习了Java多线程并发执行的实现，包括泛型、线程池、阻塞队列和计数器等概念。这些概念可以帮助开发者编写更加高效、灵活和可重用的代码。
JAVA多线程与并发学习总结分析
09-05
总的来说，JAVA多线程与并发的学习涵盖了从硬件层面的缓存一致性到软件层面的内存模型、原子性、可见性和有序性，以及解决并发问题的关键机制如volatile和synchronized。理解并掌握这些知识点对于编写高效、安全的...
Java_多线程与并发编程总结.doc
04-14
Java多线程与并发编程是Java开发中至关重要的一部分，它涉及到如何高效地利用CPU资源，以实现程序的并行执行。在操作系统层面，多任务和多进程是通过分配不同的内存空间来实现的，而线程则共享同一进程的内存，这...
JAVA多线程高并发学习
Fuly的博客
06-14 9236
工欲善其事，必先利其器 postman 可作为一个简单的并发测试 JMeter相比于postman更加强大 JMeter入门: https://www.jianshu.com/p/0e4daecc8122 线程安全性: 定义:当多个线程访问某个类时,不管采用任何调度方式,不需要额外的同步或者协调,这个类都能表现出正确的结果,这个类就成为是线程安全的 线程安全性主要体现在 原子性: 互斥访问,同一时...
java 并发同步_Java中同步与并发用法分析
weixin_39573981的博客
02-15 77
本文较为详细的分析了Java中同步与并发的用法。分享给大家供大家参考。具体分析如下：1.同步容器类包括两部分：vector和hashtable另一类是同步包装类，由Collections.synchronizedXXX创建。同步容器对容器的所有状态进行串行访问，从而实现线程安全。它们存在如下问题：a) 对于符合操作，需要额外的锁保护。比如迭代，缺少则添加等条件运算。b) toString，hash...
web开发中的两把锁之数据库锁：（高并发--乐观锁、悲观锁）
dawuafang
06-09 2040
这篇文章讲了 1.同步异步概念（消去很多疑惑），同步就是一件事一件事的做；sychronized就是保证线程一个一个的执行。 2.我们需要明白，锁机制有两个层面，一种是代码层次上的，如java中的同步锁，典型的就是同步关键字synchronized（ 线 程级别的）。另一个就是数据库层次上的，比较典型的就是悲观锁和乐观锁。 3.常见并发同步案例分析 附原文...
多线程学习总结（二）：同步与并发
weixin_42882828的博客
08-14 240
多线程学习总结（二）：同步与并发 最近看了《Java编程多线程核心技术》这本书，在此接着上一篇继续总结以下知识点： 线程安全问题的产生 synchronized关键字的用法 volatile关键字的用法 原子类的用法 线程停止与暂停 守护线程 1.线程安全问题的产生 举个简单的例子 public void test(){ Runnable t= new Run...
关于Synchronized涉及到多线程并发操作的处理
a872822645的博客
06-14 1182
首先根据网上demo  定义了Synchronized 的代码块。基础类如下：/** * @author sunlei * @create 2018/6/14 * @Describe */ public class SynchThread implements Runnable{ private final int i=0; private static int cou...
Java多线程并发协同
周先生丶的博客
08-02 7959
Java并发相关技术：线程池、线程安全（锁）、多线程并发协同、并发集合类、原子类。 什么是并发协同？ 多个线程并发，协同来完成一件事情的过程中，因事情处理的需要，需控制某些线程阻塞，等待另一些线程完成某部分事情，再继续执行的过程。 并发协同原理： 分析并发协同问题的常用思路 并发的是什么？ 在什么地方需要协同？ 该谁等待？谁来通知？ 并发协同的实现方式 多线程协同执行都基于条...
面试中多线程并发处理方式？
黄钟飞的博客
05-21 5300
1.首先我们要搞清楚什么是并发 什么是并行? 概念：在单CPU系统中，系统调度在某一时刻只能让一个线程运行，虽然这种调试机制有多种形式(大多数是时间片轮巡为主)，但无论如何，要通过不断切换需要运行的线程让其运行的方式就叫并发(concurrent)。而在多CPU系统中，可以让两个以上的线程同时运行，这种可以同时让两个以上线程同时运行的方式叫做并行(parallel)。简单讲在某一个时间中，一...
Java的线程同步 & 并发操作
萨达哈鲁的博客
07-21 3831
并发：CUP在同一时间或同一时段内只能执行一件事情，而不同时件执行时，切换得十分快速，因为CUP的频率非常高，切换的速度人根本感受不出来。 同步：同步是多个任务进行时，按照一定的规律进行着。 线程并发：同一时间间隔中，有多个线程在同时执行，就是线程的并发。线程可能互相有逻辑影响，所以要进行控制，进行控制和协调就是线程的同步。 系统采用多线程并发
并发处理同一个订单问题
qq_34254462的博客
05-23 433
当存在并发对同一个订单都做更想操作时，怎么才能保证各自的线程有效的执行呢？ 采用悲观锁处理方式：@Lock(LockModeType.PESSIMISTIC_WRITE) AreaPO.java @Data @EqualsAndHashCode() @Accessors(chain = true) @Entity @Table(name = "AREA_INFO") public class AreaInfoPO { /** * 区域主键 */ @Id @Co

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值