随记——多线程——基础篇

最新推荐文章于 2024-02-27 11:11:42 发布
最新推荐文章于 2024-02-27 11:11:42 发布
阅读量201 收藏
点赞数
分类专栏： 多线程 随记 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dadadadak/article/details/106226483
版权
随记 同时被 3 个专栏收录
29 篇文章 0 订阅
订阅专栏
java
10 篇文章 0 订阅
订阅专栏
多线程
2 篇文章 0 订阅
订阅专栏

尚硅谷_Java零基础教程-java入门必备-初学者基从入门到精通全套完整版(宋红康主讲)
P430-P447

相关题目

  1. 画图说明线程的生命周期，以及各状态切换使用到的方法等。
  2. 同步代码块中涉及到同步监视器和共享数据，谈谈你对同步监视器和共享数据的理解，以及注意点。
  3. sleep()和wait()的区别。
  4. 写一个线程安全的懒汉式
  5. 创建多线程有哪几种方式。

文章目录

2.线程的创建

比较创建线程的两种方式：继承Thread和实现Runnable

开发中优先选择Runnable：

  1. 实现的方式没有类的单继承的局限性
  2. 实现的方式更适合来处理多个线程共享数据的情况。

问题

  1. 谈谈对程序、进程、线程的理解
    答 ：

    1. 程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即一段静态的代码，静态对象。
    2. 进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期
      程序是静态的，进程是动态的。
      进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域。
    3. 线程(Thread)，进程可进一步细分为线程，是一个程序内部的一条执行路径。
      若一个进程同一时间并行执行多个线程，就是支持多线程的。
      线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小
      一个进程中的多个线程共享相同的内存单元/内存地址空间->它们从同一堆中分配对象，可以访问相同的变量和对象。这就使线程间通信更简便、高效。但多个线程共享的系统资源可能就会带来安全隐患。

  2. 代码完成继承Thread的方式创建分线程，并遍历100以内的自然数

  3. 代码完成继承Thread的方式创建分线程，并遍历100以内的自然数

  4. 对比两种创建方式
    相同点：都需要重写run()方法。目前两种方式，要想启动线程，都是调用Thread.run()方法
    联系： public class Thread implements Runnable

  5. 对IDEA中Project和Module的理解
    Project是顶级结构
    Module可以在project下建立不同的模块

3.线程的生命周期

线程的几种状态：

  1. 新建new：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态。
    • 新建–>就绪：调用start()
  2. 就绪Runnable：处于新建状态的线程被start()之后，将进入线程队列等待CPU时间片，此时它已经具备了运行的条件，只是没分配到CPU资源
    • 就绪–>运行：获取CPU执行权
  3. 运行Running：当就绪的线程被调度并获得CPU资源时，便进入运行状态，run()方法定义了线程的操作和功能。
    • 运行–>就绪：失去CPU执行权或yeild()
    • 运行–>死亡：stop()；执行完；异常Error/Exception未处理
    • 运行–>阻塞：sleep(long t)；B.join()；等待同步锁；wait()；suspend()挂起，可能会导致死锁；
  4. 阻塞Blocking：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态
    • 阻塞–>就绪：sleep(long t)时间到；B.join()结束；获取同步锁；notify()；resume()（对应suspend）
  5. 死亡Dead：线程完成了它的全部工作或线程被提前强制性中止或出现异常导致结束。

在这里插入图片描述

4.线程的同步

问题的提出

  • 多个线程的执行的不确定性引起执行结果的不稳定性
  • 多个线程对账本的共享，会造成操作的不完整性，会破坏数据。

同步机制

方法一：同步代码块
synchronized(同步监视器){
	//需要被同步的代码
}

说明：

  1. 操作共享数据的代码，即为需要被同步的代码
  2. 共享数据：多个线程共同操作的变量
  3. 同步监视器：俗称“锁”。任何一个类的对象都可以充当锁。
    要求：多个线程必须要共用同一把锁。
方法二：同步方法
  1. 同步方法仍然涉及到同步监视器，只是不需要显式声明
  2. 非静态的同步方法，同步监视器是this；静态的同步方法，同步监视器是：当前类本身

*线程安全的懒汉式单例模式

public class BankTest {
    private static Bank instance = null;

    public static Bank getInstance() {
        //方式一：效率稍差
//        synchronized (Bank.class) {
//            if (instance==null){
//                instance=new Bank();
//            }
//            return instance;
//        }
        //方式二：效率更高
        if (instance==null){
            synchronized (Bank.class) {
                if (instance==null){
                    instance=new Bank();
                }
            }
        }
        return instance;
    }
}
class Bank{

}

死锁问题

死锁

  • 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。
  • 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续。

解决办法

  • 专门的算法、原则
  • 尽量减少同步资源 的定义
  • 尽量避免嵌套同步

Lock

  • 从JDK5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁用Lock对象充当。
  • java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
  • ReentrantLock类实现了Lock接口，它用于与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。
class Window implements Runnable{
    private ReentrantLock lock = new ReentrantLock();
    private int ticket = 100;
    @Override
    public void run() {
        while (true){
            try{
                lock.lock();

                if (ticket>0){
                    System.out.println(Thread.currentThread().getName() + "售出，票号为：" + ticket);
                    ticket--;
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else {
                    break;
                }
            }finally {
                lock.unlock();
            }

        }
    }
}
public class LockTest {

    public static void main(String[] args) {
        Window w = new Window();
        Thread t1 = new Thread(w,"窗口1");
        Thread t2 = new Thread(w,"窗口2");
        Thread t3 = new Thread(w,"窗口3");

        t1.start();
        t2.start();
        t3.start();

    }
}
synchronized与Lock的异同

同：都可以解决线程安全问题
异：

  • synchronized机制在执行完相应的同步代码之后，自动的释放同步监视器
  • Lock需要手动的启动同步（lock()），也需要手动的结束同步（unlock()）。

5.线程的通信

问题：实现线程交替打印1-100。（类似面试题，交替打印“A”“B"）

/*
交替打印1-100
 */

class Number implements Runnable{
    private int number = 1;
    public void run(){
        while (true){
            synchronized (this) {

                notify();
                if (number<=100){
                    System.out.println(Thread.currentThread().getName() + ":" + number);
                    number++;
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else {
                    break;
                }
            }
        }
    }
}

涉及到的三个方法：

  • wait()：一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器
  • notify()：一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级最高的 || 随机一个。
  • notifyAll()：一旦执行此方法，就会唤醒被wait的所有线程。

说明：

  • 这些方法必须使用在同步方法或同步代码块中。
  • 这三个方法的调用者必须是同步方法或同步代码块中的同步监视器。否则，会出现java.lang.IllegalMonitorStateException异常。
  • 这三个方法是定义在java.lang.Object类中。因为理论上同步监视器可以是任意一个类的对象，都继承object

sleep()和wait()方法的异同

  • 相同点：
    • 一旦执行方法，都可以使得当前的线程进入阻塞状态。
  • 不同点：
    • (1) 两个方法声明的位置不同：Thread类中声明sleep()，Object类中声明wait()。
    • (2) 调用的要求不同：sleep()可以在任何需要的场景下调用。wait()必须使用在同步代码块或同步方法中。
    • (3) 关于是否释放同步监视器：sleep()不会释放同步监视器；wait()会释放。

经典例题：生产者/消费者问题

描述
  • 生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品（比如：20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产。如果店中没有产品了，会通知消费者等一下；如果店中有产品了再通知消费者来取走产品。
  • 这里可能出现两个问题：
    • 生产者比消费者快时，消费者会漏掉一些数据没有取到。
    • 消费者比生产者快时，消费者会取相同的数据。
分析
  1. 是否是多线程问题：是。有生产者线程，消费者线程。
  2. 是否有共享数据：是，店员（或产品）
  3. 如何解决线程的安全问题：同步机制，三种方法。
  4. 是否涉及线程的通信：是。
实现

clerk：

package learn.concurrency.consumerAproducer2;

public class Clerk {
    private int num = 10;
    static final int MAX_NUM = 20;
    //生成产品
    public synchronized void produceProduct() {
//        notifyAll();
        if (num<MAX_NUM){
            num++;
            System.out.println(Thread.currentThread().getName() + "开始生产第" + num + "个产品.");
            notify();
        }else {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    //消费产品
    public synchronized void consumeProduct() {
        if (num>0){
            System.out.println(Thread.currentThread().getName() + "开始消费第" + num + "个产品.");
            num--;
            notify();
        }else {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

生产者：

package learn.concurrency.consumerAproducer2;

import java.util.concurrent.BlockingQueue;

public class Producer extends Thread{
    private Clerk clerk;

    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }

    public Producer(Clerk clerk, String name) {
        super(name);
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(getName() + "开始生成产品……");
        while (true){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.produceProduct();
        }
    }
}

消费者：

package learn.concurrency.consumerAproducer2;

public class Consumer extends Thread{
    private Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }
    public Consumer(Clerk clerk, String name) {
        super(name);
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(getName() + "开始消费产品……");
        while (true){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.consumeProduct();
        }
    }
}

测试Main：

package learn.concurrency.consumerAproducer2;


public class MainTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Producer p = new Producer(clerk,"生产者1");
        Consumer c = new Consumer(clerk, "消费者1");
        p.start();
        c.start();
        new Producer(clerk,"生产者2").start();
        new Producer(clerk,"生产者3").start();
    }
}

6. JDK5.0新增线程创建方式

新增方式一：实现Callable接口

  • 与使用Runnable相比，Callable功能更加强大：
    • 相比run()方法，call()方法可以有返回值。
    • 方法可以抛出异常
    • 支持泛型的返回值
    • 需要借助FutureTask类，比如获取返回结果
  • Future接口
    • 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成，获取结果等。
    • FutureTask是Future的唯一实现类
    • FutureTask同时实现了Runnable、Future接口。它既可以作为Runnable被线程执行，又可以作为Future获得Callable的返回值。
  • 实现步骤：
    • 1.实现一个Callable的实现类，将此线程需要执行的操作声明在call()方法中。
    • 2.实现一个Callable实现类的对象
    • 3.将此Callable实现类的对象，传递到FutureTask 的构造器中，创建一个FutureTask 的对象
    • 4.将FutureTask 对象作为参数传递到Thread类的构造器中，创建Thread对象，并start()；
    • 5.获取Callable中call()方法的返回值
// 第1步
class NumTread implements Callable {
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            if (i%2==0){
                System.out.println(i);
                sum+=(i+1);
            }
        }
        return sum;
    }
}
public class ThreadNew{
    public static void main(String[] args) {
    	// 第2步
        NumTread numTread = new NumTread();
		// 第3步
        FutureTask futureTask = new FutureTask(numTread);
		// 第4步
        new Thread(futureTask).start();

        try {
        	// 第5步
            Object x = futureTask.get();
            System.out.println("总和为:"+x);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }
}
  • 如何理解实现Callable接口的方式创建多线程比实现Runnable的方式更强大？
    • call()方法有返回值
    • call()方法可以抛出异常，被外面的操作捕获，获取异常信息。
    • Callable支持泛型。

新增方式二：使用线程池

  • 背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响较大。
  • 思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
  • 好处：
    • 提高响应速度（减少了创建新线程的时间）
    • 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
    • 便于线程管理：
      • corePoolSize：核心池的大小
      • maximumPoolSize：最大线程数
      • keepAliveTime：线程没有任务时最多保持多长时间后会结束
线程池相关API
  • JDK5.0开始提供了线程池相关API：ExecutorService和Executors
  • ExecutorService：真正的线程池接口。常见子类：ThreadPoolExecutor
    • public void execute(Runnable command) {}：执行任务/命令，没有返回值，一般用来执行Runnable
    • <T> Future<T> submit(Callable<T> task);：执行任务，有返回值，一般用来执行 Callable
    • void shutdown();关闭连接池
  • Executors：工具类、线程池的工厂类，用来创建并返回不同类型的线程池
    • public static ExecutorService newCachedThreadPool() {创建一个可根据需要创建新线程的线程池
    • public static ExecutorService newFixedThreadPool(int nThreads) {创建一个可重用固定线程数的线程池
    • public static ExecutorService newSingleThreadExecutor() {创建一个只有一个线程的线程池
    • public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {创建一个线程池，它可安排在给定延迟后运行命令或者定期的执行。
dadadadak
关注
专栏目录
随记13——我的简单自定义View之升级版的带指示的图片圆形进度条
白小花同学的博客
01-11 246
女神镇楼 这次实在上一篇圆形进度条的基础上在进度的末尾处增加一个图片。效果如下： 解释一下：绿色背景是我们控件所占的空间大小。我想要的效果就是：在绘制的过程中，图片的中心始终跟着进度走。且进度的圆环末端中心点就是图片的中心点。理论图如下： 以上就是原理图，下面直接上代码： /** * Created by Administrator on 2017/12/18
漫谈大数据分布式协调服务框架——Zookeeper（你会懂的）
lbb88888888的博客
01-06 654
1.Zookeeper是什么?        Zookeeper是一个开源的、分布式的，为分布式应用提供协调服务的大数据框架。        它的诞生是源于雅虎对Google Chubby（分布式锁服务）的开源实现，后来托管到Apache Software F...
前端学习第一天-html基础
最新发布
weixin_55702682的博客
02-27 1023
前端学习第一天-html基础
书签收藏集
Link2Points的博客
12-19 782
目录 GITHUB K8s 网站 工具 搜索引擎 文章 RPi 文档 待学 论文索引 平台 临时 Django API GPS MQTT Android 论文 疑难 毕 GITHUB guanguans/design-patterns-for-humans-cn: ???? Design patterns for humans 中文版 orico/www.mlcompendium.com: The Machine Learning & Dee
《疯狂 Java 突破程序员基本功的 16 课》读书随记
秀才的专栏
08-13 1013
源自：http://blog.csdn.net/tzs_1041218129/article/details/72824194 第 1 课 数组与内存控制 数组初始化使用数组 第 2 课 对象与内存的控制 实例变量 和 类变量 局部变量成员变量实例变量和类变量的属性实例变量的初始化时机类变量的初始化时机 父类构造器 隐式调用和显示调用访问子类对象的实例变量调用
Perfmon简介
enchanterblue的专栏
05-02 3938
 Perfmon - Windows 自带系统监测工具一、 简述可以用于监视CPU使用率、内存使用率、硬盘读写速度、网络速度等。Perfmon提供了图表化的系统性能实时监视器、性能日志和警报管理，系统的性能日志可定义为二进制文件、文本文件、SQLSERVER表记录等方式，可以很方便地使用第三方工具进行性能分析。perfmon.exe 文件位于C:\Windows\System32目录下。　　使用方...
IT工程师学习方法和发展路线
stqer的博客
03-25 7100
前言： 从需求，即招聘，面试入手，了解行业所需，再到个人部分，学习大佬们的学习方法，书写自己的简历，提升自我技能，或通过考证锻炼学习的学习方法，或通过技能提高工作效率，简述几个方面的特点，梳理下发展路线，通过利器提高办公效率。 Tips：Markdown语法学习：改字体颜色、该字体底色、画图、各种图、语法大全根据我国发布的《国民经济和社会发展第十四个五年规划和2035年远景目标纲要》 从招聘平台获取自己想要的招聘信息，进而找到应对之道，换言之，做好押题工作。 1、Boss直聘：https://www.zhi
python资料全集
watsondai1234的博客
04-15 2588
python: 微信公众号开发小记——2.80端口上的服务 python: 微信公众号开发小记——3.接入三方登录 使用python编写一个壁纸网站的简单爬虫 python: python List 用法 Python 中各个时间复杂度 python ssh异常 Seleniu2: Selenium2 Python 自动化测试实战学习笔记
Bookmarks 各种技术 参考
大JAVA解决方案
11-28 2736
    收藏栏   微软必应搜索 - 全球搜索，有问必应 (Bing) spring security   第 1 章 一个简单的HelloWorld spring security的原理及教程 - 二当家的 - 博客频道 - CSDN.NET Spring Security 3.0 数据库动态实现权限控制 - zlllxl2002的专栏 - 博客频道 - CSDN.NET S...
阿西河前端教程学习心得随记——HTML5 有哪些新特性？_声明方式
01-08
最近看了一些与html基础相关的入门教学视频，心得感悟只有：不同特性的标签记住就好了！但理智告诉我，一切还未正式开始。肿么办？-_-#  是不是可以根据具体html的面试问题对理论知识进行认知拓展与实践练习呢？待...
python随机抽号_Python学习随记 ————随机抽号器（一）
weixin_39817347的博客
11-20 2234
第一篇博客 2018-07-15笔者是一名学生，见到很多教师会选择用抽号的方式点名、收作业，甚至来确定期末口语考试的背诵文章，特花了几天时间，查阅了大量资料，完成了此抽号器。闲话不多说，进入正题。界面是这样的： 功能是这样的：随机抽取学号结果保存至本地修改字体及大小代码是这样的：首先画出...
问题随记——【Python】 Redirection is not supported.
繁依Fanyi的博客
05-16 968
报错信息 Redirection is not supported. # 不支持重定向 解决方法 RUN --> Edit Configuration --> 勾选 Emulate terminal in output console （运行 --> 编辑配置 --> 勾选 模拟输出控制台的终端） 成功运行。。 ......
复习随记——关于Grid
qq_43516152的博客
07-24 248
关于Grid布局的一些理解 ——其实个人认为CSS这一块最起码先把对应的“公式”先记熟 简介 Grid布局又叫做网格布局，顾名思义是一种二维网格的布局方式（Flex可以理解为一维布局），Grid的强大让人兴奋！ 兼容性 提到Grid布局可能很多人会联想到它的兼容性问题，但是截止至2017年3月，已经有许多浏览器对Grid提供了支持，而且无需加浏览器前缀。 上面的浏览器，顺序从左到右： PC 端...
Mybatis入门 （含过程debug）
10-05 649
前言 连接数据库的工具： JDBC —> Dbutils(QueryRunner) —> JdbcTemplate 连接数据库主要流程： 编写sql 预编译 设置参数 执行sql 封装结果 Hibernate：全自动ORM（Object Relation Mapping）框架：旨在消除sql，HQL 缺点： 长难复杂SQL，对Hibernate而言处理也不容易 难以进行sql优化（sql由框架自动生成） 全映射，无法选取部分字段（一些场景，mysql选取部分字段效率更优） mybatis
在线课程项目（二）——讲师管理模块
11-08 616
讲师管理模块后端： 创建数据库 项目结构： 创建父工程：pom类型，管理依赖版本和放公共依赖 （springboot工程） 子模块：子模块下可再分子模块（maven工程） 新建父工程 在节点后面添加pom类型 <artifactId>guli_parent</artifactId> <packaging>pom</packaging> 把父工程的dependencies全部去掉（在子工程中添加），只保留properties和dependency
随记——netty入门（一）——20201012
10-12 458
Netty核心技术及源码剖析——尚硅谷 文章目录前言Netty介绍Netty应用场景IO模型IO模型基本说明BIO NIO AIO适用场景BIO基本介绍BIO工作机制BIO应用实例（线程池）NIO基本介绍demoNIO群聊系统NIO与零拷贝AIO基本介绍Netty概述线程模型传统阻塞IO服务模型Reactor模式 前言 前置课程：JAVA OOP编程、多线程编程、IO编程、网络编程、常用设计模式 书籍： 《Netty IN ACTION》 《Netty 权威指南》（基于Netty5） 《Netty 进阶之路
随记——java8新特性
06-23 384
尚硅谷_Java零基础教程-java入门必备-初学者基从入门到精通全套完整版(宋红康主讲) P666-665 文章目录1. Lambda表达式lambda表达式的使用：6种语法格式总结2. 函数式接口如何理解函数式接口java内置四大核心函数式接口测试 `Consumer `：测试 `Predicate`：3. 方法引用与构造器引用方法引用的使用情况一 对象 :: 实例方法情况二 类 :: 静态方法情况三 类 :: 非静态方法构造器引用无参构造器含参构造器数组 String[]::new4. Stre
随记——java基础的String类和日期Date、Calendar类
06-12 303
文章目录1. 字符串相关的类String概述不可变性String实例化的不同方式字符串拼接方式赋值的对比常用方法字符串和byte[]转化字符串存放位置StringBuffer、StringBuilder内存解析常用方法2. JDK8之前的日期时间API1. 获取系统当前时间2. java.util.Date 和java.sql.Date3. java.text.SimpleDateFormat4. Calendar类3. JDK8中新日期时间APILocalDate、LocalTime、LocalDateT
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值