多线程复习——B站

最新推荐文章于 2022-12-04 20:42:12 发布
最新推荐文章于 2022-12-04 20:42:12 发布
阅读量116 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiapi3/article/details/109699453
版权

目录


程序：指令的集合，是静态的
进程：程序执行后的动态行式，是系统分配资源的基本单元
线程：一个进程至少有一个线程，是CPU调度执行的基本单位

多线程：真多线程是指多个CPU同时服务（并行），伪多线程是指一个CPU的多次切换模拟出的效果（并发）

线程创建

三种方法：

  1. 继承Thread类
  2. 实现Runnable接口
  3. 实现Callable接口

其实：Thread类相当于Runnable接口的静态代理，将Runnable接口的实现类传入，然后生成代理对象，去做一些事情，事情怎么做就在start函数中。

继承Thread类

步骤：继承Thread–重写run–调用start方法
该方式过于简单，懒得写过程了
注意：线程执行顺序，无法确定！

实现Runnable接口

步骤：实现Runable–new Thread(实现类)–调用new出来的对象的start方法
该方式过于简单，懒得写过程了
注意：推荐使用该方法，可以避免单继承，同时方便同一个对象创建多个线程
由此产生一个问题：线程不安全。
线程不安全是因为多个线程操作同一个资源导致的。

线程之间的资源共享
静态变量：由于是类所有的，存在于方法区，所有该类实例都能看到该变量，都可以修改，所以线程不安全
实例变量：如果多线程共享一个实例则等同于静态变量的情况，线程不安全。如果每个线程都有一个类的实例，则实例变量互相隔离，线程安全
局部变量：局部变量是线程安全的

实现Callable接口

步骤：★★★

  1. 实现Callable接口，带上返回值
  2. 重写call方法，需要抛出异常
  3. 创建目标对象
  4. 开启服务
  5. 提交执行
  6. 获取结果
  7. 关闭服务

参考demo

public class Demo01 implements Callable<Integer> {
    private int num;

    @Override
    public Integer call() throws Exception {
        int x;
        while(6 != (x=(int)(Math.random()*10))){
            num++;
//            System.out.println(Thread.currentThread().getId()+":running,x="+x);
        }
        return num+1;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 创建实例
        Demo01 d1 = new Demo01();
        Demo01 d2 = new Demo01();
        Demo01 d3 = new Demo01();
        // 创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        Future<Integer> f1 = executorService.submit(d1);
        Future<Integer> f2 = executorService.submit(d2);
        Future<Integer> f3 = executorService.submit(d3);
        // 获取值
        Integer r1 = f1.get();
        Integer r2 = f2.get();
        Integer r3 = f3.get();
        //关闭线程池
        executorService.shutdown();

        System.out.println("r1="+r1+",r2="+r2+",r3="+r3);
    }
}

Lambda表达式

避免匿名内部类定义过多，属于函数式编程

函数式接口

定义：任何接口，如果只包含一个方法且为抽象方法，那他就是函数式接口（Functional Interface，Java8）

public interface Abc(){
	public abstract void go()
}

对于函数式接口，可以用lambda创建该接口对象

Abc abc = ()->{//实现};
abc.go();

注意：如果带参数：单参数可以不写参数括号。实现语句如果是一句，可以不写花括号。入参类型可以省略。

线程状态

在这里插入图片描述
注意点：就绪和运行状态是可以互相转化的取决于【CPU资源是否释放和获得】，线程一旦结束不能再被启动！
线程常用方法：
在这里插入图片描述

线程停止

注意：不推荐JDK提供的线程停止方法：stop、destory，推荐使用自定义标志位来作为停止的标识
在这里插入图片描述

线程休眠

sleep：

  1. 参数是毫秒数
  2. 会抛出InterruptedException
  3. 结束后恢复就绪状态
  4. 不释放锁！！

线程礼让

让线程暂停，直接回到就绪状态，不会释放锁！！

Join插队

thread.join的含义是当前线程需要等待previousThread线程终止之后才从thread.join返回。简单来说，就是线程没有执行完之前，会一直阻塞在join方法处。
在这里插入图片描述

线程状态

Thread.State

  1. NEW状态：没有启动的线程
  2. RUNNABLE：运行态
  3. BLOCKED：阻塞态
  4. WATING：等待另一个线程执行工作
  5. TIMED_WATING：等待另一个线程执行工作到指定时间
  6. TERMINATED：退出的线程

线程优先级

Java提供给线程调度器来使用，优先调用优先级高的，但是否一定会调用是不确定的。主线程优先级是默认的5
优先级范围：1-10
其中：
Thread.MIN_PRIORITY=1
Thread.MAX_PRIORITY=10
Thread.NORM_PRIORITY=5

使用方法：getPriority() setPriority(int xx)
注意：优先级超过1-10范围会报错，优先级设置不能超过当前线程所属组的最大线程优先级
如果对于性能要求比较高则可以设置线程优先级防止出现性能倒置。

守护线程Daemon

我们创建的线程都是用户线程，除非设置了为守护线程
thread.setDaemon(true)必须要在start前设置

在Java中有两类线程：User Thread(用户线程)、Daemon Thread(守护线程)

用个比较通俗的比如，任何一个守护线程都是整个JVM中所有非守护线程的保姆：
只要当前JVM实例中尚存在任何一个非守护线程没有结束，守护线程就全部工作；只有当最后一个非守护线程结束时，守护线程随着JVM一同结束工作。
Daemon的作用是为其他线程的运行提供便利服务，守护线程最典型的应用就是 GC (垃圾回收器)，它就是一个很称职的守护者。

User和Daemon两者几乎没有区别，唯一的不同之处就在于虚拟机的离开：如果 User Thread已经全部退出运行了，只剩下Daemon Thread存在了，虚拟机也就退出了。 因为没有了被守护者，Daemon也就没有工作可做了，也就没有继续运行程序的必要了。

线程同步

队列+锁：

  • 一个线程持有锁，会导致其他想要该锁的线程挂起
  • 多线程下，加锁和释放锁会产生性能开销
  • 高优先级线程等待低优先级线程释放锁会导致性能倒置

同步方法：在方法上加sychronized关键字，同时只能有一个线程在该方法内执行：pubic synchronized void a(){}
同步代码块：在代码块上加锁：synchronized(obj){}

一般而言，只在需要修改的部分加锁，防止性能浪费

同步方法

在方法上加锁，锁的是调用该方法的对象，this

同步块

同步块锁定的是一个对象，该对象称为同步监视器，推荐使用共享资源对象作为锁，比如要修改的那个对象。

JUC

java util concurrent 并发包，专门用来做并发编程的
CopyOnWriteArrayList 线程安全的ArrayList，使用volatile和transient来修饰，限制了内存可见性和指令重排

死锁

多个线程各子占有一部分资源（锁）又等待去占有其他资源（锁）时，容易出现，通俗点讲就是，想同时占有多个锁
解决方法：获取对方线程可能占有的锁时，释放掉自己的锁
在这里插入图片描述

Lock锁

JDK5开始，显示定义同步锁对象，使用Lock对象充当，JUC下的包，用于控制多个线程对共享资源进行访问

Lock是一个接口，ReentrantLock是其一个实现类，可重入锁
使用示例：

package com.xiaopi3;

import java.util.concurrent.locks.ReentrantLock;

public class Demo01 {
    public static void main(String[] args) {
        Test t = new Test();
        new Thread(t).start();
        new Thread(t).start();
    }
}

class Test implements Runnable{

    private int num=10;
    /**
     * static 保证new多个对象时，锁只有一份
     * final 保证该锁不会被重新赋值
     */
    private static final ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {

        while(true){
        	// 一定要在判断前加锁，要不然会出现同时判断成功的错误 
            lock.lock();
            if(num>=0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getId()+" : "+num--);
            }else{
            	lock.unlock();
                break;
            }
            lock.unlock();
        }
    }
}

注意：一般而言，lock.unlock()在try catch中需要写在finally中，也可以直接try finally中写unlock！（推荐）

Lock和synchronized区别

  1. 前者显示锁后者隐式锁
  2. 前者只能锁代码块，后者还可以锁方法
  3. 前者调度线程消耗少于后者，扩展性高
  4. 建议：Lock>同步代码块>同步方法

线程通信

明确一个模型：生产者和消费者模型，两条线程进行通信
解决方式一：管程法
生产者：产出产品到缓冲区，缓冲区满则停产，不满则生产
消费者：从缓冲区消费，缓冲区空则停止，不空则消费
线程通信的方法：wait和notify
示例：

package com.xiaopi3;

public class Demo {
    public static void main(String[] args) {
        MyPool myPool = new MyPool();
        new Producer(myPool).start();
        new Consumer(myPool).start();
    }
}
class MyPool{
    private int[] pool = new int[10];
    private int num=0;
    public synchronized void push(int x){
        System.out.println("生产");
        if(num==pool.length){
            try {
                System.out.println("仓库满了，等待消费！");
                wait();// 等待并释放MyPool的push上的锁
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else{
            num++;
            System.out.println("存入，当前存量为："+num);
            notifyAll();// 通知所有在MyPool的push上等待锁的线程
        }
    }
    public synchronized void pop(){
        System.out.println("消费");
        if(num==0){
            try {
                System.out.println("仓库空了，等待生产！");
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else{
            num--;
            System.out.println("取出，当前存量："+num);
            notifyAll();
        }
    }
}
class Producer extends Thread{
    private MyPool myPool;
    public Producer(MyPool o){
        this.myPool=o;
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            myPool.push(i);
        }
    }
}
class Consumer extends Thread{
    private MyPool myPool;
    public Consumer(MyPool o){
        this.myPool=o;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            myPool.pop();
        }
    }
}

解决方式二：信号灯法
生产者和消费者通过标志位来判断是否生产或者消费，原理是（借助第三方中介来作为判断人），信号灯法适用于生产者产出1个消费者消费1个的情况。

这里讲一下思路：第三方负责生产和消费的具体实现，生产者负责调用第三方生产方法，消费者负责调用第三方消费方法，第三方设置了标志位，生产还是消费取决于标志位。

线程池

JDK5提供了线程池相关接口
在这里插入图片描述
Executors：线程池工具类

public class Demo {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        Test test = new Test();
        executorService.execute(test);
        executorService.execute(test);
        executorService.execute(test);
        executorService.shutdown();
    }
}
class Test implements Runnable{
    @Override
    public void run() {
        System.out.println("123");
    }
}
天落枫
关注
专栏目录
python封装dll能不能突破线程锁_python中的线程锁
weixin_35319943的博客
01-13 138
from threading importThread,Lockimportrandom#锁的作用#arr = []###原始锁处于 "锁定" 或者 "非锁定" 两种状态之一。它被创建时为非锁定状态。它有两个基本方法， acquire() 和 release() 。当状态为非锁定时， acquire() 将状态改为 锁定 并立即返回。当状态是锁定时， acquire() 将阻塞至其他线程调用 re...
史上最全的C++面试宝典（九）—— 多线程
热门推荐
编程之路
08-11 1万+
参考：https://www.runoob.com/cplusplus/cpp-tutorial.html 本教程旨在提取最精炼、实用的C++面试知识点，供读者快速学习及本人查阅复习所用。 第一章 C++基本语法 C++ 程序可以定义为对象的集合，这些对象通过调用彼此的方法进行交互。 对象 -对象具有状态和行为。例如：一只狗的状态 - 颜色、名称、品种，行为 - 摇动、叫唤、吃。 类 -类可以定义为描述对象行为/状态的模板，对象是类的实例。 方法 -从基本上说，一个方法表示一种行为。一...
dll中线程死锁的问题（收集的文章，资料)
bsnry的专栏
02-20 461
http://bbs.csdn.net/topics/390262373 http://blog.csdn.net/breaksoftware/article/details/8142203
Java复习——多线程
zhangzhang_one的博客
06-04 385
Java多线程和四种线程实现方式
Java多线程下——各类锁的详解
weixin_45696320的博客
08-26 3076
假设男主是一个锁, 女主是一个线程. 如果只有这一个线程来使用这个锁, 那么男主女主即使不领证结婚(避免了高成本操作), 也可以一直幸福的生活下去.但是,但是，但是，女配出现了, 也尝试竞争男主, 此时不管领证结婚这个操作成本多高, 女主也势必要把这个动作完成了, 让女配死心.比如一个递归函数里有加锁操作，递归过程中这个锁会阻塞自己吗？实际开发过程中, 使用细粒度锁, 是期望释放锁的时候其他线程能使用锁,但是实际上可能并没有其他线程来抢占这个锁. 这种情况 JVM 就会自动把锁粗化, 避免频繁申请释放锁..
P1 线程简介——多线程详解（B站狂神说）
weixin_43660497的博客
09-29 365
多线程秋招真的很常问，自己看B站视频笼统的过了一遍复习。 这个老师讲的想对比较适合初学，高阶建议啃书。???? 记了一些笔记写成博客分享出来。???? 在这推荐up主：狂神说。???? 指路b站视频链接： https://www.bilibili.com/video/BV1V4411p7EF/ 多线程 Java.Thread P1、线程简介 P2、线程创建 P3、线程状态 P4、线程同步 P5、线程通信问题 P6、线程池 P1 线程简介 1.基本概念 多任务：   看起来多个任务在做，本质大脑在同一时
Java复习六——多线程
张毅轩的博客
01-19 576
首先了解一下什么是进程和线程 我们在windows上经常使用各类软件，举个最简单的例子，我们运行一个word软件，这时候系统就为word分配了一个进程，而当我们在打字的时候word会进行自动拼写检查，这个拼写检查程序就相当于一个线程。线程实际上就是在进程的基础上进一步划分，如果一个进程没有了，则线程就会消失，但是进程未必会消失，而且所有的线程都是在进程的基础上同时运行。 一、进程与线程 进程...
java多线程基础——阻塞式队列
weixin_60778429的博客
07-28 594
比如我们看这张图，A负责从网络上获取数据传输给B，网络上有大量的数据，但由于A不负责数据处理所以影响不大，但是B要负责数据处理，A不断将海量数据传输给B，而B负责数据处理，计算压力非常大。擀饺子皮的人不关心包饺子的人是谁(能包就行,无论是手工包,借助工具,还是机器包),包饺子的人也不关心擀饺子皮的人是谁(有饺子皮就行,无论是用擀面杖擀的,还是拿罐头瓶擀,还是直接从超市买的)此时即使A依然在传输海量数据，但是多出来的压力由阻塞队列分担了，B就可以根据自己的频率来处理数据，这样就。...
面试复习————JAVA多线程与并发
qq_41398448的博客
09-22 345
进程和线程的区别 进程和线程的由来 进程是资源分配的最小单位，线程是CPU调度的最小单位 1.所有与进程相关的资源，都被记录在PCB中（Process Control Block 进程管理块） 2.进程是抢占处理机的调度单位，线程属于某个进程，共享其资源 3.线程只由相关堆栈寄存器，程序计数器和TCB组成 总结 1.线程不能看做独立应用，而进程可以看做独立应用 2.进程...
Java多线程知识复习记录
qq_30836691的博客
11-03 169
Java多线程知识复习记录 概念介绍 进程 进程是计算机中的程序关于某数据集合上的依次运行活动，即一段程序的执行过程。拥有独立的代码和数据空间（进程上下文），进程间的切换会有比较大的开销，进程是资源分配的最小单位。 线程 线程是进程的一个执行单元，也是进程内可调度的实体。同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器（PC），线程间切换开销小，线程是CPU调度的最小单位。 协程 是一种用户态的轻量级线程，协程的调度由用户控制，协程拥有自己的寄存器上下文和栈。协程调度切换时，
斗图斗不过小伙伴？python多线程爬取斗图网表情包，助你成为斗图帝！
01-20
于是来试试多线程爬虫，正好复习一下mooc上自学的嵩天男神的爬虫知识。想法很美好，过程却很心酸，从早上开始写，每次出现各种奇怪问题，到现在晚上了终于是搞好啦。害得我连晚上的课都没有听，不过最后看着文件夹中...
多线程复习——进程线程（上）
最新发布
qq_59539549的博客
12-04 656
目录一、进程是啥?跑起来的程序二、进程是怎么管理的?描述+组织三、进程的PCB里有啥?四、进程的调度是咋进行?时间管理大师五、进程的独立性是咋回事?六、进程之间如何通信?一个进程要想跑起来，我们就得给其分配内存和各种资源PCB其中的属性？例如 现有12块时间. 最喜欢 B ,就给 B 分配了 7块时间 其次最喜欢 C , 就给 C 分配了 4块时间 最不喜欢 A ,就给 A 分配了 1块时间这样就优先给 B 其次是 C 最后是 A同一个时刻我们是只能执行一个进程的（单核CPU），因此我们看起来同时执行，其实
Java基础进阶——多线程与JUC（上）
尼尧Nier的博客
06-05 949
最近在准备面试，把知识点复习一遍，整理出的笔记记录下，里面会穿插代码和面试例题。 内容不是原创，是总结和收集，并在理解的基础上进行一些完善，如果侵权了请联系作者，若有错误也请各位指正。因为收集的时候忘记把来源记录下来了，所以就不po出处了，请见谅（这是个坏习惯，一定改）。 Java基础进阶——JUC多线程多线程 这是面试复习内容的第十三篇——多线程，主要是Java基础的内容，所有内容将分为几篇来写。 多线程 ...
《Java 多线程编程核心技术》笔记——第1章 Java 多线程技能（二）
bm1998
07-08 281
文章目录1.7 停止线程1.7.1 停止不了的线程1.7.2 判断线程是否是停止状态1.7.3 能停止的线程——异常法1.7.4 在沉睡中停止1.7.5 能停止的线程——暴力停止1.7.6 方法 stop() 与 java.lang.ThreadDeath 异常1.7.7 释放锁的不良后果1.7.8 使用 return 停止线程1.8 暂停线程1.8.1 suspend 与 resume 方法的使用1.8.2 suspend 和 resume 方法的缺点——独占1.8.3 suspend 和 resume
springboot jpa批量新增、更新、删除、查询数据
xiaopi3的博客
03-03 8728
springboot jpa使用：写一个dao层，定义一个类 // PersonDao.java @Repository public interface PersonDao extends JpaRepository<PersonPO,String>, JpaSpecificationExecutor<PersonPO>{ } 在controller层注入该类，并调用即可 默认的删除方法有： delete(实体)，只能传入一个可以对应到数据库的实体，即数据库中存在一样的数据
MySQL复习——B站
xiaopi3的博客
12-06 5035
目录简介安装 简介 数据库用于存储数据，软件体系的核心 数据库分类：关系型和非关系型 关系：Mysql、Oracle、SqlServer、DB2、SQLlite 非关系：Redis、mongDB 关系型存储的是表，包含行和列 非关系型：存储对象，对象中的字段由自身的属性来决定，实时更新结构（适用于热搜等业务） DBMS：数据库管理系统 使用语言：SQL 优点：体积小、速度快、学习成本低，可做集群 安装 尽量不要使用exe，协助会有残留已经注册表问题 使用zip包安装 下载解压 配置mysql环境变量，bi
分布式服务之间的通讯-RPC实战
xiaopi3的博客
06-22 1153
分布式服务之间的通讯-RPC实战依据服务最佳实践分包粒度序列化实现步骤一、 定义两个服务模块二、提取共同的api模块 前提：在会议发布后，需要提供依据会议id查询发布该会议的员工信息 provider：员工信息模块 consumer：会议模块 注意：由于是两个模块的进程间通信，所以必须实现Serializable 依据服务最佳实践 http://dubbo.apache.org/zh-cn/docs/user/best-practice.html 分包 建议将服务接口、服务模型、服务异常等均放
jsp日记博客系统02
xiaopi3的博客
08-12 873
一、日志信息显示 改进：导航栏主页功能实现，在主页链接中加上：href=”main?all=true”即可 要实现日志信息显示，需要查询日志信息 改进diarydao.java，新增查询日志内容函数 查询语句为：String sql=”select * from t_diary t1,t_diaryType t2 where t1.typeId=t2.diaryTypeId and t1....
深入理解：多任务与多线程编程——线程创建
"本资源主要介绍了在C++编程中如何进行多任务和多线程操作，特别是关注于工作者线程的创建。文档来自于《C++高级编程》，详细讲解了进程与线程的概念，以及在Windows操作系统中的实现方式，包括协同多任务和抢先式多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值