深入浅出Java多线程--慕课网笔记

最新推荐文章于 2024-05-03 20:28:57 发布
最新推荐文章于 2024-05-03 20:28:57 发布
阅读量902 收藏
点赞数
分类专栏： 慕课网笔记 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/helloPurple/article/details/76599696
版权
1-2java多线程基础概念介绍
  • 进程：程序（任务）的执行过程持有资源（共享内存，共享文件）和线程

  • 线程：qq聊天、收发文件

    *线程是系统中最小的执行单元
    同一进程中有多个线程
    线程共享进程的资源*

    *线程的交互
    互斥 同步*

java中线程的常用方法介绍：
java对线程的支持
线程的创建和启动
线程常用方法
如何停止线程
java.lang

*class Thread
interface Runnable*

run()

Thread常用方法
  1. 线程的创建
    Thread()
    Thread(String name)
    Thread(Runnable target)
    Thread(Runnable target,String name)
  2. 线程的方法
    启动线程：
    start（）
    线程休眠：
    sleep(long millis)
    sleep(long millis,intnanos)
    使其他线程等待当前线程终止：
    join()
    join(long millis)
    join(long millis,int nanos)
    当前运行线程释放处理器资源：
    yield()
  3. 获取线程引用
    返回当前运行的线程引用：
    currentThread()
2-2java线程-隋唐演义框架说明
//军队线程
//模拟作战双方的行为
public class ArmRunnable implements Runnable{}
ArmRunnable armyTaskOfSuiDynasty = new ArmyRunnable();
ArmRunnable armyTaskOfarmyOfRevolt = new ArmyRunnable();
//使用Runnable接口创建线程
Thread armyOfSuiDynasty = new Thread(armyTaskOfSuiDynasty,"随军");
Thread armyOfRevolt = new Thread(armyTaskOfarmyOfRevolt,"农民起义军");
public class KeyPersonThread extends Thread{

    public KeyPersonThread(String name){
        super(name);
    }

    @Override
    public void run(){
        System.out.println(Thread.currentThread().getName()+"开始了战斗");
        for(int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+"左突右杀，攻击随军。。。");
        }

        System.out.println(Thread.currentThread().getName()+"结束战斗！");
    }   


}
/**
 * 隋唐演义大戏舞台
 */
public class Stage extends Thread{}
综上所述:

*军队：ArmyRunnble
英雄人物：KeyPersonThread
舞台：Stage*

2-3Java线程-隋唐演义实战开发–演员简介
演员

*Mr.Thread
Ms.Runnable*

public class Actor extends Thread {

    public void run(){
        System.out.println(getName()+"是一个演员！");
        int count = 0;
        boolean keepRunning = true;

        while(keepRunning){
            System.out.println(getName()+"登台演出："+ (++count));

            if(count == 100){
                keepRunning = false;
            }

            if(count%10== 0){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println(getName()+"的演出结束了！");
    }


    public static void main(String[] args){
        Thread actor = new Actor();
        actor.setName("Mr. Thread");

        actor.start();

        Thread actressThread = new Thread(new Actress(),"Ms. Runnable");
        actressThread.start();
    }

}


class Actress implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"是一个演员！");
        int count = 0;
        boolean keepRunning = true;

        while(keepRunning){
            System.out.println(Thread.currentThread().getName()+"登台演出："+ (++count));

            if(count == 100){
                keepRunning = false;
            }

            if(count%10== 0){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println(Thread.currentThread().getName()+"的演出结束了！");

    }

}
2-4Java线程-隋唐演义实战开发–军队线程
2-5Java线程-隋唐演义实战开发–关键先生
//军队线程
//模拟作战双方的行为
public class ArmyRunnable implements Runnable {

    //volatile保证了线程可以正确的读取其他线程写入的值
    //可见性 ref JMM， happens-before原则
    volatile boolean keepRunning = true;

    @Override
    public void run() {
        while(keepRunning){
            //发动5连击
            for(int i=0;i<5;i++){
                System.out.println(Thread.currentThread().getName()+"进攻对方["+i+"]");
                //让出了处理器时间，下次该谁进攻还不一定呢！
                Thread.yield();
            }

        }

        System.out.println(Thread.currentThread().getName()+"结束了战斗！");

    }

}
public class KeyPersonThread extends Thread {

    public void run(){
        System.out.println(Thread.currentThread().getName()+"开始了战斗！");
        for(int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+"左突右杀,攻击隋军...");
        }
        System.out.println(Thread.currentThread().getName()+"结束了战斗！");
    }
}
/**
 * 隋唐演义大戏舞台
 */
public class Stage extends Thread {

    public void run(){

        System.out.println("欢迎观看隋唐演义");
        //让观众们安静片刻，等待大戏上演
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
        System.out.println("大幕徐徐拉开");

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }

        System.out.println("话说隋朝末年，隋军与农民起义军杀得昏天黑地...");

        ArmyRunnable armyTaskOfSuiDynasty = new ArmyRunnable();
        ArmyRunnable armyTaskOfRevolt = new ArmyRunnable();

        //使用Runnable接口创建线程
        Thread  armyOfSuiDynasty = new Thread(armyTaskOfSuiDynasty,"隋军");
        Thread  armyOfRevolt = new Thread(armyTaskOfRevolt,"农民起义军");

        //启动线程，让军队开始作战
        armyOfSuiDynasty.start();
        armyOfRevolt.start();

        //舞台线程休眠，大家专心观看军队厮杀
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("正当双方激战正酣，半路杀出了个程咬金");

        Thread  mrCheng = new KeyPersonThread();
        mrCheng.setName("程咬金");

        System.out.println("程咬金的理想就是结束战争，使百姓安居乐业！");

        //停止军队作战
        //停止线程的方法
        armyTaskOfSuiDynasty.keepRunning = false;
        armyTaskOfRevolt.keepRunning = false;

        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        /*
         * 历史大戏留给关键人物
         */
        mrCheng.start();

        //万众瞩目，所有线程等待程先生完成历史使命
        try {
            mrCheng.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        System.out.println("战争结束，人民安居乐业，程先生实现了积极的人生梦想，为人民作出了贡献！");
        System.out.println("谢谢观看隋唐演义，再见！");

    }

    public static void main(String[] args) {
        new Stage().start();

    }

}
3-1Java线程停止的错误方法–stop
not stop()方法
戛然而止
完成了什么
那些工作还没有做
清理工作
3-2Java线程停止正确的方法–设置退出标志
 volatile boolean keepRunning = true;
3-3Java线程停止广为流传的错误方法–interrupt方法
interrupt方法初衷并不是停止线程
4-1Java线程交互之汽车人之忧：消失的能量
4-2Java线程交互之能量损失之谜：争用条件
Race Condition

*当多个线程同时共享访问同一数据（内存区域）时，每个线程都尝
试操作该数据，从而导致数据破坏（corrupted），这种现象称为争
用条件*。

4-3Java线程交互之互斥与同步：守恒的能量
/**
 * 宇宙的能量系统
 * 遵循能量守恒定律：
 * 能量不会凭空创生或消失，只会从一处转移到另一处
 */
public class EnergySystem {

    //能量盒子，能量存贮的地方
     private final double[] energyBoxes;
     private final Object lockObj = new Object();

     /**
      * 
      * @param n    能量盒子的数量
      * @param initialEnergy 每个能量盒子初始含有的能量值
      */
     public EnergySystem(int n, double initialEnergy){
         energyBoxes = new double[n];
         for (int i = 0; i < energyBoxes.length; i++)
             energyBoxes[i] = initialEnergy;
     }

     /**
      * 能量的转移，从一个盒子到另一个盒子
      * @param from 能量源
      * @param to     能量终点 
      * @param amount 能量值
      */
     public void transfer(int from, int to, double amount){

         synchronized(lockObj){

//           if (energyBoxes[from] < amount)
//               return;
            //while循环，保证条件不满足时任务都会被条件阻挡
             //而不是继续竞争CPU资源
             while (energyBoxes[from] < amount){
                 try {
                    //条件不满足, 将当前线程放入Wait Set
                    lockObj.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
             }


             System.out.print(Thread.currentThread().getName());
             energyBoxes[from] -= amount;
             System.out.printf("从%d转移%10.2f单位能量到%d", from, amount, to);
             energyBoxes[to] += amount;
             System.out.printf(" 能量总和：%10.2f%n", getTotalEnergies());
            //唤醒所有在lockObj对象上等待的线程
             lockObj.notifyAll();
         }

     }

     /**
      * 获取能量世界的能量总和 
      */
     public double getTotalEnergies(){
         double sum = 0;
         for (double amount : energyBoxes)
             sum += amount;
         return sum;
     }

     /**
      * 返回能量盒子的长度
      */
     public  int getBoxAmount(){
         return energyBoxes.length;
     }

}
public class EnergySystemTest {

    //将要构建的能量世界中能量盒子数量
    public static final int BOX_AMOUNT = 100;
    //每个盒子初始能量
    public static final double INITIAL_ENERGY = 1000;

    public static void main(String[] args){
        EnergySystem eng = new EnergySystem(BOX_AMOUNT, INITIAL_ENERGY);
        for (int i = 0; i < BOX_AMOUNT; i++){
            EnergyTransferTask task = new EnergyTransferTask(eng, i, INITIAL_ENERGY);
            Thread t = new Thread(task,"TransferThread_"+i);
            t.start();
        }
    }

}
public class EnergyTransferTask implements Runnable{

    //共享的能量世界
    private EnergySystem energySystem;
    //能量转移的源能量盒子下标
    private int fromBox;
    //单次能量转移最大单元
    private double maxAmount;
    //最大休眠时间（毫秒）
    private int DELAY = 10;

    public EnergyTransferTask(EnergySystem energySystem, int from, double max){
        this.energySystem = energySystem;
        this.fromBox = from;
        this.maxAmount = max;
    }

    public void run() {
        try{
            while (true){
                int toBox = (int) (energySystem.getBoxAmount()* Math.random());
                double amount = maxAmount * Math.random();
                energySystem.transfer(fromBox, toBox, amount);
                Thread.sleep((int) (DELAY * Math.random()));
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }

}
4-4Java线程交互之深入剖析互斥与同步
  • 互斥的实现：synchronized(intrinsic lock)

  • 同步的实现：wait()/notify()/notifyAll()

    *wait set
    critical section *

5-1总结及展望
  1. 如何创建线程及线程的基本操作
  2. 可见性及volatile关键字
  3. 争用条件
  4. 线程的互斥synchronized
  5. 线程的同步wait/notifyAll
扩展建议

  • Java Menory Model

    • MM描述了Java线程如何通过内存进行交互
    • happens-before
    • synchronized,volatile&final*

  • Locks&Condition

    • Java锁机制和等待条件的高级实现
    • java.util.concurrent.locks

  • 线程安全性

    • 原子性与可见性
    • java.util.concurrent.atomic
    • synchronized & volatile
    • DeadLocks

  • 多线程编程常用的交互模型

    • Producer-Consumer模型
    • Read-Write Lock模型
    • Future模型
    • Worker Thread模型

  • Java5中并发编程工具

    • java.util.concurrent
    • 线程池ExecutorService
    • Callable & Future
    • BlockingQueue

  • 书籍推荐

    • 《CORE JAVA》
    • 《JAVA CONCURRENCY IN PRACTICE》

深入浅出Java多线程视频

lmjun3
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
字节跳动四面技术面，顺利收获Offer
m0_57983600的博客
06-25 366
什么是 CAP CAP 定理最初是由加州大学伯克利分校的计算机科学家埃里克·布鲁尔（Eric Brewer）在 2000 年的 ACM PODC 上提出的一个猜想，也因此被叫做布鲁尔定理。后来在 2002 年，麻省理工学院的赛斯·吉尔伯特（Seth Gilbert）和南希·林奇（Nancy Lynch）发表了 CAP 定理的证明，让它成为分布式系统领域公认的一个定理。 CAP 定理指出了，在一个跨区域网络连接，共享数据的分布式系统中，一致性（Consistency），可用性（Availability）和分区
代码理解java多线程 (一) - 基础篇（1）
zzqtty的博客
04-05 265
第一章 进程与线程的基本概念 1.1 进程产生的背景 最初的计算机只能接受一些特定的指令，用户每输入一个指令，计算机就做出一个操作。当用户在思考或者输入时，计算机就在等待。这样效率非常低下，在很多时候，计算机都处在等待状态。 批处理操作系统 后来有了批处理操作系统,把一系列需要操作的指令写下来，形成一个清单，一次性交给计算机。用户将多个需要执行的程序写在磁带上，然后交由计算机去读取并逐个执行这些程序，并将输出结果写在另一个磁带上。 批处理操作系统在一定程度上提高了计算机的效率，但是由于批处理操作系
实现多线程的正确姿势（慕课网 -＞ 线程八大核心+Java并发底层原理精讲 掌握企业级并发问题解决方案）
weixin_44745208的博客
07-26 298
实现多线程的方法是1种还是2种还是4种？ 网上的说法 。。。。。。。 正确的说法 实现多线程的官方正确方法：2种 方法一：实现Runnable接口 package threadcoreknowledge.createthreads; public class RunnableStyle implements Runnable{ public static void main(String[] args) { Thread thread = new Thread(new Runna
深入浅出 Java 多线程
最新发布
2301_82257317的博客
05-03 1010
实际项目中，用的最多的就是ThreadPoolExecutor这个类，而《阿里巴巴Java开发手册》中强制线程池不允许使用 Executors 去创建，而是通过 new ThreadPoolExecutor 实例的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。我们从 ThreadPoolExecutor入手多线程创建方式，先看一下线程池创建的最全参数参数说明如下：线程池的核心线程数，即便线程池里没有任何任务，也会有corePoolSize个线程在候着等任务。
必知必会的Java多线程可算是被讲透彻了，让我们一起深入浅出多线程！
老男孩的架构路
11-27 450
Java 提供了多线程编程的内置支持，让我们可以轻松开发多线程应用。Java 中我们最为熟悉的线程就是 main 线程——主线程。一个进程可以并发多个线程，每条线程并行执行不同的任务。线程是进程的基本单位，是一个单一顺序的控制流，一个进程一直运行，直到所有的“非守护线程”都结束运行后才能结束。这里简要述说以下并发和并行的区别。并发：同一时间段内有多个任务在运行并行：同一时间点上有多个任务同时在运行多线程可以帮助我们高效地执行任务，合理利用 CPU 资源，充分地发挥多核 CPU 的性能。
字节跳动面试分享：java工程师进阶路线
m0_58590364的博客
07-07 181
二、Spring生命周期的大胆猜测 这里分享一个阅读源码的小技巧：捉大放小，连蒙带猜！8字真言，我们在阅读源码过程中，因为你要知道，每一个被开源出来的优秀框架，其源码的体系都是极其庞大复杂的，我们不能面面俱到，所以在看源码过程中一定不能被细枝末节缠住，一定要先理清楚整个框架的一个大致思想和大致的框架体系，再去搞那些细枝末节，其效率会好很多，其次在看源码过程中，我们一定要大胆的去想，去猜测，如果这个功能让你自己去写，你会怎么实现！ 我们今天学习SpringBean的生命周期也是按照这个8字真言去学习，通过我们
深入浅出Java多线程.pdf
04-09
深入浅出Java多线程
深入浅出 Java 多线程.pdf
09-15
在本文中，我们将深入浅出Java多线程编程的世界，探索多线程编程的基本概念、多线程编程的优点、多线程编程的缺点、多线程编程的应用场景、多线程编程的实现方法等内容。 一、多线程编程的基本概念 多线程编程是指...
深入浅出 Java 多线程.pdf_java_
10-03
深入了解Java多线程，对Java的复习有了一定的提供基础
Java多线程-线程间的通信
02-02
Java多线程--线程间的通信
深入浅出Java多线程.doc
06-09
深入浅出Java多线程.doc深入浅出Java多线程.doc深入浅出Java多线程.doc
深入浅出java多线程代码示例
06-29
深入浅出java多线程代码示例，由简单到复杂，代码示例，供参考学习
Java核心技术再理解——深入浅出Java多线程
Joea的专栏
02-24 1278
在程序设计语言中，线程对程序员可以说是一种又爱又恨的矛盾，一方面可以大大的简化模型，帮助程序员编写出功能强大的代码；另一方面又可能因为考虑不周全使得我们的程序出现各种大大小小的很难在开发环境中复现的BUG。 在这里笔者根据《Java核心技术》一书以及一些博文来和大家分享一下对Java多线程的理解和体会 进程与线程 在学习之前我们有必要了解什么是进程和线程。 进程 所谓的进程就
深入浅出Java多线程
weixin_34313182的博客
07-18 176
Java给多线程编程提供了内置的支持。一个多线程程序包含两个或多个能并发运行的部分。程序的每一部分都称作一个线程，并且每个线程定义了一个独立的执行路径。 多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。 这里定义和线程相关的另一个术语 - 进程：一个进程包括由操作系统分配的内存空间，包含一个或多个线程。一个线程不能独立的存在，它必须是进程的一部分。一个进程一直运行，直到所有的非守...
Java 多线程
Architect_CSDN的博客
05-20 522
1. 线程概述 1.1 线程和进程 进程是处于运行过程中的程序，并且具有一定的独立功能 并发性：同一个时刻只能有一条指令执行，但多个进程指令被快速轮换执行 并行：多条指令在多个处理器上同时执行 线程是进程的执行单元 1.2 多线程的优势 进程之间不能共享内存，但线程之间非常容易 系统创建进程时需要为该进程重新分配系统资源，但创建线程则代价小得多，因此使用多线程效率更高 Java语言内置了多线程功能 2. 线程创建与启动 2.1 继承Thread public class Firs.
300 行代码带你秒懂 Java 多线程！
好好学java
06-05 320
点击上方好好学java，选择星标公众号重磅资讯、干货，第一时间送达 今日推荐：终于放弃了单调的swagger-ui了，选择了这款神器—knife4j个人原创+1博客：点击前往...
java 多线程深入浅出的分析
行走江湖的文艺猿 的专栏
10-08 1156
多线程 synchronized lock 多线程面试题
第-章-JAVA多线程优秀文档.pptx
12-01
本资源是一份名为"第-章-JAVA多线程优秀文档.pptx"的文档，主要讲解了Java多线程的相关概念和技术。文档详细介绍了以下几个关键知识点： 1. **线程基础**： - Java中的线程是进程中的执行单元，它是进程内一个顺序...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值