Java多线程（超详细！）

最新推荐文章于 2024-06-19 21:11:55 发布
最新推荐文章于 2024-06-19 21:11:55 发布
阅读量315 收藏
点赞数
分类专栏： 面试 学习路线 阿里巴巴资料职业发展 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74823507/article/details/133744443
版权

1、什么是进程？什么是线程？

进程是:一个应用程序（1个进程是一个软件）。

线程是：一个进程中的执行场景/执行单元。

注意：一个进程可以启动多个线程。

eg.
对于java程序来说，当在DOS命令窗口中输入：
java HelloWorld 回车之后。会先启动JVM，而JVM就是一个进程。

JVM再启动一个主线程调用main方法（main方法就是主线程）。
同时再启动一个垃圾回收线程负责看护，回收垃圾。

最起码，现在的java程序中至少有两个线程并发，一个是 垃圾回收线程，一个是 执行main方法的主线程。

2、进程和线程是什么关系？

进程：可以看做是现实生活当中的公司。

线程：可以看做是公司当中的某个员工。

注意：
进程A和进程B的 内存独立不共享。

eg.
魔兽游戏是一个进程
酷狗音乐是一个进程
这两个进程是独立的，不共享资源。

线程A和线程B是什么关系？

在java语言中：

线程A和线程B，堆内存 和 方法区 内存共享。但是 栈内存 独立，一个线程一个栈。

eg.
假设启动10个线程，会有10个栈空间，每个栈和每个栈之间，互不干扰，各自执行各自的，这就是多线程并发。

eg.
火车站，可以看做是一个进程。
火车站中的每一个售票窗口可以看做是一个线程。
我在窗口1购票，你可以在窗口2购票，你不需要等我，我也不需要等你。所以多线程并发可以提高效率。

java中之所以有多线程机制，目的就是为了 提高程序的处理效率。

3、思考一个问题

使用了多线程机制之后，main方法结束，是不是有可能程序也不会结束？

main方法结束只是主线程结束了，主栈空了，其它的栈(线程)可能还在压栈弹栈。

4.分析一个问题

对于单核的CPU来说，真的可以做到真正的多线程并发吗？

对于多核的CPU电脑来说，真正的多线程并发是没问题的。4核CPU表示同一个时间点上，可以真正的有4个进程并发执行。

单核的CPU表示只有一个大脑：
不能够做到真正的多线程并发，但是可以做到给人一种“多线程并发”的感觉。

对于单核的CPU来说，在某一个时间点上实际上只能处理一件事情，但是由于CPU的处理速度极快，多个线程之间频繁切换执行，给别人的感觉是：多个事情同时在做！！！

eg.
线程A：播放音乐

线程B：运行魔兽游戏

线程A和线程B频繁切换执行，人类会感觉音乐一直在播放，游戏一直在运行，
给我们的感觉是同时并发的。（因为计算机的速度很快，我们人的眼睛很慢，所以才会感觉是多线程！）

4、什么是真正的多线程并发？

t1线程执行t1的。
t2线程执行t2的。
t1不会影响t2，t2也不会影响t1。这叫做真正的多线程并发。

5、关于线程对象的生命周期（附图)？★★★★★

  1. 新建状态
  2. 就绪状态
  3. 运行状态
  4. 阻塞状态
  5. 死亡状态

在这里插入图片描述

线程构造方法

构造方法名

备注

Thread()

Thread(String name)

name为线程名字

创建线程第二种方式

Thread(Runnable target)

Thread(Runnable target, String name)

name为线程名字

6、java语言中，实现线程有两种方式

第一种方式：

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

  1. 怎么创建线程对象？ new继承线程的类。
  2. 怎么启动线程呢？ 调用线程对象的 start() 方法。

伪代码：

// 定义线程类
public class MyThread extends Thread{
	public void run(){
	
	}
}
// 创建线程对象
MyThread t = new MyThread();
// 启动线程。
t.start();

eg.

public class ThreadTest02 {
    public static void main(String[] args) {
        MyThread t = new MyThread();
        // 启动线程
        //t.run(); // 不会启动线程，不会分配新的分支栈。（这种方式就是单线程。）
        t.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);
        }
    }
}

注意：

  • t.run() 不会启动线程，只是普通的调用方法而已。不会分配新的分支栈。（这种方式就是单线程。）

  • t.start() 方法的作用是：启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码任务完成之后，瞬间就结束了。
    这段代码的任务只是为了开启一个新的栈空间，只要新的栈空间开出来，start()方法就结束了。线程就启动成功了。
    启动成功的线程会自动调用run方法，并且run方法在分支栈的栈底部（压栈）。
    run方法在分支栈的栈底部，main方法在主栈的栈底部。run和main是平级的。

调用run()方法内存图：
在这里插入图片描述

调用start()方法内存图：
在这里插入图片描述

第二种方式：

编写一个类，实现 java.lang.Runnable 接口，实现**run方法**。

  1. 怎么创建线程对象？ new线程类传入可运行的类/接口。
  2. 怎么启动线程呢？ 调用线程对象的 start() 方法。

伪代码：

// 定义一个可运行的类
public class MyRunnable implements Runnable {
	public void run(){
	
	}
}
// 创建线程对象
Thread t = new Thread(new MyRunnable());
// 启动线程
t.start();

eg.

public class ThreadTest03 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable()); 
        // 启动线程
        t.start();
        
        for(int i = 0; i < 100; i++){
            System.out.println("主线程--->" + i);
        }
    }
}

// 这并不是一个线程类，是一个可运行的类。它还不是一个线程。
class MyRunnable implements Runnable {
    @Override
    public void run() {
        for(int i = 0; i < 100; i++){
            System.out.println("分支线程--->" + i);
        }
    }
}
采用匿名内部类创建：
public class ThreadTest04 {
    public static void main(String[] args) {
        // 创建线程对象，采用匿名内部类方式。
        Thread t = new Thread(new Runnable(){
            @Override
            public void run() {
                for(int i = 0; i < 100; i++){
                    System.out.println("t线程---> " + i);
                }
            }
        });

        // 启动线程
        t.start();

        for(int i = 0; i < 100; i++){
            System.out.println("main线程---> " + i);
        }
    }
}

注意：
第二种方式实现接口比较常用，因为一个类实现了接口，它还可以去继承其它的类，更灵活。

7、获取当前线程对象、获取线程对象名字、修改线程对象名字

方法名

作用

static Thread currentThread()

获取当前线程对象

String getName()

获取线程对象名字

void setName(String name)

修改线程对象名字

当线程没有设置名字的时候，默认的名字是什么？

  • Thread-0
  • Thread-1
  • Thread-2
  • Thread-3
  • …

eg.

class MyThread2 extends Thread {
    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);

            //System.out.println(super.getName() + "-->" + i);
            //System.out.println(this.getName() + "-->" + i);
        }
    }
}

8、关于线程的sleep方法

方法名

作用

static void sleep(long millis)

让当前线程休眠millis秒

  1. 静态方法：Thread.sleep(1000);
  2. 参数是毫秒
  3. 作用： 让当前线程进入休眠，进入“阻塞状态”，放弃占有CPU时间片，让给其它线程使用。
    这行代码出现在A线程中，A线程就会进入休眠。
    这行代码出现在B线程中，B线程就会进入休眠。
  4. Thread.sleep()方法，可以做到这种效果：
    间隔特定的时间，去执行一段特定的代码，每隔多久执行一次。

eg.

public class ThreadTest06 {
    public static void main(String[] args) {
    	//每打印一个数字睡1s
        for(int i = 0; i < 10; i++){
            System.out.println(Thread.currentThread().getName() + "--->" + i);

            // 睡眠1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

9、关于线程中断sleep()的方法

方法名

作用

void interrupt()

终止线程的睡眠

eg.

public class ThreadTest08 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable2());
        t.setName("t");
        t.start();

        // 希望5秒之后，t线程醒来（5秒之后主线程手里的活儿干完了。）
        try {
            Thread.sleep(1000 * 5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 终断t线程的睡眠（这种终断睡眠的方式依靠了java的异常处理机制。）
        t.interrupt();
    }
}

class MyRunnable2 implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "---> begin");
        try {
            // 睡眠1年
            Thread.sleep(1000 * 60 * 60 * 24 * 365);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //1年之后才会执行这里
        System.out.println(Thread.currentThread().getName() + "---> end");
}

10、补充：run()方法小知识点

在这里插入图片描述

为什么run()方法只能try…catch…不能throws？

因为run()方法在父类中没有抛出任何异常，子类不能比父类抛出更多的异常。

11、java中强行终止一个线程的执行（不推荐使用，了解即可！）

eg.

public class ThreadTest09 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable3());
        t.setName("t");
        t.start();

        // 模拟5秒
        try {
            Thread.sleep(1000 * 5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 5秒之后强行终止t线程
        t.stop(); // 已过时（不建议使用。）
    }
}

class MyRunnable3 implements Runnable {

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

注意：

这种方式存在很大的缺点：容易丢失数据。

因为这种方式是直接将线程杀死了，线程没有保存的数据将会丢失。不建议使用。

12、Java中合理结束一个进程的执行（常用）

eg.

public class ThreadTest10 {
    public static void main(String[] args) {
        MyRunable4 r = new MyRunable4();
        Thread t = new Thread(r);
        t.setName("t");
        t.start();

        // 模拟5秒
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 终止线程
        // 你想要什么时候终止t的执行，那么你把标记修改为false，就结束了。
        r.run = false;
    }
}

class MyRunable4 implements Runnable {

    // 打一个布尔标记
    boolean run = true;

    @Override
    public void run() {
        for (int i = 0; i < 10; i++){
            if(run){
                System.out.println(Thread.currentThread().getName() + "--->" + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else{
                // return就结束了，你在结束之前还有什么没保存的。
                // 在这里可以保存呀。
                //save....

                //终止当前线程
                return;
            }
        }
    }
}

为什么if()语句要在循环里面？

由于一个线程一直运行此程序，要是if判断在外面只会在启动线程时判断并不会结束，因此需要每次循环判断一下标记。

补充小知识：线程调度࿰

最低0.47元/天 解锁文章
m0_74823507
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
JAVA多线程详解（超详细）
01-07
JAVA多线程详解（超详细）
java中多线程的超详细介绍
08-25
Java中多线程的超详细介绍 Java中的多线程是指在同一个程序中同时执行多个线程的技术。多线程可以提高程序的效率和响应速度，使得程序更加灵活和高效。下面我们将对Java中的多线程进行详细的介绍。 线程概述 线程...
Java多线程超详解
热门推荐
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
编程必备：JAVA多线程详解
拾一二的博客
06-14 7887
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
java多线程
最新发布
m0_46702681的博客
06-19 1160
javajava。
Java线程详解
boilll的博客
11-29 762
自学笔记，自用
Java中实现多线程的几种方式
qq_25409421的博客
06-08 3万+
本文章介绍了Java中实现多线程的几种方式，介绍了各种实现方式的不同和优缺点
java创建多线程的四种方式
qq_47155894的博客
12-22 1614
java创建多线程的四种方式
Java多线程详解（超详细）_狂神说笔记完整版_项目代码_适合小白随课程学习
08-08
Java多线程详解 在Java编程中，多线程是一种重要的技术，它使得程序能够同时执行多个任务，提高系统的效率和响应性。本教程将详细讲解Java中的多线程概念，包括线程的创建、状态、同步以及高级主题，旨在帮助初学者...
Java多线程处理任务的封装
01-20
近公司项目很多地方使用多线程处理一些任务，逻辑代码和java多线程处理代码混合在一起，造成代码的可读性超级差，现在把Java多线程相关的处理抽出来，方面代码中重复使用。　  使用方法很简单，有两种使用方法 　...
超实用的Java并发多线程教程
04-19
Java并发多线程是Java编程中的重要组成部分，它允许程序同时执行多个任务，极大地提高了程序的效率和响应性。在Java中，多线程主要通过`Thread`类、`Runnable`接口以及`ExecutorService`来实现。下面我们将深入探讨...
基于多线程的简单小游戏的制作
03-25
此游戏的工程 博文链接：https://hwfantasy.iteye.com/blog/1142136
一文搞懂Java多线程，讲的很详细，收藏起来慢慢看
兴趣是最好的老师，勤能补拙
07-05 2001
多线程是指在一个程序中同时执行多个线程，每个线程都有自己独立的执行路径。在多线程中，程序的执行可以同时进行多个任务，从而提高系统的资源利用率和响应性能。在传统的单线程编程模型中，程序按照顺序执行，一次只处理一个任务。这种方式在某些情况下可能会导致效率低下或者无法满足需求。而多线程通过将任务拆分为多个子任务，并且在不同的线程上同时执行，从而实现并发处理。
【Java之多线程篇】——吐血整理Java多线程详解（知识点+代码）
qq_50497708的博客
03-25 6178
目录： 线程基本概念 并行\并发的区别 多线程优点和何时使用多线程 多线程创建的两种方式：继承Thread类、实现Runnable接口（代码） 线程的生命周期 线程的同步 用线程同步解决线程安全问题的方式（一）：同步代码快、同步方法、Lock锁（代码） 死锁 线程通信的例子——涉及wait()、notify()、notifyAll()） 面试题：sleep()和wait()的异同 生产者和消费者例题 用线程同步解决线程安全问题的方式（二）：实现Callable()接口、线程池 基本
超详细JAVA基础——多线程
qq_45781655的博客
04-12 2万+
学会Java多线程，只看一个博客就够了！
(13)线程b
05-07 261
1…线程间通信   线程间通信:同一堆数据,一个线程在往里面存数据一个线程在取数据,他们同时进行,这2个线程运行代码不一样,动作不一致就代表着有2个run方法来存放运行代码,2个run方法在2个类当中   线程间通讯： 其实就是多个线程在操作同一个资源， 但是操作的动作不同。 class Res {     private String name;     private
java多线程实现的2种方式详解、比较、匿名内部类实现多线程的方法
m0_45877477的博客
06-08 512
实现Runnable接口的好处 1 避免的单继承的局限性 (一个类只能继承一个类,一个人只能有1个亲爹) 实现Runnable接口还可以继承其他类,实现其他接口 2 增强了程序的扩展性,降低了程序的耦合性(解耦) 实现Runnable接口 把设置线程任务和开启新线程进行了分离 设置线程任务:Runnable接口中重写run()方法 开启新线程:创建的Thread类调用start()方法...............
Java多线程 匿名内部类实现多线程
nicolas9974
06-23 1507
class ThreadTest { public static void main(String[] args) { new Thread() { public void run() { for(int x=0; x<100; x++) { System.out.println(Thread.currentThread().getNam
Java基础-线程（十个线程实现1~100求和）
渴鱼y. . 。.
11-25 1万+
这道题我大概搞了两个小时左右吧。 可是我发现总是不对，最后发现我做不出来了，因为我并未真正搞清整个程序的执行，以及对那些关键词（我指的是synchronized、wait()、notify()等这些玩意儿）的理解和使用都不清楚，更别说写出来整个程序了。 public class Forth2 { public static void main(String[] args) { MyRunna...
Java语言特性详解：面向对象、多线程与封装
Java语言的特点是其简单易学、面向对象、平台无关性、可靠性、安全性、多线程支持以及对网络编程的良好适应。平台无关性是通过Java虚拟机（JVM）实现的，使得Java程序可以在任何安装了JVM的平台上运行。多线程特性...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值