有没有一种可能，我可以学好Java的多线程——知识点汇总

最新推荐文章于 2024-10-06 20:16:20 发布
最新推荐文章于 2024-10-06 20:16:20 发布
阅读量122 收藏
点赞数
分类专栏： 秋招 Java java基础 文章标签： java jvm servlet 架构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Park33/article/details/126067973
版权
Java 同时被 3 个专栏收录
274 篇文章 1 订阅
订阅专栏
秋招
101 篇文章 0 订阅
订阅专栏
java基础
12 篇文章 0 订阅
订阅专栏

一、前言

这篇文章是介绍Java基础知识——多线程的，读完这篇文章，各位小伙伴们可以收获哪些呢？

  • 程序、进程、线程三者的区别
  • 创建线程的四种方式
  • 线程的常用方法
  • 线程的死锁、释放锁
  • 线程的同步原理、生命周期等等

废话不多说，干货满满，赶快来看看吧~

二、基本概念

什么是程序？

  • 程序是为完成特定任务、用某种语言编写的一组指令的集合。大白话来讲，就是我们写的代码

什么是进程？

  • 进程是程序的一次执行过程，或是正在运行的一个程序。例如运行中的QQ、微信，运行中的MP3播放器等等，有它自身的产生、存在和消亡的过程

什么是线程？

  • 线程是由进程创建的，是进程的一个实体，一个进程可以拥有多个线程，也可以有单个线程

三、创建线程

1、方式一

继承 Thread类 ，看代码：

public class Thread_one {
    public static void main(String[] args) throws InterruptedException {
        Person person = new Person();
        person.start();
        //当启动线程时，子线程和主线程会交替执行
        //主线程结束，子线程不一定结束
        //person.run()就是一个普通的方法，没有真正的启动一个线程
        for (int i = 0; i < 20; i++) {
            System.out.println("main线程执行");
            Thread.sleep(1000);
        }
    }
}
class Person extends Thread {
    @Override
    public void run() {
        int times = 0;
        while (true) {
            try {
                System.out.println("大家好，我是卷心菜~"
                        + (++times)
                        + "号" + "线程名是——"
                        + Thread.currentThread().getName());
                Thread.sleep(2000);
                if (times == 50) break;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

该代码的功能是：启动一个子线程，在控制台打印50次 “大家好，我是卷心菜” ，主线程在控制台打印 “main线程执行” ，运行的部分结果如下：

我们来重点剖析一下这种创建方式，因为后面三种方式本质上区别不大。

当我们 Person类 继承 Thread类 以后，就要重写 run() ，方法体内写上自己需要的代码逻辑。语句 Thread.sleep(2000); 意思是，每打印一句话在控制台后，子线程就要“休息”2秒，在这“休息”的时间，主线程就开始执行自己的语句；同样，在主线程“休息”的时间，子线程也开始执行自己的语句。

总之，子线程和主线程会交替执行，多次运行可以发现，主线程结束，子线程不一定结束。这里需要特别注意。

爱思考的小伙伴们可能就要问了：我们在Person类中重写了run()，但是怎么使用线程的时候，调用的是start()，那run()谁来执行的呢？别着急，让我们进去源码看一看。

我们从源码中可以发现，start()调用了start0()，而start0()是一个本地方法，由JVM调用，只是我们看不到而已。

2、方式二

方式一明白了，再看看第二种方式，代码如下：

public class Thread_two {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Thread thread = new Thread(animal);
        thread.start();
    }
}
class Animal implements Runnable {
    int times = 0;
    @Override
    public void run() {
        while (true) {
            System.out.println("大家好，我是Tomcat~");
            try {
                Thread.sleep(2000);
                ++times;
                if (times == 10) break;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

此代码逻辑也很好理解，这里就不过多讲述了。我们来分析一下：为什么要使用类实现接口的方式来创建线程？

学过基础的小伙伴们都知道，我们Java是单继承的。因此，在某些情况下一个类可能已经继承了某个类，这时再用继承Thread类方法来创建线程就不可以了，所以我们有了Runnable接口。

3、方式三

再来看看方式三，代码如下：

public class Thread_six {
    public static void main(String[] args) throws Exception {
        D d = new D();
        FutureTask futureTask = new FutureTask(d);
        Thread thread = new Thread(futureTask);
        thread.start();
        Object o = futureTask.get();
        System.out.println(o);
    }
}
class D implements Callable {
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 5; i++) {
            System.out.println(i + 1);
            sum += i;
        }
        return sum;
    }
}

来看看运行结果：

与 Runnable类 相比，类 Callable 功能更强大些，具体有如下优点：

  • 相比run()方法，可以有返回值
  • 方法可以抛出异常
  • 支持泛型的返回值
  • 需要借助FutureTask类，比如获取返回结果

4、方式四

最后来看看第四种方式，使用线程池，也是最推荐使用的方式，代码如下：

public class Thread_seven {
    public static void main(String[] args) {
        ExecutorService service =
                Executors.newFixedThreadPool(10);
//        service 可以理解为池子
        service.execute(new F()); //适用于Runnable
//        service.submit();  //适用于Callable
        service.shutdown();//关闭线程池
    }
}
class F implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(i + 1);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果没有任何问题：

四、常用方法

1、第一组

  • public Thread(Runnable target)：返回对当前正在执行的线程对象的引用
  • public synchronized void start()：开启线程
  • public final synchronized void setName(String name)：设置线程名
  • public final void setPriority(int newPriority)：设置线程的优先级别
  • public static native void sleep(long millis)：设置线程的睡眠时间
  • public void interrupt()：中断线程，但并没有结束线程，一般用于中断正在休眠的线程

这么多的方法，用代码实践一下：

public class Thread_five {
    public static void main(String[] args) {
        A a = new A();
        Thread thread = new Thread(a);
        thread.setName("棒棒糖线程");
        thread.setPriority(Thread.MIN_PRIORITY);
        thread.start();
        thread.interrupt();
        for (int i = 0; i < 20; i++) {
            System.out.println("主线程开始行动");
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class A implements Runnable {
    @Override
    public void run() {
        while (true) {
            try {
                for (int i = 0; i < 10; i++) {
                    System.out.println("我要吃" + (i + 1) +
                            "棵棒棒糖，所处的线程是："
                            + Thread.currentThread().getName());
                }
                System.out.println("吃多了，要消化20秒");
                Thread.sleep(20000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

带大家看一下线程的优先级：

MAX_PRIORITY：10 
MIN _PRIORITY：1
NORM_PRIORITY：5

截取一部分运行结果：

解析一下：由于把子线程的优先级设置为最低，主线程拿到了优先执行的语句，输出 "主线程开始行动" ，然后在主线程睡眠时间时，子线程开始执行，当执行完：吃多了，要消化20秒时，本应该等待20秒，但是interrupt()打断了子线程，所以就会出现上图的情况。

如果把语句 thread.interrupt(); 删去，就会出现下图的结果：

2、第二组

  • public final void join()：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止
  • public static native void yield()：暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程

直接上代码演示：

public class Thread_one {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        Thread thread = new Thread(t);
        thread.start();
        for (int i = 0; i < 15; i++) {
            Thread.sleep(100);
            System.out.println("主线程吃了" + (i+ 1) + "颗棒棒糖");
            if (i == 4) {
                System.out.println("让子线程先吃吧");
                thread.join();
//                thread.yield();
                System.out.println("子线程吃完了，该我了");
            }
        }
    }
}
class T implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程吃了" + (i + 1) + "颗棒棒糖");
        }
    }
}

运行结果：

由代码和运行结果图可以看出：因为语句 thread.join(); 的出现，导致主线程必须等到子线程结束后才能继续执行自己的代码，这就是 join() 的作用。

五、守护线程

Java中的线程分为两类：一种是守护线程，一种是用户线程。 它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。

守护线程是用来服务用户线程的，通过在start()方法前调用 thread.setDaemon(true) 可以把一个用户线程变成一个守护线程。

下面用代码演示一下：

public class Thread_two {
    public static void main(String[] args) throws InterruptedException {
        A a = new A();
        Thread thread = new Thread(a);
        //下面的方法要在start方法使用前使用，目的是当我们希望main方法结束后，子线程也可以结束；即把子线程设为守护线性
        thread.setDaemon(true);
        thread.start();
        for (int i = 0; i < 10; i++) {
            Thread.sleep(100);
            System.out.println("我在疯狂打游戏~");
        }
    }
}
class A  implements Runnable{
    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(1000);
                System.out.println("室友们在努力内卷学习~");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

即当语句 我在疯狂打游戏 结束之后，守护线程的执行语句 室友们在努力内卷学习 就结束了，不在执行。

六、生命周期

要想实现多线程，必须在主线程中创建新的线程对象。我们可以使用Thread类 及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五 种状态：

  • 新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建 状态
  • 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已 具备了运行的条件，只是没分配到CPU资源
  • 运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线 程的操作和功能
  • 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中 止自己的执行，进入阻塞状态
  • 死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

    代码演示一下：
public class Thread_three {
    public static void main(String[] args) throws InterruptedException {
        B b = new B();
        Thread thread = new Thread(b);
        System.out.println(thread.getName() + "状态为" + thread.getState());
        thread.start();
        //只要子线程状态不是终止状态，就继续查看子线程的状态
        while (Thread.State.TERMINATED != thread.getState()) {
            System.out.println(thread.getName() + "状态" + thread.getState());
            Thread.sleep(500);
        }
        System.out.println(thread.getName() + "状态" + thread.getState());
    }
}
class B implements Runnable {
    @Override
    public void run() {
        while (true) {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                    System.out.println("我说了" + (i + 1) + "次Hi");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            break;
        }
    }
}

运行结果：

七、线程的同步

下面案例都以模仿卖票入手，解决卖超的情形

1、方式一

  • 同步方法
public class Thread_four {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        Thread thread1 = new Thread(ticket);
        Thread thread2 = new Thread(ticket);
        thread1.start();
        thread2.start();
    }
}
class Ticket implements Runnable{

    private int tickets = 30;
    @Override
    public synchronized void run() {
        while (true) {
            try {
                if (tickets <= 0) {
                    System.out.println("票没了，售票结束！");
                    break;
                }
                System.out.println("窗口" + Thread.currentThread().getName()
                        + "出售了一张票，还剩下"
                        + --tickets + "张票");
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果：

2、方式二

  • 同步代码块
class Ticket implements Runnable {
    private int tickets = 30;
    @Override
    public void run() {
        synchronized (this) {
            while (true) {
                try {
                    if (tickets <= 0) {
                        System.out.println("票没了，售票结束！");
                        break;
                    }
                    System.out.println("窗口" + Thread.currentThread().getName()
                            + "出售了一张票，还剩下"
                            + --tickets + "张票");
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

八、锁

1、死锁

public class Thread_five {
    public static void main(String[] args) {
        DeadLock deadLock1 = new DeadLock(true);
        DeadLock deadLock2 = new DeadLock(false);

        Thread thread1 = new Thread(deadLock1);
        Thread thread2 = new Thread(deadLock2);
        thread1.start();
        thread2.start();
    }
}

class DeadLock implements Runnable {
    static Object o1 = new Object();// 保证多线程，共享一个对象,这里使用 static
    static Object o2 = new Object();
    boolean flag;
    public DeadLock(boolean flag) {
        this.flag = flag;
    }
    @Override
    public void run() {
        //下面业务逻辑的分析 //1. 如果 flag 为 T, 线程 A 就会先得到/持有 o1 对象锁, 然后尝试去获取 o2 对象锁
        // 2. 如果线程 A 得不到 o2 对象锁，就会 Blocked
        // 3. 如果 flag 为 F, 线程 B 就会先得到/持有 o2 对象锁, 然后尝试去获取 o1 对象锁
        // 4. 如果线程 B 得不到 o1 对象锁，就会 Blocked
        if (flag) {
            synchronized (o1) {//对象互斥锁, 下面就是同步代码
                System.out.println(Thread.currentThread().getName() + " 进入 1");
                synchronized (o2) { // 这里获得 li 对象的监视权
                    System.out.println(Thread.currentThread().getName() + " 进入 2");
                }
            }
        } else {
            synchronized (o2) {
                System.out.println(Thread.currentThread().getName() + " 进入 3");
                synchronized (o1) { // 这里获得 li 对象的监视权
                    System.out.println(Thread.currentThread().getName() + " 进入 4");
                }
            }
        }
    }
}

运行结果：

2、释放锁

因为不好演示，所以就介绍一下释放锁的各种情况：

  • 当前线程的同步方法、同步代码块执行结束
  • 当前线程在同步代码块、同步方法中遇到break、return
  • 当前线程在同步代码块、同步方法中出现了未处理的ERROR、Exception，导致异常结束

最后再介绍不会释放锁的情况：

  • 线程执行同步代码块或同步方法时，程序调用sleep()、yield()暂停当前线程的执行，不会释放锁
  • 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程也不会释放锁

总结

乐莫乐兮新相知，很高兴各位小伙伴可以坚持看完这篇文章。 一起加油，一起进步！

「已注销」
关注
专栏目录
Java多线程模拟售票系统
nianbingsihan的博客
05-16 1万+
Java创建多线程的两种基本方法:方法1.继承Thread类(1)定义子类,继承Thread类,重写该类的run()方法作为线程执行体;(2)创建该子类的实例作为线程对象;(3)调用线程对象的start()方法来启动线程;我们以模拟火车售票系统为例:public class SellTicket { public static void main(String[] args) { for(...
Java简单的多线程卖票
weixin_52210086的博客
04-09 4388
package xiancheng; /* 定义一个MaiPiao类实现Runnable接口，里面定义一个成员变量: private int tickets =100(票数); 在类中重写run()方法实现卖票，代码步骤如下 1：判断票数大于0，就卖票，并告知是哪个窗口卖的 2:卖了票之后，总票数要减1 3：票没有了，也可能有人来问，所以这里用死循环让卖票的动作一直执行 定义一个测试类MaiPiaoDemo，里面有main方法，代码步骤如下 1:创建MaiPiao类的对象 2:创建三个Th.
JAVA多线程实现龟兔赛跑
小菜鸟的博客
10-13 2万+
要求 1、兔子每秒跑5米，但是每10米要休息2秒 2、乌龟每秒钟4米，不休息 3、谁先到达终点，比赛结束 首先创建一个动物类Animal package com.th.animal; import java.util.concurrent.CyclicBarrier; import java.util.concurrent.ExecutorService; publ
java多线程售票例子
小泽
05-15 515
代码如下: public class Ticket1 implements Runnable { private int tickets = 100; @Override public void run() { while (tickets > 0) { synchronized (Ticket.class) { if (tickets > 0) { ...
Java入门到架构师知识点整理，P8的技术大咖是这样通关的
前端工程师年薪30万，就靠这套教程！持续更新最新知识
04-08 1042
一个人最怕的不是路途遥远，而是看不到胜利曙光。我希望下面这篇文章能给你的学习之路带来一丝曙光，大家不妨试着读一下吧，如果有收获给我点个赞哟。 温馨提醒：这篇文章写着写着就一万字了，建议大家关注后再收藏，以防走丢。 这篇文章主要内容包括(干货满满)： 学Java有哪些就业方向？ 数据结构和算法 设计模式 计算机基础 Java 入门 Java 高手进阶 基础框架（SSM） 微服务框架 常用中间件 数据库 分布式架构 必须掌握的工具软件 学习资源网站列表汇总 学习常见问题（FAQ） 买一瓶可乐，泡一杯咖啡
牛逼！Java 从入门到精通，超全汇总版
热门推荐
程序员cxuan的个人主页
05-06 7万+
文章目录Java 基础Head First JavaJava 核心技术卷一Java 编程思想设计模式Head First 设计模式图解设计模式设计模式重学 Java 设计模式Java 进阶Java 并发编程实战Java 并发编程艺术Java 并发编程之美图解Java多线程设计模式JVM深入理解 Java 虚拟机Java 虚拟机规范HotSpot 实战自己动手写 Java 虚拟机MySQLMySQL 基础教程SQL 基础教程深入浅出 MySQLMySQL 必知必会SQL 必知必会高性能 MySQLMySQL
为什么你学过Java却忘光了——记第一次助教同学见面会，java开发面试笔试题
ccc_ccc8的博客
04-23 513
我总结出了很多互联网公司的面试题及答案，并整理成了文档，以及各种学习的进阶学习资料，免费分享给大家。 扫描二维码加VX好友，拉你进【程序员面试学习交流群】免费领取。也欢迎各位一起在群里探讨技术。 大约两周之前，主讲老师刘志勇老师和我约定，让我上周四到课堂上和同学们认识、交流一下。一开始我不太明了去和大家见面要说些什么，也不太理解这么做的必要性是什么。但随着日子临近，我请教了周筠老师，周筠...
一文彻底理解并发编程中非常重要的票据锁——StampedLock
冰河的专栏
06-09 785
冰河曾经说过：周末和假期假期是超越他人的最好时机，悄悄努力，然后惊艳所有人。
送你九年经验，我的Java学习之路你也可以复制
SUNXIOAJIE的博客
03-24 675
这篇文章写的非常认真，足足花了两周时间，不是简单的资料聚合，我将多年的工作和学习经验写下来了，相信看完后你能有一种豁然开朗的感觉，这就是我要达到的目的，希望不要被打脸。 最近身边很多人在问：Java 怎么学习啊？有没有什么学习路线？ 我相信这些人或多或少都有一些 Java 基础，但由于看不到全貌，学了一段时间很容易迷失。所以我在寻思着能不能写一个学习的地图或者路线，让读者能知道下一步该学什么，自己离大厂的 offer还有多远的距离。 一个人最怕的不是路途遥远，而是看不到胜利曙光。我希望下面这篇文章能给
Java中级面试常见题目+答案
oooorrr的博客
03-01 1万+
@ 一.基础知识 1.集合类：List和Set比较，各自的子类比较（ArrayList，Vector，LinkedList；HashSet，TreeSet）； 2.HashMap的底层实现，之后会问ConcurrentHashMap的底层实现； 3.如何实现HashMap顺序存储：可以参考LinkedHashMap的底层实现； 4.HashTable和ConcurrentHashMap的区别； 5.String,StringBuffer和StringBuilder的区别； 6.Object的方法有哪些：比如
Python史上最全知识重点（超详细版）进阶篇
xiaolinyui的博客
11-04 763
Python史上最全知识重点（超详细版）进阶篇，python进阶重点知识。
2020校招复盘——秋招不易，致敬每一位追梦者（含网易、京东等19家互联网公司后台/Server端面经）
ZY-JIMMY
10-18 3万+
秋招经历、秋招心得、C++后台/Server端方向校招准备、面经整理、面经题库
java面试突击
qq_42882477的博客
02-23 9565
时间 版本 说明 2019-2-27 v 1.0 初版发布 2019-3-2 v 2.0 对于第一版进行了大幅度更新，除了修改了一些小错误之外，还增加了一些内容。 2019-4-18 v3.0 修复错误，完善内容，增加了少部分内容。 必看 本文档由 SnailClimb 整理，文章大部分内容来源于本人的开源项目 JavaGuide，你可以把这个文档看做JavaGuide 的精简版，适合面试前的突击...
2024年最新大数据进阶之路——Spark SQL小结_spark sql进阶(1)
2401_84692226的博客
05-02 946
Python崛起并且风靡，因为优点多、应用领域广、被大牛们认可。学习 Python 门槛很低，但它的晋级路线很多，通过它你能进入机器学习、数据挖掘、大数据，CS等更加高级的领域。Python可以做网络应用，可以做科学计算，数据分析，可以做网络爬虫，可以做机器学习、自然语言处理、可以写游戏、可以做桌面应用…Python可以做的很多，你需要学好基础，再选择明确的方向。这里给大家分享一份全套的 Python 学习资料，给那些想学习 Python 的小伙伴们一点帮助！
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 882
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
JDK1.0主要特性
最新发布
FoolRabbit的专栏
10-06 285
JDK1.0主要特性。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 489
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring依赖注入和注解驱动详解和案例示范
J老熊
10-01 1000
在 Spring 框架中，依赖注入（Dependency Injection, DI）和注解驱动（Annotation-Driven）是其核心机制，它们为 Spring 应用提供了灵活性和可扩展性。依赖注入简化了对象间的依赖管理，而注解驱动则通过简洁的注解配置取代了繁琐的 XML 配置。本文将详细分析这两个机制，并通过示例加深理解。
如何学好Java多线程
05-02
学习Java多线程需要掌握...学习Java多线程需要掌握上述基础知识，同时需要多做练习，熟悉多线程编程的常见问题和解决方法。可以参考一些经典的多线程编程书籍，如《Java并发编程实战》、《Java多线程编程核心技术》等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值