【JAVA并发编程-黑马】第二章

最新推荐文章于 2024-03-18 15:01:47 发布
最新推荐文章于 2024-03-18 15:01:47 发布
阅读量384 收藏 1
点赞数 1
分类专栏： 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37023928/article/details/106204242
版权

一、买票案例

1.1线程不安全方式

package com.learning.concurrent;

/**
 * ClassName:TicketWindow
 * Package:com.learning.concurrent
 * Desciption:
 *
 * @date:2020/5/18 22:33
 * @author:
 */
public class TicketWindow {

    private int tickets;
    public TicketWindow(int tickets) {
        this.tickets = tickets;
    }

    public void sell (int sells) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (tickets - sells >=0) {
            tickets = tickets -sells;
        }
    }


    public int getTickets() {
        return tickets;
    }
}


import java.util.ArrayList;
import java.util.List;
import java.util.Vector;

/**
 * ClassName:SellTicketTest
 * Package:com.learning.concurrent
 * Desciption:
 *
 * @date:2020/5/18 22:38
 * @author:17611219021@sina.cn
 */
@Slf4j
public class SellTicketTest {


    public static void main(String[] args) throws Exception{
        //模拟多人买票窗口
        TicketWindow window=new TicketWindow(60000);
        //线程集合
        List<Thread> threadList = new ArrayList<Thread>();
        //统计一共卖出了多少张票
        Vector<Integer> sellCounts = new Vector<>();

        long start = System.currentTimeMillis();
        log.info("开始时间:{}",start);

        for (int i=0 ;i<1000; i++) {
            Thread t =new Thread(() ->{
                window.sell(6);
                sellCounts.add(6);

            });
            threadList.add(t);
            t.start();
        }

        //等待所有买票线程跑完，再执行main线程中的方法
        for ( Thread t: threadList) {
            t.join();
        }
        long end = System.currentTimeMillis();
        log.info("结束时间：{}",end);
        log.info("耗时：{}",end - start);
        log.info("卖出的票：{}",sellCounts.stream().mapToInt(i -> i).sum());
        log.info("剩余的票：{}",window.getTickets());

    }
}

执行结果：

23:34:30.523 [main] INFO com.learning.concurrent.SellTicketTest - 开始时间:1589816070521
23:34:31.612 [main] INFO com.learning.concurrent.SellTicketTest - 结束时间：1589816071612
23:34:31.612 [main] INFO com.learning.concurrent.SellTicketTest - 耗时：1091
23:34:31.615 [main] INFO com.learning.concurrent.SellTicketTest - 卖出的票：6000
23:34:31.615 [main] INFO com.learning.concurrent.SellTicketTest - 剩余的票：54582

线程不安全，因为票数加起来不等于60000.

1.2线程安全方式

package com.learning.concurrent;

/**
 * ClassName:TicketWindow
 * Package:com.learning.concurrent
 * Desciption:
 *
 * @date:2020/5/18 22:33
 * @author:
 */
public class TicketWindow {

    private int tickets;
    public TicketWindow(int tickets) {
        this.tickets = tickets;
    }

    public synchronized void sell (int sells) {
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (tickets - sells >=0) {
            tickets = tickets -sells;
        }
    }


    public int getTickets() {
        return tickets;
    }
}

这里在买票窗口中添加了synchronized ，并且休眠时间调成了10毫秒，执行结果如下：

23:38:35.179 [main] INFO com.learning.concurrent.SellTicketTest - 开始时间:1589816315178
23:38:45.940 [main] INFO com.learning.concurrent.SellTicketTest - 结束时间：1589816325940
23:38:45.940 [main] INFO com.learning.concurrent.SellTicketTest - 耗时：10762
23:38:45.944 [main] INFO com.learning.concurrent.SellTicketTest - 卖出的票：6000
23:38:45.944 [main] INFO com.learning.concurrent.SellTicketTest - 剩余的票：54000

重要结论：
这个是线程安全的，因为卖出的票+剩余的票等于60000.但是观察两种结果，第一种结果我睡眠1000毫秒，大约花了1秒时间执行完成，第二种结果我睡眠了仅仅10毫秒，却花了10s的时间执行完成，想象一下，当第1001个人来买票的时候，花了10s钟才进行响应，多可怕，如果10000个人同时访问呢？花费100s吗？这个太可怕了。

二、转账案例

2.1线程不安全的方式

package com.learning.concurrent;

import lombok.extern.slf4j.Slf4j;

import java.util.Random;

@Slf4j(topic = "c.ExerciseTransfer")
public class ExerciseTransfer {
    public static void main(String[] args) throws InterruptedException {
        Account a = new Account(1000);
        Account b = new Account(1000);
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                a.transfer(b, randomAmount());
            }
        }, "t1");
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                b.transfer(a, randomAmount());
            }
        }, "t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        // 查看转账2000次后的总金额
        log.debug("total:{}", (a.getMoney() + b.getMoney()));
    }

    // Random 为线程安全
    static Random random = new Random();

    // 随机 1~100
    public static int randomAmount() {
        return random.nextInt(100) + 1;
    }
}

// 账户
class Account {
    private int money;

    public Account(int money) {
        this.money = money;
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    // 转账
    public void transfer(Account target, int amount) {
        if (this.money >= amount) {
            this.setMoney(this.getMoney() - amount);
            target.setMoney(target.getMoney() + amount);
        }
    }
}

输出结果：

21:47:00.784 [main] DEBUG c.ExerciseTransfer - total:55

2.2线程安全的方式

上面的方式，共享变量有两个，一个是A账户的余额，一个是B账户的余额，如果说单纯的加synchronized关键字是不起作用的，因为只能锁住A对象或者B对象，而我们应该需要锁住A和B账户共享的对象即可解决，即锁住账户的class文件：

package com.learning.concurrent;

import lombok.extern.slf4j.Slf4j;

import java.util.Random;

@Slf4j(topic = "c.ExerciseTransfer")
public class ExerciseTransfer {
    public static void main(String[] args) throws InterruptedException {
        Account a = new Account(1000);
        Account b = new Account(1000);
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                a.transfer(b, randomAmount());
            }
        }, "t1");
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                b.transfer(a, randomAmount());
            }
        }, "t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        // 查看转账2000次后的总金额
        log.debug("total:{}", (a.getMoney() + b.getMoney()));
    }

    // Random 为线程安全
    static Random random = new Random();

    // 随机 1~100
    public static int randomAmount() {
        return random.nextInt(100) + 1;
    }
}

// 账户
class Account {
    private int money;

    public Account(int money) {
        this.money = money;
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    // 转账
    public void transfer(Account target, int amount) {
        synchronized(Account.class) {
            if (this.money >= amount) {
                this.setMoney(this.getMoney() - amount);
                target.setMoney(target.getMoney() + amount);
            }
        }
    }
}

输出结果：

21:47:42.392 [main] DEBUG c.ExerciseTransfer - total:2000

三、JAVA对象头

也可以参考 https://blog.csdn.net/SCDN_CP/article/details/86491792
以32位的虚拟机为例：
8个字节，其中4个字节是Mark Word。
普通对象：
在这里插入图片描述
数组对象：
在这里插入图片描述
其中Mark Word的结构为：
在这里插入图片描述
64位虚拟机的Mark Word：
在这里插入图片描述

四、Monitor原理

Monitor 被翻译为监视器或管程

Monitor是操作系统提供的对象

每个 Java 对象都可以关联一个 Monitor 对象，如果使用 synchronized 给对象上锁（重量级）之后，该对象头的Mark Word 中就被设置指向 Monitor 对象的指针

Monitor 结构如下：
在这里插入图片描述

  • 刚开始 Monitor 中 Owner 为 null
  • 当 Thread-2 执行 synchronized(obj) 就会将 Monitor 的所有者 Owner 置为 Thread-2，Monitor中只能有一
    个 Owner
  • 在 Thread-2 上锁的过程中，如果 Thread-3，Thread-4，Thread-5 也来执行 synchronized(obj)，就会进入
    EntryList BLOCKED
  • Thread-2 执行完同步代码块的内容，然后唤醒 EntryList 中等待的线程来竞争锁，竞争的时是非公平的
  • 图中 WaitSet 中的 Thread-0，Thread-1 是之前获得过锁，但条件不满足进入 WAITING 状态的线程，后面讲
    wait-notify 时会分析

注意：
synchronized 必须是进入同一个对象的 monitor 才有上述的效果
不加 synchronized 的对象不会关联监视器，不遵从以上规则

沉淀技术这十年
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java学习笔记——并发编程（二）
l903445981的博客
07-28 224
Monitor被翻译为监视器或管程 每个Java对象都可以关联一个Monitor对象，如果使用synchronized给对象上锁(重量级)之后，该对象头的Mark Word中就被设置指向Monitor对象的指针 原理之synchronized，轻量级锁，偏向锁，膨胀锁...
黑马程序员——第二章 Java编程基础
zoutyp的专栏
05-13 408
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 1.关键字 关键字是被Java语言赋予了特殊含义的单词。 所有的关键字都由小写字母组成。 main、sizeof不是关键字。 2.标识符 Java中包、类、方法、常量、变量、接口的名字。 由字母（汉字）、数字、下划线_、$组成，不能以数字开头。 不能使用java中的关键字和保
黑马程序员–Java多线程讲解笔记
12-22
进程：正在进行中的程序。 每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。 　　线程：是进程中一个执行单元或执行情景或执行路径负责进程中程序执行的控制单元 。一个进程中至少要有一个线程。当一个进程中线程有多个时，是多线程。 　　为什么要用多线程 　　1，让计算机"同时"做多件事情，节约时间。 　　2，后台运行程序，提高程序的运行效率.。 　　3，多线程可以让程序"同时"处理多个事情。 　　4，计算机CPU大部分时间处于空闲状态，浪费了CPU资源。 　　1.创建线程的两种方式： 　　方式一步骤：继承Thread类 　　子类覆盖父类中的
2021黑马程序员java面试宝典笔记二（并发篇）
qq_461491877的博客
02-17 453
二、并发篇 1. 线程状态 要求 掌握 Java 线程六种状态 掌握 Java 线程状态转换 能理解五种状态与六种状态两种说法的区别 六种状态及转换 分别是 新建 当一个线程对象被创建，但还未调用 start 方法时处于新建状态 此时未与操作系统底层线程关联 可运行 调用了 start 方法，就会由新建进入可运行 此时与底层线程关联，由操作系统调度执行 终结 线程内代码已经执行完毕，由可运行进入终结 此时会取消与底层线程关联 阻塞 当获取锁失败后，由可运行进入 Monitor 的
黑马程序员——javase进阶——day09——线程安全,死锁,状态,通讯,线程池
qq_56444564的博客
03-18 902
死锁是一种少见的，而且难于调试的错误，在两个线程对两个同步锁对象具有循环依赖时，就会大概率的出现死锁。我们要避免死锁的产生。否则一旦死锁，除了重启没有其他办法的其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。
黑马程序员Java面试专题（2）|并发编程篇（1）线程基础
YOYU_的博客
02-26 1025
指路👉黑马程序员Java面试专题（1）|常见集合篇（1）ArrayList&LinkedList-CSDN博客黑马程序员Java面试专题（1）|常见集合篇（2）HashMap-CSDN博客。
黑马程序员-多线程（线程的安全问题与锁的理解）
梁剑的专栏
10-30 1059
---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------   多线程的安全问题 多线程出现安全问题的根源： 多个线程共享同一个资源，并且同时在操作该资源，操作该资源的代码有多句 卖票的代码中 run() {          System.out.println(“卖
Java并发编程-3.pdf
05-28
Java并发编程中的多线程协作机制 在 Java 并发编程中，多线程协作机制是非常重要的一部分。多线程协作机制是指在多线程编程中，多个线程之间如何协作、同步和通信，以达到共同完成某个任务的目的。Java 提供了多种...
JAVA并发编程-2-线程并发工具类
01-20
JAVA并发编程-2-线程并发工具类一、Fork/Join1、分而治之与工作密取2、使用标准范式3、Fork/Join的同步用法4、Fork/Join的异步用法二、CountDownLatch三、CyclicBarrier四、Semaphore信号量五、Exchanger 上一章：看...
Java并发编程-Doug Lea
10-08
Java并发编程原汁原味英文版,Doug Lea大神经典著作, 内容:Concurrency Models, design forces, Java Designing objects for concurrency Immutability, locking, state dependence, containment, splitting ...
java并发编程-超级大全整理
10-19
【Java 并发编程-超级大全整理】 Java 并发编程是Java开发中不可或缺的一部分，尤其是在高并发场景下，能够有效提升程序的运行效率。本文将深入探讨Java多线程的相关知识点，帮助开发者理解并掌握如何在Java环境中...
62-Java并发编程实战
10-10
62-Java并发编程实战62-Java并发编程实战62-Java并发编程实战62-Java并发编程实战62-Java并发编程实战62-Java并发编程实战62-Java并发编程实战62-Java并发编程实战62-Java并发编程实战62-Java并发编程实战62-Java...
JAVA多线程(二)Java多线程之火车票
yuan_xw的专栏
12-27 1387
1. Java多线程实现简单的火车售票程序   需求如下：铁道部发布了一个售票任务，要求销售10张票，要求有4个窗口来进行销售，请编写多线程程序来模拟这个效果 第001窗口，正在售票，票号：1 第004窗口，正在售票，票号：2 第002窗口，正在售票，票号：3 第003窗口，正在售票，票号：4 1.1 继承Thread类多线程进行售票 继承Thread类的方式创建多线程进行售票的方式，在不加锁...
黑马JAVA并发编程,JUC并发编程全套教程学习笔记02
Blesser12138的博客
03-14 1922
进程，线程；并行，并发；多线程应用
黑马程序员并发编程笔记(一)
abaidaye的博客
01-21 2574
1.聊聊线程和进程 1.1.进程和线程的概念 什么是进程？ 可以理解为，进程就是存储在静态资源（磁盘）里的程序（指令和数据）运行时的一种状态，通俗的理解，进程就是运行时的程序。 注释：程序由数据和指令组成，这些指令要读写，就必须把指令加载到cpu，数据加载到内存 。进程就是来加载指令，管理内存，管理io的 注意：内存一般指的是运行内存，因为小时候不准确的概念，我们常常将内存和磁盘存储相关联，但二者不相同。 当一个程序被调用时，它就作为一个进程，从磁盘加载到内存之中。一个程序可以有多个进程（记事本）也
Java多线程学习2
jacknoe的博客
08-20 181
java多线程学习
java 并发编程 (上) 超详细笔记 从入门到深入原理
weixin_53142722的博客
05-04 974
Java并发编程笔记入门到深入 （超详细） 进程和线程，上下文，异步和同步，创建线程的方式，线程状态， sleep和yield，synchronized，start和run的区别， 线程的一些运行原理
员工关怀实施提案.pptx
最新发布
08-07
员工关怀实施提案.pptx
Java并发编程实践基础-第一章详解
"Java并发编程实践-电子书-01章" 在Java并发编程实践中，了解进程与线程的基础知识至关重要。进程是操作系统中运行的实体，它代表了资源的分配单位，而线程则是在一个进程中执行的独立的控制流，是CPU调度的基本...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值