多线程01,线程基础知识

简介:

多线程基础知识

目录介绍

  • 1.进程概述及多进程的意义[理解]

    • 1.1 线程和进程
    • 1.2 进程概述
    • 1.3 多进程的意义
  • 2.线程的概述和多线程的意义[理解]

    • 2.1 什么是线程
    • 2.2 多线程有什么意义
    • 2.3 并行和并发
  • 3.JVM运行原理以及JVM启动的线程探讨[理解]

    • 3.1 Java程序运行原理
    • 3.2 JVM的启动是多线程的吗
  • 4.多线程程序实现的方式[掌握]

    • 4.1 多线程程序实现的方式【重点】
    • 4.1.1 第一种方式:是类继承Thread
    • 4.1.2 第二种方式:是实现接口Runnable
    • 4.2 多线程两种方式的区别
    • 4.3 几个小问题探索
    • 4.4 匿名内部类的方式实现多线程程序
  • 5.线程调度

    • 5.1 线程的调度问题
    • 5.2 线程有两种调度模型
  • 6.线程控制

    • 6.1 线程控制之休眠线程
    • 6.2 线程控制之加入线程
    • 6.3 线程控制之礼让线程
    • 6.4 线程控制之守护线程
    • 6.5 线程控制之中断线程
  • 7.案例分析

    • 7.1 继承Thread类的方式卖电影票案例
    • 7.2 实现Runnable接口的方式卖电影票
    • 7.3 买电影票出现了同票和负数票的原因分析
    • 7.4 线程安全问题的产生原因分析
    • 7.5 同步代码块的方式解决线程安全问题

1.进程概述及多进程的意义[理解]

1.1 线程和进程

  • 要想说线程,首先必须得聊聊进程,因为线程是依赖于进程存在的。

1.2 进程概述

  • 什么是进程呢?通过任务管理器我们就可以看到进程的存在。
  • 概念:进程就是正在运行的程序,是系统进行资源分配和调用的独立单位。每一个进程都有它自己的内存空间和系统资源。

1.3 多进程的意义

  • 单进程计算机只能做一件事情。而我们现在的计算机都可以一边玩游戏(游戏进程),一边听音乐(音乐进程),所以我们常见的操作系统都是多进程操作系统。比如:Windows,Mac和Linux等,能在同一个时间段内执行多个任务。
  • 对于单核计算机来讲,游戏进程和音乐进程是同时运行的吗?不是。
  • 因为CPU在某个时间点上只能做一件事情,计算机是在游戏进程和音乐进程间做着频繁切换,且切换速度很快,
  • 所以,我们感觉游戏和音乐在同时进行,其实并不是同时执行的。多进程的作用不是提高执行速度,而是提高CPU的使用率。

2.线程的概述和多线程的意义[理解]

2.1 什么是线程

  • 在一个进程内部又可以执行多个任务,而这每一个任务我们就可以看成是一个线程。是程序使用CPU的基本单位。

2.2 多线程有什么意义

  • 多线程的作用不是提高执行速度,而是为了提高应用程序的使用率。
  • 那么怎么理解这个问题呢?我们程序在运行的使用,都是在抢CPU的时间片(执行权),如果是多线程的程序,那么在抢到CPU的执行权的概率应该比较单线程程序抢到的概率要大.那么也就是说,CPU在多线程程序中执行的时间要比单线程多,所以就提高了程序的使用率.但是即使是多线程程序,那么他们中的哪个线程能抢占到CPU的资源呢,这个是不确定的,所以多线程具有随机性.

2.3 并行和并发

  • 前者是逻辑上同时发生,指在某一个时间内同时运行多个程序。
  • 后者是物理上同时发生,指在某一个时间点同时运行多个程序。

3.JVM运行原理以及JVM启动的线程探讨[理解]

3.1 Java程序运行原理

  • Java命令会启动java虚拟机,启动JVM,等于启动了一个应用程序,也就是启动了一个进程。
  • 该进程会自动启动一个 “主线程” ,然后主线程去调用某个类的 main 方法。所以 main方法运行在主线程中。

3.2 JVM的启动是多线程的吗

  • JVM启动至少启动了垃圾回收线程和主线程,所以是多线程的。

4.多线程程序实现的方式[掌握]

4.1 多线程程序实现的方式

  • 4.1.1 第一种方式:是类继承Thread
第一种方式的步骤:
1: 定义一个类,让该类去继承Thread类
2: 重写run方法
3: 创建该类的对象
4: 启动线程

public class ThreadDemo {
    public static void main(String[] args) {
        // 创建对象
        MyThread t1 = new MyThread() ;
        MyThread t2 = new MyThread() ;
        // 启动线程: 需要使用start方法启动线程, 如果我们在这里调用的是run方法,那么我们只是把该方法作为普通方法进行执行
//        t1.run() ;
//        t1.run() ;
        t1.start() ;        // 告诉jvm开启一个线程调用run方法
        // t1.start() ;        // 一个线程只能被启动一次
        t2.start() ;
        
    }
}

public class MyThread extends Thread {
    @Override
    public void run() {
        for(int x = 0 ; x < 1000 ; x++) {
            System.out.println(x);
        }
    }
}
  • 4.1.2 第二种方式:是实现接口Runnable
实现多线程的第二中方式步骤:
1: 定义一个类,让该类去实现Runnable接口
2: 重写run方法
3: 创建定义的类的对象
4: 创建Thread的对象吧第三步创建的对象作为参数传递进来
5: 启动线程

public static void main(String[] args) {
    // 创建定义的类的对象
    MyThread mt = new MyThread() ;
    // 创建Thread的对象吧第三步创建的对象作为参数传递进来
    Thread t1 = new Thread(mt , "张三") ;
    Thread t2 = new Thread(mt , "李四") ;
    // 启动线程
    t1.start() ;
    t2.start() ;
}

public class MyThread implements Runnable {
    @Override
    public void run() {
        for(int x = 0 ; x < 1000 ; x++) {
            System.out.println(Thread.currentThread().getName() + "---" + x);
        }
        
    }
}

4.2 多线程两种方式的区别

  • run()方法只是调用了Thread实例的run()方法而已,它仍然运行在主线程上,而start()方法会开辟一个新的线程,在新的线程上调用run()方法,此时它运行在新的线程上。

4.3 几个小问题探索

  • 4.3.1 为什么要重写run方法
  • 可以在定义的类中,定义多个方法,而方法中的代码并不是所有的都需要线程来进行执行; 如果我们想让某一个段代码被线程,那么我们只需要将那一段代码放在run方法中。那么也就是说run方法中封装的都是要被线程执行的代码 ;
  • run方法中的代码的特点: 封装的都是一些比较耗时的代码
  • 4.3.2 线程能不能多次启动
  • 一个线程只能被启动一次
  • 4.3.2 run()和start()方法的区别
  • 启动线程: 需要使用start方法启动线程, 如果我们在这里调用的是run方法,那么我们只是把该方法作为普通方法进行执行。

4.4 匿名内部类的方式实现多线程程序

  • new Thread(){代码…}.start();
  • new Thread(new Runnable(){代码…}).start();

5.线程调度

5.1 线程的调度问题

  • 应用程序在执行的时候都需要依赖于线程去抢占CPU的时间片 , 谁抢占到了CPU的时间片,那么CPU就会执行谁
  • 线程的执行:假如我们的计算机只有一个 CPU,那么 CPU在某一个时刻只能执行一条指令,线程只有得到CPU时间片,也就是使用权,才可以执行指令。

5.2 线程有两种调度模型

  • 5.2.1 分时调度模型
  • 所有线程轮流使用CPU的使用权,平均分配每个线程占用 CPU 的时间片
  • 5.2.2 抢占式调度模型
  • 优先让优先级高的线程使用 CPU,如果线程的优先级相同,那么会随机选择一个,优先级高的线程获取的 CPU 时间片相对多一些。Java使用的是抢占式调度模型。

6.线程控制

6.1 线程控制之休眠线程

  • public static void sleep(long time) ;
  • time表达的意思是休眠的时间 , 单位是毫秒

6.2 线程控制之加入线程

  • public final void join()
  • 等待该线程执行完毕了以后,其他线程才能再次执行
  • 注意事项: 在线程启动之后,在调用方法

6.3 线程控制之礼让线程

  • public static void yield():
  • 暂停当前正在执行的线程对象,并执行其他线程。
  • 线程礼让的原理是: 暂定当前的线程,然CPU去执行其他的线程, 这个暂定的时间是相当短暂的; 当我某一个线程暂定完毕以后,其他的线程还没有抢占到cpu的执行权 ; 那么这个是时候当前的线程会和其他的线程再次抢占cpu的执行权;

6.4 线程控制之守护线程

  • public final void setDaemon(boolean on)
  • 将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时,Java 虚拟机退出。 该方法必须在启动线程前调用。
  • jvm会线程程序中存在的线程类型,如果线程全部是守护线程,那么jvm就停止。

6.5 线程控制之中断线程

  • public final void stop():
  • 停止线程的运行
  • public void interrupt():
  • 中断线程(这个翻译不太好),查看API可得当线程调用wait(),sleep(long time)方法的时候处于阻塞状态,可以通过这个方法清除阻塞

7.案例分析

7.1 继承Thread类的方式卖电影票案例

public class ThreadDemo {
    public static void main(String[] args) {
        /**
         * 需求:某电影院目前正在上映贺岁大片,共有100张票,而它有3个售票窗口售票,请设计一个程序模拟该电影院售票。
         */
        // 创建3个线程对象
        SellTicktes t1 = new SellTicktes() ;
        SellTicktes t2 = new SellTicktes() ;
        SellTicktes t3 = new SellTicktes() ;
        // 设置名称
        t1.setName("窗口1") ;
        t2.setName("窗口2") ;
        t3.setName("窗口3") ;
        // 启动线程
        t1.start() ;
        t2.start() ;
        t3.start() ;
    }
}

public class SellTicktes extends Thread {
    private static int num = 100 ;
    @Override
    public void run() {
        /**
         * 定义总票数
         * 
         * 如果我们把票数定义成了局部变量,那么表示的意思是每一个窗口出售了各自的100张票; 而我们的需求是: 总共有100张票
         * 而这100张票要被3个窗口出售; 因此我们就不能把票数定义成局部变量,只能定义成成员变量
         */        
        // 模拟售票
        while(true) {
            if( num > 0 ) {
                System.out.println(Thread.currentThread().getName() + "正在出售" + (num--) + "张票");
            }
        }
    }
}

7.2 实现Runnable接口的方式卖电影票

public class SellTicektesDemo {
    public static void main(String[] args) {
        // 创建SellTicektes对象
        SellTicektes st = new SellTicektes() ;
        // 创建Thread对象
        Thread t1 = new Thread(st , "窗口1") ;
        Thread t2 = new Thread(st , "窗口2") ;
        Thread t3 = new Thread(st , "窗口3") ;
        // 启动线程
        t1.start() ;
        t2.start() ;
        t3.start() ;
    }
}

public class SellTicektes implements Runnable {
    private static int num = 100 ;
    @Override
    public void run() {
        while(true) {
            if(num > 0) {
                System.out.println(Thread.currentThread().getName() + "正在出售第" + (num--) + "张票");
            }
        }
    }
}

7.3 买电影票出现了同票和负数票的原因分析

  • 讲解过电影院售票程序,从表面上看不出什么问题,但是在真实生活中,售票时网络是不能实时传输的,总是存在延迟的情况,所以,在出售一张票以后,需要一点时间的延迟。改实现接口方式的卖票程序,每次卖票延迟100毫秒
public class ThreadDemo {
    public static void main(String[] args) {
        // 创建3个线程对象
        SellTicktes t1 = new SellTicktes() ;
        SellTicktes t2 = new SellTicktes() ;
        SellTicktes t3 = new SellTicktes() ;
        // 设置名称
        t1.setName("窗口1") ;
        t2.setName("窗口2") ;
        t3.setName("窗口3") ;
        // 启动线程
        t1.start() ;
        t2.start() ;
        t3.start() ;
    }
}

public class SellTicktes extends Thread {
    private static int num = 100 ;
    @Override
    public void run() {
        // 模拟售票
        while(true) {
            if( num > 0 ) {
                try {
                    Thread.sleep(100) ;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "正在出售" + (num--) + "张票");
            }
        }
    }
}

7.4 线程安全问题的产生原因分析

  • 7.4.1 首先想为什么出现问题?
  • 是否是多线程环境,是否有共享数据,是否有多条语句操作共享数据
  • 7.4.2 如何解决多线程安全问题呢?
  • 基本思想:让程序没有安全问题的环境。怎么实现呢?把多个语句操作共享数据的代码给锁起来,让任意时刻只能有一个线程执行即可。

7.5 同步代码块的方式解决线程安全问题

  • 7.5.1 同步代码块的格式
  • 同步可以解决安全问题的根本原因就在那个对象上。该对象如同锁的功能
synchronized(对象){
            需要同步的代码;
        }
  • 7.5.2 同步代码块优势和劣势
  • 同步的好处:同步的出现解决了多线程的安全问题。
  • 同步的弊端:当线程相当多时,因为每个线程都会去判断同步上的锁,这是很耗费资源的,无形中会降低程序的运行效率。
目录
相关文章
|
23小时前
|
存储 消息中间件 资源调度
C++ 多线程之初识多线程
这篇文章介绍了C++多线程的基本概念,包括进程和线程的定义、并发的实现方式,以及如何在C++中创建和管理线程,包括使用`std::thread`库、线程的join和detach方法,并通过示例代码展示了如何创建和使用多线程。
11 1
C++ 多线程之初识多线程
|
23小时前
|
存储 前端开发 C++
C++ 多线程之带返回值的线程处理函数
这篇文章介绍了在C++中使用`async`函数、`packaged_task`和`promise`三种方法来创建带返回值的线程处理函数。
14 6
|
23小时前
|
C++
C++ 多线程之线程管理函数
这篇文章介绍了C++中多线程编程的几个关键函数,包括获取线程ID的`get_id()`,延时函数`sleep_for()`,线程让步函数`yield()`,以及阻塞线程直到指定时间的`sleep_until()`。
6 0
C++ 多线程之线程管理函数
|
4天前
|
设计模式 Java 物联网
【多线程-从零开始-玖】内核态,用户态,线程池的参数、使用方法详解
【多线程-从零开始-玖】内核态,用户态,线程池的参数、使用方法详解
17 0
|
4天前
|
安全 Java 程序员
【多线程-从零开始-肆】线程安全、加锁和死锁
【多线程-从零开始-肆】线程安全、加锁和死锁
22 0
|
4天前
|
Java 程序员 编译器
【多线程-从零开始-叁】线程的核心操作
【多线程-从零开始-叁】线程的核心操作
15 0
|
4天前
|
Java 调度
【多线程-从零开始-贰】线程的构造方法和常见属性
【多线程-从零开始-贰】线程的构造方法和常见属性
15 0
|
2月前
|
存储 监控 Java
Java多线程优化:提高线程池性能的技巧与实践
Java多线程优化:提高线程池性能的技巧与实践
73 1
|
16天前
|
数据采集 负载均衡 安全
LeetCode刷题 多线程编程九则 | 1188. 设计有限阻塞队列 1242. 多线程网页爬虫 1279. 红绿灯路口
本文提供了多个多线程编程问题的解决方案,包括设计有限阻塞队列、多线程网页爬虫、红绿灯路口等,每个问题都给出了至少一种实现方法,涵盖了互斥锁、条件变量、信号量等线程同步机制的使用。
LeetCode刷题 多线程编程九则 | 1188. 设计有限阻塞队列 1242. 多线程网页爬虫 1279. 红绿灯路口
|
23天前
|
Java Spring
spring多线程实现+合理设置最大线程数和核心线程数
本文介绍了手动设置线程池时的最大线程数和核心线程数配置方法,建议根据CPU核数及程序类型(CPU密集型或IO密集型)来合理设定。对于IO密集型,核心线程数设为CPU核数的两倍;CPU密集型则设为CPU核数加一。此外,还讨论了`maxPoolSize`、`keepAliveTime`、`allowCoreThreadTimeout`和`queueCapacity`等参数的设置策略,以确保线程池高效稳定运行。
94 10
spring多线程实现+合理设置最大线程数和核心线程数