JavaSE进阶06-多线程

已于 2022-05-29 10:57:18 修改
阅读量174 收藏
点赞数
分类专栏： Java笔记 文章标签： java 开发语言
于 2022-05-29 10:52:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cry30867/article/details/124705822
版权

01 多线程的基本概念

线程指进程中的一个执行场景，即执行流程。进程与线程的区别：

  • 每个进程是一个应用程序，都有独立的内存空间
  • 同一个进程中的线程共享其进程中的内存和资源（共享的内存是堆内存和方法区内存，栈内存不共享，每个线程有自己的栈内存）

1.1 什么是进程

  一个进程就是一个应用程序。在操作系统中每启动一个应用程序就会相应的启动一个进程。如：QQ、网易云等。

1.2 系统引入多进程的作用

提高CPU的使用率。
重点：进程与进程之前的内存相互独立。

1.3 什么是线程

线程是进程的一个执行场景，一个进程可以启动多个线程。

1.4 进程引入多线程的作用

提高进程的使用率。
重点：线程和线程之间栈内存独立，堆内存和方法区内存共享，一个线程一个栈。

1.5 描述Java程序的执行原理

  Java命令执行会启动JVM，JVM的启动表示启动一个应用程序即启动一个进程。该进程会自动启动一个“主线程”，然后主线程负责调用某个类的main方法。main方法的执行是在主线程中执行的，然后通过main方法代码的执行可以启动其他的“分支线程”。所以main方法结束程序不一定结束，因为其他的支线分支有可能还在执行。

02 线程的创建和启动

Java虚拟机的主线程入口是main方法，用户可以自己创建线程，创建方式有两种：

  • 继承Thread类
  • 实现Runnable接口（推荐使用）

2.1 继承Thread类

  Thread类中创建线程最重要的两个方法为public void run()和public void start()。采用Thread类创建线程，用户只需要继承Thread，重写Thread的run()方法，父类Thread中的run()方法没有抛出异常，那么子类也不能抛出异常，最后采用start()启动线程即可。

public class ThreadTest {
    public static void main(String[] args) {
        Processor p=new Processor();
        p.start();
        method1();
    }

    private static void method1(){
        System.out.println("------method1()-------");
    }
}

class Processor extends Thread{
    // 重写Thread中的run方法
    public void run(){
        for (int i = 0; i < 5; i++) {
            System.out.println(i);
        }
    }
}

输出结果为：

------method1()-------
0
1
2
3
4

  以上输出并没有顺序执行，从效率上看，采用多线程的示例要快一些。method1并没有等待前面的操作完成才执行，称为“异步编程模型”

2.2 实现Runnable接口

  Thread对象本身实现了Runnable接口，但一般建议直接使用Runnable接口来写多线程，因为接口比类更好用。

public class ThreadTest {
    public static void main(String[] args) {
        Runnable r1=new Processor();
        // 不能直接调用run
        Thread t1=new Thread(r1);
        // 启动线程
        t1.start();

        method1();
    }
    private static void method1(){
        System.out.println("----method1()------");
    }
}

class Processor implements Runnable{
    // 实现Runnable中的run方法
    public void run(){
        for (int i = 0; i < 5; i++) {
            System.out.println(i);
        }
    }
}

03 线程的生命周期

线程的生命周期存在五个状态：新建、就绪、运行、阻塞、死亡
在这里插入图片描述

  • 新建：采用new语句创建完成
  • 就绪：执行start后
  • 运行：占用CPU时间
  • 阻塞：执行了wait语句、执行了sleep语句和等待某个对象锁，等待输入的场合
  • 终止：退出run()方法
    在这里插入图片描述

04 线程的调度与控制

  通常我们的计算机只有一个 CPU，CPU 在某一个时刻只能执行一条指令，线程只有得到 CPU时间片，也就是使用权，才可以执行指令。在单 CPU 的机器上线程不是并行运行的，只有在多个 CPU 上线程才可以并行运行。Java 虚拟机要负责线程的调度，取得 CPU的使用权，目前有两种调度模型：分时调度模型和抢占式调度模型，Java 使用抢占式调度模型。

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

4.1 线程优先级

  线程优先级主要分三种：MAX_PRIORITY( 最高级 );MIN_PRIORITY（最低级）; NOM_PRIORITY(标准)默认

public class ThreadTest {
    public static void main(String[] args) {
        Runnable r1=new Processor();

        Thread t1=new Thread(r1,"t1");
        // 设置线程的优先级，线程启动后不能再设置优先级
        t1.setPriority(Thread.MAX_PRIORITY);
        // 启动线程
        t1.start();

        Thread t2=new Thread(r1,"t2");
        // 设置最低优先级
        t2.setPriority(Thread.MIN_PRIORITY);
        t2.start();
        System.out.println(Thread.currentThread().getName());
    }

}

class Processor implements Runnable{
    // 实现Runnable中的run方法
    public void run(){
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+","+i);
        }
    }
}

优先级高的线程（t1）会抢占到更多的CPU时间片，优先执行完成

4.2 Thread.sleep

  sleep 设置休眠的时间,单位毫秒，当一个线程遇到 sleep 的时候，就会睡眠，进入到阻塞状态,放弃 CPU，腾出 cpu 时间片，给其他线程用，所以在开发中通常我们会这样做，使其他的线程能够取得 CPU 时间片，当睡眠时间到达了，线程会进入可运行状态，得到 CPU 时间片继续执行，如果线程在睡眠状态被中断了，将会抛出 IterruptedException。

class Processor implements Runnable{
    // 实现Runnable中的run方法
    public void run(){
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+","+i);
            if (i%10==0){
                try{
                    // 睡眠100毫秒，将时间片交给其他线程使用
                    Thread.sleep(100);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        }
    }
}

4.3 Thread.yield

它与 sleep()类似，只是不能由用户指定暂停多长时间，并且 yield()方法只能让同优先级的线程有执行的机会

class Processor implements Runnable{
    // 实现Runnable中的run方法
    public void run(){
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+","+i);
            if (i%10==0) {
                System.out.println("------------");
                // 采用yield可以将CPU的使用权让给同一个优先级的线程
                Thread.yield();
            }
        }
    }
}

4.4 t.join()

当前线程可以调用另一个线程的 join 方法，调用后当前线程会被阻塞不再执行，直到被调用的线程执行完毕，当前线程才会执行。

4.5 interrupt（中断）

如果我们的线程正在睡眠，可以采用 interrupt 进行中断

4.6 如何正确停止一个线程

通常定义一个标记来判断标记的状态停止线程的执行

public class ThreadTest {
    public static void main(String[] args) {
        Processor r1=new Processor();
        Thread t1=new Thread(r1,"t1");
        t1.start();

        try {
            Thread.sleep(20);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 停止线程
        r1.setFlag(true);
    }

}

class Processor implements Runnable{
    // 线程停止标记，true为停止
    private boolean flag;
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+","+i);
            // 为true停止线程执行
            if(flag){
                break;
            }
        }
    }
    public void setFlag(boolean flag){
        this.flag=flag;
    }
}

05 线程的同步（加锁）

实例变量：在堆中。
静态变量：在方法区。
局部变量：在栈中。
以上三大变量中：
  局部变量永远都不会存在线程安全问题。
  因为局部变量不共享。（一个线程一个栈）
  局部变量在栈中。所以局部变量永远都不会共享。
实例变量在堆中，堆只有1个。
静态变量在方法区中，方法区只有1个。
堆和方法区都是多线程共享的，所以可能存在线程安全问题。

局部变量+常量：不会有线程安全问题。
成员变量：可能会有线程安全问题。

5.1 为什么需要同步

  • 共享一个对象启动两个线程，s为每个线程的局部变量
public class ThreadTest {
    public static void main(String[] args) {
        Processor r1=new Processor();
        Thread t1=new Thread(r1,"t1");
        t1.start();

        Thread t2=new Thread(r1,"t2");
        t2.start();
    }

}

class Processor implements Runnable{
    @Override
    public void run() {
        // 定义局部变量s，作为累加变量
        int s=0;
        for (int i = 0; i < 10; i++) {
            s+=i;
        }
        System.out.println(Thread.currentThread().getName()+","+s);
    }
}

输出：

t1,45
t2,45

以上t1和t2并发执行，s为每个线程的局部变量，位于各自的栈帧中，因为栈帧中的数据是互不干扰的，所以计算结果都为45

  • 共享一个对象启动两个线程，s为每个线程的成员变量
class Processor implements Runnable{
    // 定义成员变量s，作为累加变量
    int s=0;
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            s+=i;
        }
        System.out.println(Thread.currentThread().getName()+","+s);
    }
}

输出：

t1,45
t2,90

  因为共享同一对象的成员变量，两个线程同时对其进行操作，所以出现了问题，此时称Processor为线程不安全的。想得到正确结果，必须采用线程同步，加锁，该变量不能共享使用。
线程安全问题：

  1. 多线程并发
  2. 有共享数据
  3. 共享数据有修改行为

5.2 使用线程同步

  线程同步指某一时刻允许一个线程来访问共享资源，其实是对对象加锁，如果对象中的方法都是同步方法，那么某一时刻只能执行一个方法。
采用线程同步解决上面的问题：

class Processor implements Runnable{
    // 定义局部变量s，作为累加变量
    int s=0;
    public void run(){
        // 使用同步块
        synchronized (this){
            for (int i = 0; i < 10; i++) {
                s+=i;
            }
            System.out.println(Thread.currentThread().getName()+","+s);
            s=0;
        }
    }
}

  synchronized是对对象加锁，优先考虑synchronized 同步块，因为同步的代码越多，其他线程等待的时间就会越长影响效率。
synchronized的三种写法

  1. 同步代码块
    synchronized(线程共享对象){
    同步代码块;
    }
  2. 在实例方法上使用synchronized
    表示共享对象一定是this
    并且同步代码块是整个方法体。
  3. 在静态方法上使用synchronized
    表示找类锁。
    类锁永远只有1把。
    就算创建了100个对象，那类锁也只有一把。

5.3 为每一个线程创建一个对象来解决线程安全问题

public class ThreadTest {
    public static void main(String[] args) {
        Processor r1=new Processor();
        Thread t1=new Thread(r1,"t1");
        t1.start();

        // 再次创建Processor对象
        Processor r2=new Processor();
        Thread t2=new Thread(r2,"t2");
        t2.start();
    }

}

class Processor implements Runnable{
    // 定义局部变量s，作为累加变量
    int s=0;
    public void run(){
        for (int i = 0; i < 10; i++) {
            s+=i;
        }
        System.out.println(Thread.currentThread().getName()+","+s);
    }
}

  每个线程操作都是自己的对象，没有操作共享的资源
在这里插入图片描述

如何解决线程安全问题？

  1. 尽量使用局部变量代替“实例变量和静态变量”
  2. 如果必须是实例变量，那么可以考虑创建多个对象，这样实例变量的内存不共享
  3. 不能使用局部变量及对象不能创建多个时，考虑synchronized

06 守护线程

  从线程分类上可以分为：用户线程（以上讲的都是用户线程），另一个是守护线程。所有的用户线程结束生命周期后，守护线程才会结束生命周期，只要有一个用户线程存在，那么守护线程就不会结束。例如 java 中著名的垃圾回收器就是一个守护线程，只有应用程序中所有的线程结束，它才会结束。

6.1 用户线程

public class ThreadTest {
    public static void main(String[] args) {
        Processor r1=new Processor();
        Thread t1=new Thread(r1,"t1");
        t1.start();

        for (int i = 0; i <5; i++) {
            System.out.println(Thread.currentThread().getName()+","+i);
        }

        System.out.println("主线程结束！！！");
    }

}

class Processor implements Runnable{

    public void run(){
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+","+i);
        }

    }
}

main,0
main,1
main,2
t1,0
main,3
main,4
主线程结束！！！
t1,1
t1,2
t1,3
t1,4

主线程执行结束后，用户线程仍然在执行

6.2 守护线程（服务线程）

public class ThreadTest {
    public static void main(String[] args) {
        Processor r1=new Processor();
        Thread t1=new Thread(r1,"t1");
        // 将当前线程修改为守护线程
        t1.setDaemon(true);
        t1.start();

        for (int i = 0; i <5 ; i++) {
            System.out.println(Thread.currentThread().getName()+","+i);
        }

        System.out.println("主线程结束！！！");
    }

}

class Processor implements Runnable{

    public void run(){
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+","+i);
        }

    }
}

输出：


main,0
main,1
t1,0
main,2
t1,1
main,3
t1,2
main,4
t1,3
主线程结束！！！
t1,4

当主线程结束后，守护线程并没有把所有数据输出完就结束了。
**结论：**当用户线程全部结束，守护线程会自动结束

07 Timer定时器

08 Window定时器（任务）

09 重点掌握

  1. 进程与线程的概念
    2. 线程的两种实现方式（Thread,Runnable）
  2. 了解线程的优先级
  3. sleep 的含义
  4. 如果正确的结束一个线程
  5. 线程同步的含义（同步共享资源，局部变量不存在共享的问题）
  6. 守护线程的概念
  7. 了解 Timer
  8. 了解 winodw提供的计划
cry_30867
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java执行完main就结束了吗_科普：为什么SpringBoot中main方法执行完毕后程序不会直接退出呢...
weixin_32799203的博客
02-27 1791
针对这个问题我们可以转化一下思路：一个JVM进程，在什么情况下会正常退出？大部分人应该都知道使用System.exit()或Runtime.exit()可以直接导致当前JVM进程退出，但是仔细想想这个好像跟SpringBoot没啥关系哈另外一个可能会导致进程退出的是所有的非daemon进程完全终止，那么根据这个条件反推的话是不是说只要保证SpringBoot进程中包含1个以上的daemon进程就可...
Java中，main线程结束，程序会停止吗？
学亮编程手记
06-03 1245
但如果还有守护线程在运行，程序将继续执行，直到所有守护线程也结束。需要注意的是，当程序终止时，所有正在执行的线程都会被中断，并且不会完全执行完毕。因此，在设计多线程程序时，需要确保所有的线程能够正确地终止，以避免资源泄露和其他潜在的问题。守护线程是为其他线程提供服务的线程，当所有用户线程都结束时，守护线程会自动退出。例如，垃圾回收器线程就是一个守护线程，它在后台运行，负责回收不再使用的内存。相反，程序会继续执行，直到所有非守护线程都结束。方法结束后立即停止程序，可以将所有的非守护线程设置为守护线程。
一般来说，当主方法（main()）结束时，线程也会随之结束
博客域名:borter.blog.csdn.net
07-23 1143
然而，我需要你提供更多的上下文信息，包括你要我写什么类型的内容，主题是什么，以及你希望我使用什么风格或语言。如果线程是独立于主方法之外创建和运行的，那么即使主方法结束了，这些线程也可能仍然在运行。是的，一般来说，当主方法（main()）结束时，线程也会随之结束。但是，如果其他线程是在主方法之外创建和运行的，那么它们将继续运行，直到显式地关闭或终止。一般来说，主方法main()结束的时候线程结束，可是也可能出现需要中断线程的情况。总之，当主方法结束时，与主方法关联的线程会结束，但其他线程可能会继续运行。
Java程序中main方法执行结束，main方法中创建的子线程会不会结束
Robi_Candy的博客
08-19 4202
package com; public class Test { public static void main(String[] args) { //1.创建一个线程 Thread t = new Thread(() -> { while (true){ System.out.println("子线程执行，"+Thread.currentThread().getName()); .
java执行完main就结束了吗,为什么main方法中执行完第一个方法完之后,后面的代码都不执行了?...
weixin_29430691的博客
03-15 388
package chap05;public class StringFindTest {public static void testFind(String str, String substr) {int count = 0;int pos = 0;do{if(str.indexOf(substr, pos) >= 0){count++;System.out.println("子串第"+c...
JavaSE进阶-多线程&网络编程
aaa934946088的博客
08-03 167
多线程-死锁 【了解】 多线程-生产者消费者案例 【重点】 多线程-线程状态 【重点】 多线程-线程池 【重点】 网络编程-相关概念 【了解】 网络编程-UDP编程 【重点】......
javase之多线程技术
10-16
标题：进阶课程之并发编程快速入门与多线程实战项目> 课程内容： 1.CPU调度算法原理（先来先服务、最短作业法、优先级调度算法） 2.站在字节码角度+cpu上下文切换角度分析线程安全问题 3.手写Callable与FutureTask...
2020老杜最新Java零基础进阶视频教程-多线程课件
12-10
本Java视频教程适合有一定编程语言基础的学员观看，在本Java视频教程中讲解了Java面向对象、异常、数组、常用类、集合、IO流、线程、反射机制。该视频教程基于Java13进行讲解，Java13是目前Java最新版本。视频中讲师...
11多线程.xmind
08-26
JavaSE进阶学习图
java进阶,包含 常用设计模式、线程和并发、spring核心代码
12-31
Java前后开发面试题，大厂进阶之路，基于JavaGuide、Cyc大佬、牛客...包含计算机网络知识、JavaSE、JVM、Spring、Springboot、SpringCloud、Mybatis、多线程并发、netty、MySQL、MongoDB、Elasticsearch、Redis、HBASE
Java的各种实验包括反射，算法，多线程，面试题，springboot
12-31
Java前后开发面试题，大厂进阶之路，基于JavaGuide、Cyc大佬、牛客...包含计算机网络知识、JavaSE、JVM、Spring、Springboot、SpringCloud、Mybatis、多线程并发、netty、MySQL、MongoDB、Elasticsearch、Redis、HBASE
解决《‘javac‘ 不是内部或外部命令，也不是可运行的程序 或批处理文件。》问题
qq_45786391的博客
09-03 657
举例子：window10系统，64位，安装jdk1.8.0_73，安装在C盘（默认安装位置） 解决方法：配置环境变量 右击此电脑——选择属性——选择高级系统设置——选择环境变量——点击最下面的新建输入以下内容： 注：变量值可以在安装目录下找到，如下： 点击Path： 全部点击《确定》 ****在搜索框中输入cmd进入窗口： 环境变量已配置成功。 ...
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 625
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
Day43
m0_67496588的博客
06-20 705
JSON，Ajax
Geoserver源码解读三 GeoServerBasePage
Yuanben_wuxin的博客
06-19 953
GeoServerBasePage 登录
Javase.认识异常
最新发布
Joseit的博客
06-21 1135
在Java开发中，异常处理是确保程序稳定性和可靠性的关键环节。这篇blog深入解析了Java异常的概念、体系、处理策略及自定义异常类。它介绍了异常的基本概念与分类，详细阐述了异常抛出、捕获与处理的最佳实践，包括防御式编程策略、try-catch结构的使用、以及finally块在资源清理中的作用。此外，还涵盖了自定义异常类以满足特定业务需求的重要性。通过学习本blog，读者可以深入理解Java异常处理机制，提升代码质量。
高通Android 12/13 Launcher3修改RecentView与屏幕方向保持一致
qq_15950325的博客
06-18 357
最近同事遇到一个需求说，recentview应用预览与屏幕方向不一致，问题，于是加了一些日志，实现此需求。3、最后展示RecentView与屏幕方向保持一致。2、源码修改diff如下所示。源码修改路径汇总如下。
Java SE入门及基础（55）& Stream流及常用API
m0_63181360的博客
06-19 488
通过外部迭代，你的应用程序既可以确定要迭代的集合，又可以确定迭代的方式。它可以更轻松地利用并行计算的优势，这涉及将问题分为子问题，同时解决这些问题，然后将解决方案的结果组合到子问题中。）会产生非流结果，例如原始值（如双精度值），集合，或者在forEach的情况下根本没有任何值。它们处理流中的元素：聚合操作从流中而不是直接从集合中处理元素。流将一个基本数据类型的数组转换为包装类型的数组，再将包装类型的数组转换基本数据类型数组。筛选器操作返回一个新流，该流包含与筛选条件（此操作的参数）匹配的元素。
https://www.oracle.com/java/technologies/javase/javase-jdk8-downloads.html
03-16
这是Oracle官网上Java SE 8的下载页面，其中提供了Java SE 8开发工具包（JDK）和Java SE 8运行时环境（JRE）的下载链接。用户可以根据自己的需要选择不同的平台和版本进行下载安装。注意，Java SE 8已经不再接收免费的技术支持和安全更新，建议用户尽快升级到更新的Java版本。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值