Java基础整理（十九）

最新推荐文章于 2024-09-10 10:21:38 发布
最新推荐文章于 2024-09-10 10:21:38 发布
阅读量354 收藏
点赞数
分类专栏： Java基础 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43201722/article/details/122078175
版权

多线程（上）

传送门：多线程（下）

1. 基本概念

  • 什么是进程？什么是线程？

    进程是资源（CPU、内存等）分配的基本单位，它是程序执行时的一个实例。程序运行时系统就会创建一个进程，并为它分配资源，然后把该进程放入进程就绪队列。进程调度器选中它的时候就会为它分配CPU时间，程序开始真正运行。

    线程是程序执行时的最小单位，它是进程的一个执行流，是CPU调度和分派的基本单位。一个进程可以由很多个线程组成，线程间共享进程的所有资源，每个线程有自己的堆栈和局部变量。线程由CPU独立调度执行，在多CPU环境下就允许多个线程同时运行。同样多线程也可以实现并发操作，每个请求分配一个线程来处理。

  • 什么是并发？什么是并行？

    并行(parallel)：指在同一时刻，有多条指令在多个处理器上同时执行。所以无论从微观还是从宏观来看，二者都是一起执行的。

    并发(concurrency)：指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。

  • 对java程序来说，会先启动JVM，而JVM就是一个进程。JVM再启动一个主线程调用main方法。同时再启动一个垃圾回收线程负责看护、回收垃圾。最起码，java程序中至少有连个线程并发。

  • 进程与进程之间资源内存独立不共享，线程和线程间堆内存和方法区内存共享，但栈内存独立，即一个线程一个栈，互不干扰，这就是多线程并发，目的是为了提高程序的处理效率。

  • 使用了多线程机制之后，main方法结束只是主线程结束了，主栈空了，其他的栈（线程）可能还再压栈弹栈。

2. 实现线程的方式

（1）第一种方式

编写一个类，直接继承java.lang.Thread，重写run方法

public class Demo {
    //main方法的代码属于主线程
    public static void main(String[] args) throws Exception {

        //新建一个分支线程对象
        MyThread myThread = new MyThread();
        //启动线程
        myThread.start();
        //这里的代码运行在主线程中
        for(int i = 0; i < 1000; i++){
            System.out.println("主线程-->" + i);
        }
    }
}

class MyThread extends Thread{
    @Override
    public void run() {
        //编写程序，这段程序运行在分支线程中（分支栈）
        for(int i = 0; i < 1000; i++){
            System.out.println("分支线程-->" + i);
        }
    }
}

执行结果（交替）：在这里插入图片描述

  • start()方法的作用：启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码任务完成之后，瞬间就结束了，start()方法结束，线程就启动成功了
  • 启动成功的线程会自动调用run方法，不需要手动调用，由JVM线程调度机制来运作的，并且run方法在分支栈的栈底部（压栈）
  • run方法在分支栈的栈底部，main方法在主栈的栈底部。run和main平级
  • 如果在main方法中不调用start()，而是直接调用run()，则不会启动新的线程
（2）第二种实现方式

编写一个类实现java.lang.Runnable接口

public class Demo {
    //main方法的代码属于主线程
    public static void main(String[] args) throws Exception {

        //创建一个可运行的对象
        MyRunnable myRunnable = new MyRunnable();
        //将可运行的对象封装成一个线程对象
        Thread myThread = new Thread(myRunnable);
        //Thread myThread  = new Thread(new MyRunnable);
        //启动线程
        myThread.start();
        //这里的代码运行在主线程中
        for(int i = 0; i < 1000; i++){
            System.out.println("主线程-->" + i);
        }
    }
}

//这不是一个线程类，是一个可运行的类。它还不是一个线程
class MyRunnable implements Runnable{
    @Override
    public void run() {
        //编写程序，这段程序运行在分支线程中（分支栈）
        for(int i = 0; i < 1000; i++){
            System.out.println("分支线程-->" + i);
        }
    }
}

注：第二种方式实现接口比较常用，因为一个类实现了接口，它还可以去继承其它的类，更灵活。否则用第一种继承Thread，再想继承其他类就无法继承了。

（3）第二种的匿名内部类实现
public class Demo {
    //main方法的代码属于主线程
    public static void main(String[] args) throws Exception {

        //创建线程对象，采用匿名内部类的方式
        Thread myThread = new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i = 0; i < 1000; i++){
                    System.out.println("分支线程-->" + i);
                }
            }
        });
        //启动线程
        myThread.start();
        //这里的代码运行在主线程中
        for(int i = 0; i < 1000; i++){
            System.out.println("主线程-->" + i);
        }
    }
}
（4）第三种方式

实现Callable接口（JDK 8新特性）

这种方式实现的线程可以获取线程的返回值，前两种方式是无法获取线程返回值的，因为run方法返回void

  • 使用场景

    系统委派一个线程区执行一个任务，该线程执行完任务之后，可能会有一个执行结果，我们就会需要用这种方式去拿到这个执行结果

public class Test {
    public static void main(String[] args) {

        //创建一个“未来任务类”对象
        //匿名内部类
        FutureTask task = new FutureTask(new Callable() {
            @Override
            public Object call() throws Exception {
                System.out.println("call method begin");
                Thread.sleep(1000*10);
                System.out.println("call method end");
                int a = 1;
                int b = 2;
                return a+b;
            }
        });

        //需要把未来任务类对象传进去
        Thread t = new Thread(task);
        t.setName("t");
        t.start();
        Object obj = null;
        try {
            //在主线程中获取t线程的返回值
            //get方法需要处理异常
            obj = task.get();
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println(obj);
    }
}

main方法想要执行必须等待get()方法的结果，而get()方法可能需要等待很久，因为get()方法是为了拿到另一个线程的结果，另一个线程是需要时间的。

  • 总结
    • 优点：可以获取到线程的执行结果
    • 缺点：效率比较低，在获取t线程执行结果的时候，当前线程收到阻塞，效率较低

3. 线程的生命周期

在这里插入图片描述

4. 获取当前线程对象

  • 获取线程对象的名字

    String name = 线程对象.getName();

  • 修改线程对象的名字

    线程对象.setName("线程名字");

  • 若当前线程没有设置名字的时候，默认的名字：Thread-0、Thread-1、Thread-2、Thread-3

public class Demo {
    //main方法的代码属于主线程
    public static void main(String[] args) throws Exception {

        //创建线程对象
        MyThread myThread = new MyThread();
        //设置线程的名字
        myThread.setName("ttt");
        //获取线程的名字
        String threadName=myThread.getName();//ttt
        System.out.println(threadName);
    }
}

class MyThread extends Thread{
    @Override
    public void run() {

    }
}

  • 获取当前对象

    static Thread currentThread(); //静态方法！ 返回一个Thread对象

public class Demo {
    //main方法的代码属于主线程
    public static void main(String[] args) throws Exception {

        Thread currentThread = Thread.currentThread();
        //这个代码出现在main方法当中，所以当前线程就是主线程
        System.out.println(currentThread.getName());//main
    }
}

示例：

public class Demo {
    //main方法的代码属于主线程
    public static void main(String[] args) throws Exception {

        MyThread t1 = new MyThread();
        t1.setName("t1");
        t1.start();
        MyThread t2 = new MyThread();
        t2.setName("t2");
        t2.start();
    }
}

class MyThread extends Thread{
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            //currentThread就是当前线程对象，现在对象是谁？
            //当t1线程执行run()方法时，当前线程就是t1
            //当t2线程执行run()方法时，当前线程就是t2
            Thread currentThread = Thread.currentThread();
            System.out.println(currentThread.getName()+"--->"+i);
        }
    }
}

输出结果：在这里插入图片描述

5. 线程睡眠sleep

static void sleep(long millsis)

  • 静态方法：Thread.sleep(1000);

  • 参数是毫秒

  • 要解决异常

  • 作用：让当前线程进入休眠，进入“阻塞状态”，放弃占有CPU时间片，让其他线程使用

    这行代码出现在A线程中，A线程会休眠。出现在B线程，B线程休眠

public class Demo {
    //main方法的代码属于主线程
    public static void main(String[] args){

        try {
            Thread.sleep(1000*5); //休眠5秒， 过5秒钟输出hello world
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("hello world");

    }
}

使用Thread.sleep()方法，可以做到效果：间隔特定的时间，去执行一段特定的代码，每隔多久执行一次

常见问题：

public class Demo {
    public static void main(String[] args){

        Thread t = new MyThread();
        t.start();
        try {
            t.sleep(1000*5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("hello world");
    }
}

class MyThread extends Thread{
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+"--->"+i);
        }
    }
}

由于sleep为静态方法，在执行时会被转成Thread.sleep(1000*5)，让当前线程进入休眠，也就是main线程进入休眠。这行代码出现在main，main线程休眠

所以该程序的运行结果为：循环马上直接完毕，过5s后输出hello world

6. 终止线程睡眠

线程对象.interrupt()

public class Demo {
    public static void main(String[] args)  {

        Thread t = new Thread(new MyThread());
        t.setName("t");
        t.start();

        //希望5秒后，t线程醒来
        try {
            Thread.sleep(1000*5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //中断t线程的睡眠
        t.interrupt();

    }
}

class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+ "---> begin");
        try {
            //这里的异常只能try..catch，不能抛出
            //因为run方法在父类中没有抛出任何异常，子类不能父类抛出更多的异常
            Thread.sleep(1000*60*60*24*365);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+ "---> end");
    }
}

输出结果：在这里插入图片描述

显然，这种终止线程睡眠的方式是依靠了java的异常处理机制，因为它打印出来了异常信息。如果不想异常信息打印出来的话，可以将run方法中的异常信息注释掉。

7. 线程的终止

在java中对线程进行终止，我们常用两种方法，一种是调用线程对象的stop方法，另一种是添加布尔标记。更常用的是第二种。

  • 第一种：stop方法

    public class Demo {
    public static void main(String[] args)  {

        Thread t = new Thread(new MyThread());
        t.setName("t");
        t.start();

        try {
            Thread.sleep(1000*5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        //5秒后线程t停止
        t.stop();

    }
}

class MyThread implements Runnable{
    @Override
    public void run() {
       for(int i=1;i<10;i++){
           System.out.println(Thread.currentThread().getName() + "--->" + i);
           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
    }
}

    输出结果：在这里插入图片描述

    这种方式存在很大的缺点：容易丢失数据。因为这种方式直接将线程杀死了，线程没有保存的数据将丢失，不建议使用

  • 第二种：布尔标记

    public class Demo {
    public static void main(String[] args)  {

        MyThread m = new MyThread();
        Thread t = new Thread(m);
        t.setName("t");
        t.start();

        try {
            Thread.sleep(1000*5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        m.setRun(false);
    }
}

class MyThread implements Runnable{

    private boolean run = true;

    public boolean isRun() {
        return run;
    }

    public void setRun(boolean run) {
        this.run = run;
    }

    @Override
    public void run() {
       for(int i=1;i<10;i++){
           if(run){
               System.out.println(Thread.currentThread().getName() + "--->" + i);
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       }
    }
}

8. 线程的调度

  • 常见的线程调度模型

    • 抢占式调度模型：哪个线程的优先级比较高，抢到的CPU时间片的概率就多一些。java采用的就是抢占式调度模型
    • 均分式调度模型：平均分配CPU时间片，每个线程占有的CPU时间片时间长度一样。

  • java中提供的与线程调度有关的方法

    实例方法：

    • void setPriority(int newPriority)设置线程的优先级

    • int getPriority()获取线程优先级

      最低优先级是1，默认优先级是5，最高优先级是10

      优先级比较高的获取CPU时间片可能会多一些（大概率）

    • void join() 合并线程

    静态方法：

    • static void yield() 线程让位，暂停当前正在执行的线程对象，并执行其他线程

      该方法不是阻塞方法。让当前线程让位，给其他线程使用。

      该方法执行会让当前线程从“运行状态”回到“就绪状态”，但回到就绪之后，有可能会再次抢到

9. 线程的优先级

public class Demo {
    public static void main(String[] args)  {
        
        System.out.println("最高优先级"+ Thread.MAX_PRIORITY); //10
        System.out.println("最低优先级"+ Thread.MIN_PRIORITY); //1
        System.out.println("默认优先级"+ Thread.NORM_PRIORITY); //5
    }
}

  • 如何获取当前线程的优先级

    public class Demo {
    public static void main(String[] args)  {

        Thread currentThread = Thread.currentThread();
        System.out.println(currentThread.getName()+"线程的默认优先级是"+currentThread.getPriority()); //5
    }
}

  • 如何设置当前线程的优先级

    public class Demo {
    public static void main(String[] args)  {

        Thread currentThread = Thread.currentThread();
        currentThread.setPriority(2);
        System.out.println(currentThread.getName()+"线程的优先级是"+currentThread.getPriority());//2
    }
}

优先级较高的，会抢到的CPU时间片相对多一些

10. 线程让位和合并

  • 让位

    静态方法：Thread.yield();

    让位：当前线程暂停，回到就绪状态，让给其他线程

  • 合并

    实例方法：线程对象.join() 该方法需要进行异常处理

    将某个线程合并到当前线程中，当前线程受阻

    public class Demo {
    public static void main(String[] args)  {

        System.out.println("main begin");
        Thread t = new Thread(new MyThread());
        t.setName("t");
        t.start();
        try {
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("main over");
    }
}

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

    没采用合并之前的输出结果：在这里插入图片描述
    采用合并之后的输出结果：在这里插入图片描述

    注：合并线程不代表着另一个栈消失！

李同学向前冲
关注
专栏目录
面经 | Java 基础 整理
weixin_44779122的博客
04-22 1590
文章目录Java 基础一、整体观/理论/概念JDK和JRE的区别Java 为什么可以一次编写、到处运行？java运行快吗 是编译还是解释型语言什么是APIimport java 和javax的区别重写和重载的区别面向对象和面向过程的区别面向对象的三大特性: 封装 继承 多态向上/向下转型都有常量了为什么还要有枚举？构造器 Constructor 是否可被 override构造方法是什么一个类没有声明构造方法,该程序能正确执行吗构造方法的特性调用子类构造方法之前，会先调用父类无参构造方法，其目的是?在Java
java基础笔记整理java基础笔记整理.pdf
07-15
java基础笔记整理java基础笔记整理
Java高频面试基础知识点整理
热门推荐
张彦峰的博客
11-04 167万+
Java高频面试知识点总结：覆盖高频基础知识考点+高频集合知识点深入分析+高频多线程与并发编程面试题汇总+其他扩展考察等。
Java基础知识总结（2021版）
学Java，找哪吒
01-09 25万+
前言 大家好，我是素小暖，2012年毕业，2016年通过培训转行java开发，今天2021年1月9日，转行之路跌跌绊绊，蓦然回首，已经满满的4年工作经验了？但感觉知识还是相当的匮乏，没自信，也许是努力程度还不够吧。很感谢CSDN，因为是它给了我学习的动力，之前写了一篇记录CSDN博客访问量的文章，也许大家感觉很幼稚，但真的很有用，很有效果，仿佛磕了药一样，努力学习，进步。 2020年，是我较为成功的一年，工作上，跳了槽，涨了工资；学习上，啃了几本名著（Effective Java、重构 改善既.
Java基础知识总结（超详细整理）
龙源IT 的博客
07-17 30万+
Java语言的特点，1.面向对象(OOP)就是Java语言的基础，也是Java语言的重要特性。面向对象的概念：生活中的一切事物都可以被称之为对象，生活中随处可见的事物就是一个对象，我们可以将这些事物的状态特征（属性）以及行为特征（方法）提取并出来，并以固定的形式表示。 2.简单好用，Java语言是由C和C++演变而来的，它省略了C语言中所有的难以理解、容易混淆的特性（比如指针），变得更加严谨、简洁、易使用。 3.健壮性、Java的安全检查机制，将许多程序中的错误扼杀在摇蓝之中。 另外，在
Java基础面试题整理
Java笔记
02-08 24万+
面向对象的三个特征 封装,继承,多态.这个应该是人人皆知.有时候也会加上抽象. 多态的好处 允许不同类对象对同一消息做出响应,即同一消息可以根据发送对象的不同而采用多种不同的行为方式(发送消息就是函数调用).主要有以下优点: 可替换性:多态对已存在代码具有可替换性. 可扩充性:增加新的子类不影响已经存在的类结构. 接口性:多态是超类通过方法签名,向子类提供一个公共接口,由子类来完善或者...
Java 基础常见面试题整理
搬砖农民工的博客
04-25 7570
Java基础常见面试题
java基础知识点
学Java，找哪吒
09-18 2万+
🏆作者简介：哪吒，CSDN2022博客之星Top1、CSDN2021博客之星Top2、多届新星计划导师✌、博客专家💪，专注Java硬核干货分享，立志做到Java赛道全网Top N。🏆本文收录于，，目前已经700+订阅，CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。🏆姐妹篇，，包含面向对象、基本数据类型、数组、继承和多态、泛型、枚举等Java基础知识点。🏆姐妹进阶篇，
Java基础知识点汇总
qq_41286666的博客
05-04 4万+
Java基础知识点汇总1. Java基础语法2. 面向对象3. 异常处理4. 集合5. IO流 1. Java基础语法 类型转换 // 强制类型转换 float a = 20.34f; int b = (int)a; //自动类型转换 int c = 10; float d = c; //操作较大的数时，注意溢出问题 //JDK7新特性，数字之间可以用下划线分割
Java基础知识面试题（2020最新版）
ThinkWon的博客
02-19 131万+
文章目录Java概述何为编程什么是Javajdk1.5之后的三大版本JVM、JRE和JDK的关系什么是跨平台性？原理是什么Java语言有哪些特点什么是字节码？采用字节码的最大好处是什么什么是Java程序的主类？应用程序和小程序的主类有何不同？Java应用程序与小程序之间有那些差别？Java和C++的区别Oracle JDK 和 OpenJDK 的对比基础语法数据类型Java有哪些数据类型switc...
JAVA基础知识点总结
sen_sen97的博客
07-11 1万+
Java 是一门面向对象的编程语言。 语言特点：面向对象，平台无关性，支持多线程，编译与解释并存JVM：Java Virtual Machine，Java 虚拟机。 JRE： Java 运⾏时环境。 JDK: Java Development Kit，它是功能⻬全的 Java SDK。 JDK 包含 JRE，JRE 包含 JVM。Java 程序从源代码到运行主要有三步： 编译：将我们的代码（.java）编译成虚拟机可以识别理解的字节码(.class) 解释：虚拟机执行 Java 字节码，将字节码翻译成机器能
java笔记整理(超详细) java笔记整理(超详细)
07-14
- 抽象类可以有方法实现，只能单继承，提供部分实现，作为子类的基础。 9. **变量类型**： - 成员变量属于类，存在于堆内存，生命周期与对象相同；局部变量存在于栈内存，随着方法调用结束而销毁。 10. **异常...
java基础整理笔记超详细
07-17
【Java基础整理笔记超详细】 Java是一门广泛使用的高级编程语言，由Sun Microsystems（后被Oracle收购）在1995年推出。它的设计目标是跨平台、面向对象，并且具有健壮性和安全性。Java这个名字源于印度尼西亚的咖啡...
JavaWEB基础知识整理.rar_Java WEB 开发基础知识整理
09-24
这份"JavaWEB基础知识整理.rar"压缩包提供了一份详细的Java Web开发基础教程，适合初学者和有一定经验的开发者进行复习和巩固。以下是对其中核心知识点的详细解读： 1. **Java Web概述** - Java Web开发主要涉及...
java基础单词整理
10-02
java单词入门整理,包括java基础,前端基础,web以及框架,适用于初学者.
spring事务详细讲解-深入浅出
小电玩
09-08 542
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1527
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
Java集合：Stack详解
最新发布
yang_brother的博客
09-10 590
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 626
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
Java基础面试题整理详解
Java基础面试题整理（附答案） 本文将从 Java 基础面试题中整理出重要的知识点，涵盖面向对象编程、访问修饰符、基本数据类型、运算符、内存管理等方面。 一、面向对象的特征 Java 中面向对象编程的特征有三个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值