Java编程核心基础（五）—线程

最新推荐文章于 2025-10-13 06:41:44 发布
原创 最新推荐文章于 2025-10-13 06:41:44 发布 · 245 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文详细介绍了Java中的线程概念，包括进程的独立性、动态性和并发性，以及线程作为进程的子单元。讨论了线程的创建方式，包括继承Thread类、实现Runnable接口和Callable接口，并分析了各自的优缺点。此外，还阐述了线程的常用API，如线程命名、休眠以及线程安全问题，提到了线程同步的同步代码块、同步方法和Lock显示锁。线程通信的wait、notify和notifyAll方法也在文中提及。

#top 写在最前面
水滴石穿，稳固基础，基础永远是最需要注重的
文章仅作为JAVA编程复习使用
文章参考博主：<狂神说>、<生命是有光的>

9、线程

9-1、什么是进程？

答：程序是静止的，运行中的程序就是进程

9-2、进程的三个特征

  1. 独立性：进程与进程之间是相互独立的，彼此有自己独立内存区域
  2. 动态性：进程是运行中的程序，要动态的占用内存，CPU和网络等资源
  3. 并发性：CPU会分时轮询切换依次为每个进程服务，因为切换的速度非常快，给我们的感觉像是在同时执行，这就是并发性
    1. 并发：同一时刻同时有多个在执行

9-3、什么是线程？

答：线程是属于进程的，一个进程可以包含多个线程，这就是多线程
从 JVM 角度说进程和线程之间的关系

在这里插入图片描述
从上图可以看出：一个进程中可以有多个线程，多个线程共享进程的堆和方法区 (JDK1.8 之后的元空间)资源，但是每个线程有自己的程序计数器、虚拟机栈 和 本地方法栈。

总结： 线程 是 进程 划分成的更小的运行单位。线程和进程最大的不同在于基本上各进程是独立的，而各线程则不一定，因为同一进程中的线程极有可能会相互影响。线程执行开销小，但不利于资源的管理和保护；而进程正相反

下面是该知识点的扩展内容！

下面来思考这样一个问题：为什么程序计数器、虚拟机栈和本地方法栈是线程私有的呢？为什么堆和方法区是线程共享的呢？

9-4、线程的创建方式（三种）

多线程是很有用的，我们在进程中创建线程的方式有三种：

9-4-1、继承Thread类

  1. 定义一个线程类继承Thread类

  2. 重写run()方法

  3. 创建一个新的线程对象 Thread t = new MyThread();

  4. 调用线程对象的start()方法启动线程

    public class ThreadDemo {
    // 启动后的ThreadDemo当成一个进程。
    // main方法是由主线程执行的，理解成main方法就是一个主线程
    public static void main(String[] args) {
        // 3.创建一个线程对象
        Thread t = new MyThread();
        // 4.调用线程对象的start()方法启动线程,最终还是执行run()方法！
        t.start();
        
        
        for(int i = 0 ; i < 100 ; i++ ){
            System.out.println("main线程输出："+i);
        }
    }
}

// 1.定义一个线程类继承Thread类。
class MyThread extends Thread{
    // 2.重写run()方法
    @Override
    public void run() {
        // 线程的执行方法。
        for(int i = 0 ; i < 100 ; i++ ){
            System.out.println("子线程输出："+i);
        }
    }
}

9-4-2、实现Runnable接口

  1. 创建一个线程任务类实现Runnable接口

  2. 重写run()方法

  3. 创建一个线程任务对象（注意：线程任务对象不是线程对象，只是执行线程的任务的）

    Runnable target = new MyRunnable();

  4. 把线程任务对象包装成线程对象,且可以指定线程名称

    // Thread t = new Thread(target);
Thread t = new Thread(target,"1号线程");

  5. 调用线程对象的start()方法启动线程

    public class ThreadDemo {
    public static void main(String[] args) {
        // 3.创建一个线程任务对象(注意：线程任务对象不是线程对象，只是执行线程的任务的)
        Runnable target = new MyRunnable();
        // 4.把线程任务对象包装成线程对象.且可以指定线程名称
        // Thread t = new Thread(target);
        Thread t = new Thread(target,"1号线程");
        // 5.调用线程对象的start()方法启动线程
        t.start();

        Thread t2 = new Thread(target);
        // 调用线程对象的start()方法启动线程
        t2.start();

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

// 1.创建一个线程任务类实现Runnable接口。
class MyRunnable implements Runnable{
    // 2.重写run()方法
    @Override
    public void run() {
        for(int i = 0 ; i < 10 ; i++ ){
            System.out.println(Thread.currentThread().getName()+"==>"+i);
        }
    }
}
Thread的构造器
  • public Thread(){}
  • public Thread(String name){}
  • public Thread(Runnable target){}:分配一个新的Thread对象
  • public Thread(Runnable target,String name)：分配一个新的Thread对象,且可以指定新的线程名称
优缺点

缺点：代码复杂一点

优点：

  • 线程任务类只是实现了Runnable接口，可以继续继承其他类，而且可以继续实现其他接口(避免乐单继承的局限性)
  • 同一个线程任务对象可以被包装成多个线程对象

9-4-3、实现Callable接口 (全是优点)

  1. 定义一个线程任务类实现Callable接口，申明线程返回的结果类型
  2. 重写线程任务类的call方法，这个方法可以直接返回执行的结果
  3. 创建一个Callable的线程任务对象
  4. 把Callable的线程任务对象包装成一个未来任务对象
  5. 把未来任务对象包装成线程对象
  6. 调用线程的start()方法启动线程
public class ThreadDemo {
    public static void main(String[] args) {
        // 3.创建一个Callable的线程任务对象
        Callable call = new MyCallable();
        // 4.把Callable任务对象包装成一个未来任务对象
        //      -- public FutureTask(Callable<V> callable)
        // 未来任务对象是啥，有啥用？
        //      -- 未来任务对象其实就是一个Runnable对象:这样就可以被包装成线程对象！
        //      -- 未来任务对象可以在线程执行完毕之后去得到线程执行的结果。
        FutureTask<String> task = new FutureTask<>(call);
        // 5.把未来任务对象包装成线程对象
        Thread t = new Thread(task);
        // 6.启动线程对象
        t.start();

        for(int i = 1 ; i <= 10 ; i++ ){
            System.out.println(Thread.currentThread().getName()+" => " + i);
        }

        // 在最后去获取线程执行的结果,如果线程没有结果，让出CPU等线程执行完再来取结果
        try {
            String rs = task.get(); // 获取call方法返回的结果（正常/异常结果）
            System.out.println(rs);
        }  catch (Exception e) {
            e.printStackTrace();
        }

    }
}

// 1.创建一个线程任务类实现Callable接口，申明线程返回的结果类型
class MyCallable implements Callable<String>{
    // 2.重写线程任务类的call方法！
    @Override
    public String call() throws Exception {
        // 需求：计算1-10的和返回
        int sum = 0 ;
        for(int i = 1 ; i <= 10 ; i++ ){
            System.out.println(Thread.currentThread().getName()+" => " + i);
            sum+=i;
        }
        return Thread.currentThread().getName()+"执行的结果是："+sum;
    }
}

9-5、线程的常用API

Thread 类的 API：
  1. public void setName(String name): 给当前线程取名字
  2. public void getName(): 获取当前线程的名字
    1. 线程存在默认名称，子线程的默认名称是：Thread - 索引
    2. 主线程的默认名称是：main
  3. public static Thread currentThread(): 获取当前线程对象，这个代码在哪个线程中，就得到哪个线程对象
  4. public static void sleep(long time):让当前线程休眠多少毫秒再继续执行
  5. public Thread(String name):创建对象并取名字
public class ThreadDemo {
    // 启动后的ThreadDemo当成一个进程。
    // main方法是由主线程执行的，理解成main方法就是一个主线程
    public static void main(String[] args) {
        // 创建一个线程对象
        Thread t1 = new MyThread();
        t1.setName("1号线程");
        t1.start();
        //System.out.println(t1.getName()); // 获取线程名称

        Thread t2 = new MyThread();
        t2.setName("2号线程");
        t2.start();
        //System.out.println(t2.getName());  // 获取线程名称

        // 主线程的名称如何获取呢？
        // 这个代码在哪个线程中，就得到哪个线程对象。
        Thread m = Thread.currentThread();
        m.setName("最强线程main");
        //System.out.println(m.getName()); // 获取线程名称

        for(int i = 0 ; i < 10 ; i++ ){
            System.out.println(m.getName()+"==>"+i);
        }
    }
}

// 1.定义一个线程类继承Thread类。
class MyThread extends Thread{
    // 2.重写run()方法
    @Override
    public void run() {
        // 线程的执行方法。
        for(int i = 0 ; i < 10 ; i++ ){
            System.out.println(Thread.currentThread().getName()+"==>"+i);
        }
    }
}
线程休眠api
public class ThreadDemo02 {
    public static void main(String[] args) {
        for(int i = 0 ; i < 10 ; i++ ) {
            System.out.println(i);
            try {
                // 项目经理让我加上这行代码
                // 如果用户交钱了，我就去掉。
                Thread.sleep(1000); // 让当前线程休眠1s.
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}
通过Thread类的有参构造器为当前线程对象取名字
public class ThreadDemo03 {
    // 启动这个类，这个类就是进程，它自带一个主线程，
    // 是main方法，main就是一个主线程的执行！！
    public static void main(String[] args) {
        Thread t1 = new MyThread02("1号线程");
        t1.start();

        Thread t2 = new MyThread02("2号线程");
        t2.start();

        Thread.currentThread().setName("主线程");
        for(int i = 0 ; i < 10 ; i++ ) {
            System.out.println(Thread.currentThread().getName()+" => "+i);
        }
    }
}

// 1.定义一个线程类继承Thread。线程类并不是线程对象，用来创建线程对象的。
class MyThread02 extends Thread{

    public MyThread02(String name) {
        //  public Thread(String name):父类的有参数构造器
        super(name); // 调用父类的有参数构造器初始化当前线程对象的名称！
    }

    // 2.重写run()方法
    @Override
    public void run() {
        for(int i = 0 ; i < 10 ; i++ ) {
            System.out.println(Thread.currentThread().getName()+" => "+i);
        }
    }
}

9-6、线程安全

线程安全问题：多个线程同时操作同一个共享资源的时候可能会出现线程安全问题

9-6-1、线程同步_同步代码块
  • 线程同步的作用：就是为了解决线程安全问题，让多个线程实现先后依次访问共享资源，这样就解决了安全问题
  • 线程安全：多个线程同时操作同一个共享资源的时候可能会出现线程安全问题
  • 线程同步的做法：加锁(就是把共享资源进行上锁，每次只能一个线程进入访问完毕以后，其他线程才能进来)
  • 线程同步的方法：
    • 同步代码块
    • 同步方法
    • lock 显示锁

同步代码块作用：是把出现线程安全问题的核心代码给上锁，每次只能一个线程进入，执行完毕之后自动解锁，其他线程才可以进来执行

// 格式
synchronized(锁对象){
    // 访问共享资源的核心代码    
}
  • 在实例方法中建议用this作为锁对象
  • 在静态方法中建议用类名.class字节码作为锁对象

9-7、线程同步_同步方法

作用：把出现线程安全问题的核心方法给锁起来，每次只能一个线程进入访问，其他线程必须在方法外面等待

用法：直接给方法加上一个修饰符 synchronized

public synchronized void 方法名(){
    
}

原理：同步方法的原理和同步代码块的底层原理其实是完全一样的，只是同步方法是把整个方法的代码都锁起来，同步方法其实底层也有锁对象的。

  • 如果方法是实例方法：同步方法默认用 this作为锁对象
  • 如果方法是静态方法：同步方法默认用类名.class 作为锁对象

9-8、线程同步_lock显示锁

Lock锁也称同步锁，加锁与释放锁方法化了，如下

  • public void lock(): 加同步锁
  • public void unlock(): 释放同步锁
// 创建一把锁对象
private final Lock lock = new ReentrantLock();
// 上锁
lock.lock();
// 解锁
lock.unlock();

优点：线程安全，但是性能差

假如开发中不会存在多线程安全问题，建议使用线程不安全的设计类

9-9、线程通信

线程通信一定是多个线程在操作同一个资源才需要通信，线程

线程通信方法：

  • public void wait()： 让当前线程进入到等待状态，此方法必须锁对象调用
  • public void notify()：唤醒当前锁对象上等待状态的某个线程，此方法必须锁对象调用
  • public void notifyAll()：唤醒当前锁对象上等待状态的全部线程，此方法必须锁对象调用
《Head First Java》20200917读书笔记
qq_43272318的博客
09-17 263
P206- 《Head First Java》20200917读书笔记 Java抽象类 在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。 抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。 由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。 父类包含了子类集合的常见的方法，
构造函数，抽象类
s361299706的博客
09-09 827
构造函数 也叫构造方法，取名必须与类名相同； 注意：调用子类构造函数时，首先调用父类构造函数，然后调用子类构造函数。 在子类中，如果不加关键字super的话，默认调用的是子类的方法，super关键字调用父类的方法： public class A { private String nameA="A"; public void getName() { System.out.println("父类"+nameA); } public static void main(String[]
java中有void修饰的,Java中void方法深入讲解
weixin_32396347的博客
03-13 1011
1.1基本简介void是java中的关键字，它代表的意思是什么也不返回，我们在开发过程中经常会用到，如一个方法不需要返回值时可以使用void关键字，在main方法中也是void关键字。public static void getName() {String name = "username";System.out.println(name);}public static void main(Str...
Java继承类与基类：方法名称、属性名称相同
静笃塾
12-22 1572
Java中，使用关键词extends，可以使继承类拥有基类的属性和方法，前提条件是基类的属性和方法是public或protected。在此讨论一个特殊情况，如果继承类、基类的属性和方法一样怎么办？ 案例一：属性、方法均继承 class Person { private String name = "Person"; public void getName() { System.out.println("Class name is :" + this.getClass()
Java基础巩固系列 匿名内部类的应用举例
Peter__Li的博客
04-01 250
TestProduct代码示例： public class TestProduct { public static void main(String[] args) { TestProduct t = new TestProduct(); //方式一：创建一个实现Product接口的类的对象，并将此对象传入方法中 NoteBook n...
Java多线程编程——基础篇
qq_73698057的博客
08-21 7723
java线程基础篇，通俗易懂
Java核心编程总结(五、线程池与死锁)
Augenstern_QXL的博客
04-27 1920
1.基础回顾+面试 1.1线程池 什么是线程池？ 答：线程池：其实就是一个容纳多个线程的容器，其中的线程可以反复的使用，省去了频繁创建和销毁线程对象的操作，无需反复创建线程而消耗过多资源 为什么要用线程池？ 答： 降低资源消耗，减少了创建和销毁线程的次数 提高响应速度，不需要频繁的创建线程 提高线程的可管理性（线程池可以约束系统最多只能有多少个线程，不会因为线程过多而死机) 1.2创建线程池 线程池在Java中的代表类：ExecutorService(接口) new FixedThr
深入浅出Java并发编程：线程基础
在技术的广袤天地里，本博客如精准罗盘。剖析前沿科技，深掘代码奥秘，以精炼笔触，带您穿越复杂技术迷宫，速达知识彼岸。
03-10 1846
通过本文的学习，我们详细探讨了Java并发编程中的线程基础，包括进程与线程的区别、线程的创建方式线程的生命周期守护线程与用户线程、以及线程优先级与调度策略。掌握这些基础知识是进一步学习并发编程的关键。在实际开发中，理解并正确使用这些概念可以帮助我们构建高效、稳定的多线程应用。然而，并发编程的复杂性远不止于此，后续我们还将深入探讨线程安全、锁机制、线程通信等高级主题。
《Java多线程编程核心技术》——多线程总结
weixin_39754631的博客
03-28 4168
第1章 Java多线程技能 本章主要介绍线程和进程的相关概念，多线程的实现和停止，以及Thread类中的核心方法，具体实现的代码可以参考《Java多线程编程核心技术》。 进程和线程 1.进程 一个可并发执行的具有独立功能的程序关于某个数据集合的一次执行过程，也是操作系统进行资源分配和保护的基本单位。简单的说，进程就是一个程序的一次执行过程。 2.引入线程的动机和思路 操作系统采用进程机制使得多任务...
JAVA并发编程-1-线程基础
瓶子君的博客
04-07 1354
JAVA并发编程-1-线程基础一 、基础概念1，cpu核心数与线程数2，进程和线程3，并行和并发4，高并发编程的意义与问题二、实现线程的三种方式1，继承 Thread 类2，实现 Runnable 接口3，实现 Callable 接口三、线程的状态四、线程方法1, 线程终止的方法interrupt()2，等待和通知wait(),notify(),notifyAll()3，利用join()保证线程...
Java 基础核心总结
分享是一种积极的生活态度~~
05-17 1720
Java 是一种广泛使用的程序设计语言，具有跨平台、面向对象、安全性高、灵活性强等特点，广泛应用于企业级应用程序和移动应用程序等领域。在学习 Java 语言时，需要掌握一些基础核心知识，本文将为您总结 Java 基础核心知识点，以便于您的学习和参考。介绍Java 基础核心知识点包括基本语法、面向对象编程、异常处理、集合框架、IO 流和多线程等方面。
Java线程基础：并发编程核心
我是Java程序员廖志伟，感谢朋友们的支持！
09-19 1007
在当今的软件开发领域，高并发已经成为衡量系统性能的重要指标。Java作为一门广泛应用于企业级应用开发的语言，其并发编程能力尤为关键。线程作为Java实现并发编程的基本单位，理解线程的基础知识对于深入掌握Java并发编程至关重要。想象一下，在一个大型在线购物平台中，用户同时进行商品浏览、下单、支付等操作，这些操作需要快速响应，以保证用户体验。这就需要系统具备高并发处理能力，而线程是实现这一目标的关键。然而，在深入探讨线程的细节之前，我们首先需要了解线程的基本概念。
java多线程编程实战指南核心篇，java面试项目中的技术难点
m0_61043185的博客
03-06 801
每年金三银四，金九银十之际，想进阶梦想挑战大厂的朋友层出不穷。梦想是要有的，万一就实现了呢？且撇开大牛们不说，每年面试之时问题也层出不穷，不得不说，每年被算法绝杀的朋友也是不在少数啊。这篇文的目的在于提醒朋友们不管你是正在进阶的小白还是经验丰富的大牛，请熟练算法，可能它就成为你成功进入大厂的阶梯呢，最后祝正在准备进阶面试大厂的的朋友，一切顺利，如愿以偿。
Java多线程编程详解
ljw714的专栏
06-03 999
本文系统介绍了Java多线程编程的核心内容，包括线程创建方式（继承Thread类、实现Runnable/Callable接口、线程池）、生命周期管理、同步机制（synchronized、Lock、volatile、原子类）以及常用并发工具类（CountDownLatch、CyclicBarrier、Semaphore）。通过代码示例展示了各种多线程技术的实际应用，帮助开发者理解并发编程的关键概念和技术实现。文章涵盖从基础到进阶的多线程知识，为Java开发者提供了全面的并发编程指导。
从线程池源码看Java并发编程：核心线程与非核心线程区别
最新发布
cfqB5SIV5的博客
10-13 495
JVM 分层编译（Tiered Compilation）原理与参数调优-摘要
Java 多线程编程：从基础到实战！
喵手的博客
05-07 1101
多线程编程是 Java 中的一个核心概念，它允许多个线程同时执行任务，从而提高程序的效率和响应性。在现代应用程序中，多线程编程无处不在，尤其是在处理高并发任务时。今天，我们将从基础到实战深入讲解 Java 的多线程编程，帮助你更好地理解和应用它。
探索 Java 多线程编程的核心要点与实战应用
这里只有干货：从 Modbus 通信到 MES 对接，从 YOLO 训练到工控机部署，带你搞定工业软件开发全流程。
11-14 921
线程池管理：优先使用线程池来管理线程，避免频繁创建和销毁线程，提升性能。线程同步：使用适当的同步工具，避免多线程访问共享资源时出现问题。可以使用Atomic等工具。并发容器：使用 Java 提供的并发容器类，如，避免手动处理线程安全问题。任务调度：利用来调度定时任务或周期性任务。避免死锁：合理设计锁的使用，避免嵌套锁，并使用超时机制来避免死锁。通过理解并实践这些核心要点和最佳实践，你可以编写出高效、安全、可扩展的多线程 Java 程序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值