Java SE：多线程（Thread）

最新推荐文章于 2024-03-25 23:34:29 发布
置顶 最新推荐文章于 2024-03-25 23:34:29 发布
阅读量855 收藏 10
点赞数 23
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79526467/article/details/136216009
版权
本文详细介绍了Java中的线程概念、多线程的三种实现方式（继承Thread、实现Runnable接口和Callable/Future接口）、线程优先级、守护线程、礼让机制、插入线程、同步机制、Lock以及线程池的作用和原理。
摘要由CSDN通过智能技术生成

1. 线程两个基本概念

  1. 并发：即线程交替运行多个指令
  2. 并行：即多个线程同时运行指令
  • 并发并行不矛盾，两者可同时发生，即多个线程交替运行指令

 50478036f52c48c6ae1124be2f2a4195.png

2. 多线程3种实现方式

2.1 直接创建线程对象 

        /*
        *
        * 方式1：
        * 1. 创建thread类的子类
        * 2. 将该子类实列化
        * 3. 实列化对象调用start方法即开启多线程
        * */

        myThread myThread1 = new myThread();
        myThread1.setName("线程1");
        myThread1.start();

        myThread myThread2 = new myThread();
        myThread2.setName("线程2");
        myThread2.start();


public class myThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(getName() + "看看哪个线程在执行指令");
        }
    }
}

 2.2 实现Runnable接口

 //方法2：
        /*
        * 1. 定义类实现runnable接口
        * 2. 重写Runnable接口的run方法
        * 3. 创建自己类对象
        * 4. 创建线程，将自己类这个指令添加到线程，开启线程
        * */
        //因为没有继承thread类，无法直接调用start方法，此时该类对象充当要执行的指令，再把该指令添加到线程中即可
        //可直接获取线程对象，或者调用thread类里面获取线程对象的方法
        mythread mt1 = new mythread();
        Thread t1 = new Thread(mt1);
        Thread t2 = new Thread(mt1);
        t1.setName("线程1");
        t2.setName("线程2");
        t1.start();
        t2.start();

    }


public class mythread implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + "第二个方法哟");
        }
    }
}

2.3 利用Callable、Future接口

//方法3：利用Callable、Future接口实现
        /*
        * 1. 定义类实现Callable接口，并重写该接口的call方法
        * 2. 创建自己类的对象（即将要执行的指令对象）
        * 3. 创建FutureTask对象（即接收执行指令最终返回的结果）
        * 4. 创建Thread对象（将要执行的指令添加到线程对象中），并开启线程
        * */

        //1. 定义类，实现Callable接口，并且重写call方法
        //2. 创建指令类对象
        mythread mythread = new mythread();
        //3. 创建接收指令类返回结果的FutureTask对象，此时里面参数代表接收该指令类对象返回的参数
        FutureTask<Integer> integerFutureTask = new FutureTask<Integer>(mythread);
        //将指令添加到线程对象中
        Thread thread = new Thread(integerFutureTask);
        thread.start();
        System.out.println(integerFutureTask.get());



public class mythread implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i < 10; i++) {
            sum += i;
        }
        return sum;
    }
}

三者区别：

  1. 第一种实现方式扩展性较差，因为要有继承关系即已经继承了Thread类，那么该类无法在继承别的类，而方式2、3定义的类只是实现了接口，还可以继承其他类，扩展性较好
  2. 第二种方式相对第三种语法较为简洁
  3. 第三种可以获取指令最终的返回结果，适用于需要返回结果的场景，前两种方式无返回值，无法获取指令的返回结果

3. 线程常用方法 

3.1 线程优先级 

优先级高的线程先执行的概率更高，但不是绝对，线程的执行时机都是随机事件概率问题，Java中默认的线程默认优先级为5，可以调用方法更改线程的优先级 

d0ad3d7a0641471b87c1e9517929758b.png

3.2 守护线程 

当未守护线程全都执行完毕守护线程也随之结束

4a1dcecaf39f4ba980dd0b43310dce9e.png

3.3 礼让线程 

礼让线程可让线程的执行尽可能的均匀 

 62dafc07db8c43a599977bd384a519ee.png

public class yieldThread implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "礼让线程鸭");
            Thread.yield();
        }
    }
}

 3.4 插入线程

Java虚拟机默认先执行完main线程在执行其他线程，若要其他线程在main线程之前执行可调用插入线程方法 

//插入线程
        /*
        * 执行线程：
        * 虚拟机默认先执行main线程，当main线程执行完毕在执行其他线程，若想其他线程在main线程之前执行，得调用插入线程方法
        * */
        //创建要执行指令的对象
        joinThread jt = new joinThread();
        //创建线程对象，要执行的指令添加进线程
        Thread t = new Thread(jt);
        //执行线程
        //插入线程
        t.start();
        t.join();

        for (int i = 0; i < 10; i++) {
            System.out.println("main线程在执行哟");
        }

 4. 线程生命周期

ac6959c120fb46829af0bb3c990a9cfc.png

 5. 解决多线程问题

5.1 同步代码块 

用于解决线程安全问题，需要用到synchronized关键字 

public class windowThread implements Runnable {
    static int ticket = 0;

    @Override
    public void run() {
        //定义个卖票指令，实现多个窗口同时买票
        while (true) {
            //若要避免线程安全问题，可用到synchronized关键字，括号里面的对象充当门锁，默认是打开的，当有线程对象进去，门锁关闭
            //如：此时窗口1争夺到cpu的执行权，那么就会进去，到了sleep睡眠时此时没有资格争夺cpu执行权，假设此时窗口2争夺到
            //但是因为窗口1已经进去门锁此时关闭，而争夺执到执行权的窗口2也只能在门外等候，等待窗口1出来才门才会开锁
            //此时的门锁可以避免多条线程同时执行下面的代码块，从而引发同一张票被3个窗口同时卖出的线程安全问题
            /*
            *
            * 锁细节：
            * 所有线程对象用到的门锁必须是唯一的，
            * 一般用类的字节码文件作为锁对象，保证锁的唯一性
            * */
            synchronized (windowThread.class) {
                if (ticket < 100) {
                    try {
                        //一旦线程运行到此处即休眠10毫秒，无法争夺cpu执行权，休眠过后继续执行后面代码
                        //只有该线程执行完synchronized的代码锁才会打开
                        Thread.sleep(10);
                        ticket++;
                        System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张票");
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                } else {
                    break;
                }
            }
        }
    }
}

 5.2 同步方法

被synchronized关键字修饰的方法为同步方法，该方法执行完才会开锁

public class myRunnable implements Runnable {
    int ticket = 0;

    @Override
    public void run() {
        while (true) {
            //同步方法：即将同步代码块抽取成方法即可
            //被synchronized即同步方法，当一个方法的代码全部要被锁起来可以运用到该方式
            if (method()) break;
        }
    }

    private synchronized boolean method() {
        if (ticket < 100) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            ticket++;
            System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张票");
        } else {
            return true;
        }
        return false;
    }
}

6. 锁（Lock）

synchronized关键字修饰的代码块会自动进行开关锁，而不用这个关键字也开业手动开关机解决线程问题

public class mtThread extends Thread {
    static int ticket = 0;
    //创建锁对象，因为此时定义的类继承Thread类，即会有很多线程对象，
    //而静态关键字修饰的锁对象不管该类实列化多少对象，该锁都仅有一个
    //确保了每个实例化对象对应的锁的唯一性
    static Lock lock = new ReentrantLock();

    @Override
    public void run() {
       while (true) {
           //手动关锁，当线程对象进入后，未开锁之前其他对象不能进入锁下面的代码块
           lock.lock();
           try {
             if (ticket == 100) {
                 break;
             } else {
                 //线程对象执行到此处一样会进行休眠，不参与争夺cpu
                 //当其他线程对象争夺到cpu时会被关在锁外，即无法执行此时的try、catch语句
                 //只有当锁重新打开才能继续执行
                 Thread.sleep(10);
                 ticket++;
                 System.out.println(Thread.currentThread().getName() + "正在售卖第" + ticket + "张票");
             }
           } catch (InterruptedException e) {
               throw new RuntimeException(e);
           } finally {
               //打开锁，获得cpu运行权的对象开锁执行代码
               lock.unlock();
           }
       }
    }
}

 7. 死锁

当两个锁嵌套使用时容易产生死锁问题，当死锁发生，程序将会卡死在锁的门外无法在运行下去，故锁不能嵌套使用 

8. 唤醒等待机制 

唤醒等待机制可以使线程协调运行，比如线程1运行一次，线程2也运行一次 

生产者和消费者实现唤醒等待机制

public class test {
    public static void main(String[] args) {
        //等待唤醒机制：使得线程协调运行
        /*
        * 三个对象：
        * 1. 生产者
        * 2. 消费者
        * 3. 平台
        * */

        Consumer consumer = new Consumer();
        Producer producer = new Producer();

        consumer.setName("消费者");
        producer.setName("生产者");

        consumer.start();
        producer.start();
    }
}



public class Desk {
    //三个属性作为协调的依据
    //判断当前桌子上是否有食物（线程是否运行）
    // 0:没有食物   1：有食物
    static int foodFlag = 0;

    //判断当前食物运行次数还剩多少（线程运行次数）
    static int count = 10;

    //锁对象
    static Lock lock = new ReentrantLock();
}



public class Consumer extends Thread{
    /*
    *
    * 1. 判断线程次数是否完成
    * 2. 判断桌子上是否有食物
    * 3. 有食物则吃掉，次数减一
    * 4. 没有食物则等候，并且唤醒生产者
    * */

    @Override
    public void run() {
        while (true) {
            synchronized (Desk.lock) {
                //判断线程次数
                if (Desk.count == 0) {
                    break;
                }
                //判断是否有食物
                if (Desk.foodFlag == 1) {
                    //有则直接吃掉，并且次数减一
                    System.out.println(this.getName() + "正在吃掉第" + Desk.count + "份食物");
                    //吃掉之后则生产者继续生产（即唤醒另一线程）
                    Desk.lock.notify();
                    Desk.foodFlag = 0;
                    Desk.count--;
                } else {
                    try {
                        //让该线程和锁进行绑定
                        Desk.lock.wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        }
    }
}



public class Producer extends Thread{

    /*
    *
    * 1. 判断线程次数是否运行完成
    * 2. 判断桌面上是否有食物（该线程是否运行）
    * 3. 有则等候（线程等候），并唤醒等候线程
    * 4. 没有则做食物（线程运行）
    * */

    @Override
    public void run() {
        while (true) {
            synchronized (Desk.lock) {
                //判断线程次数是否运行完成
                if (Desk.count == 0) {
                    break;
                }
                if (Desk.foodFlag == 1) {
                    //有则等候，并唤醒该锁对象的等候线程
                    try {
                        //让该线程和锁进行帮
                        Desk.lock.wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                } else {
                    //没有则做食物
                    System.out.println(this.getName() + "正在制作第" + Desk.count + "份食物");
                    //制作之后则消费者消费（即唤醒另一线程）
                    Desk.lock.notify();
                    Desk.foodFlag = 1;
                }
            }
        }
    }
}

阻塞队列实现唤醒等待机制

用到Java提供的队列类（BlockingQueue）此时的队列充当平台，线程之间数据交换协调的平台，要保证线程在同一队列之间协调运行 

public class test {
    public static void main(String[] args) {
        //阻塞队列实现唤醒等待机制
        /*
        *
        * 生产者
        * 消费者
        * 队列：生产者和消费者必须在同一队列进行生产消费
        * */

        //创建队列对象
        ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<String>(3);

        //创建两条线程
        Consumer c = new Consumer(queue);
        Producer p = new Producer(queue);

        p.start();
        c.start();
    }
}



public class Producer extends Thread{

    ArrayBlockingQueue<String> queue;

    //要保证在同一队列进行生产消费，可在构造方法中传递队列对象
    public Producer(ArrayBlockingQueue<String> queue) {
        this.queue = queue;
    }

    //重写线程运行方法
    @Override
    public void run() {
        while (true) {
            try {
                //该队列的方法中已经写好开关锁，不需要我们自己写锁
                queue.put("好吃的鸭");
                System.out.println("做了好吃的鸭");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}



public class Consumer extends Thread{

    ArrayBlockingQueue<String> queue;

    //获取队列对象，要保证同一队列可在构造方法中传递队列对象
    public Consumer(ArrayBlockingQueue<String> queue) {
        this.queue = queue;
    }

    //重写Run方法
    @Override
    public void run() {
        while (true) {
            try {
                //该队列已经写好开关锁，不需要我们手动写，若在写锁就造成嵌套锁容易形成死锁问题
                String food = queue.take();
                System.out.println(food);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

 9. 线程池

没有线程池存放线程时，我们创建的线程当运行完毕会自动销毁，而线程池可以存储线程，提高资源复用率 

线程池原理

  • 创建线程池时，里面是空的，没有任何线程
  • 当有任务添加进线程池时，先创建线程，运行任务，当任务运行完毕，线程并不会销毁，而是保留在池子中，若在有新任务添加，而原先创建的线程并没有运行任务，则会直接复用线程，并不会立刻创建新线程·
  • 当线程池的线程数量达到线程池规定数量上限就不会在创建新线程，而未运行到的任务只能排队等待

获取线程池对象的方式 

 用工具类 Executors直接创建 

f7272320aaa94f99a0418cf87c6bc9c7.png

 012e46ccd91843299d432fcdef63e57a.png

23c4c2207f4545ba95c6a4e9e510ff3e.png

 未完待续......

食懵你啊
关注
  • 23
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Java多线程Thread
qq_43609524的博客
04-19 1389
Java多线程Thread多线程实现原理线程内存图创建多线程的多种方法自定义Thread子类实现Runnable接口实现Runnable接口创建多线程程序的好处使用匿名内部类线程的方法获取线程的名称设置线程名称线程暂停（睡眠）方法 sleep 多线程实现原理 线程内存图 创建多线程的多种方法 自定义Thread子类 class MyThread extends Thread{ @Override public void run() { for (int i = 0; i
Java学习—多线程Thread
艺术的博客
12-11 524
多线程
Java多线程(Thread)
m0_65137927的博客
04-19 276
/继承Thread类的启动方法 new Thread(new MyThread2()) . start();//实现Runnable接口的启动方法 FutureTask < Integer > futureTask = new FutureTask(new MyThread3());//实现Callable接口的启动方法 new Thread(futureTask) . start();try {
Java 多线程2——Thread类常见属性 + 常见方法 + 线程状态
The_emperoor_man的博客
03-25 1431
多线程编程是开发项目中，要用到的，多线程编程是把双刃剑，即可以提高效率，也会带来不少线程安全问题，学会多线程基础，为后续解决线程安全问题做铺垫！！！
初识java多线程（Thread）
weixin_46972127的博客
03-24 2875
1、认识线程 1.1概念 线程组成了进程，进程是操作系统分配资源的最小单元，而线程是操作系统调度的最小单位，一个线程就是一个执行流，每个线程有自己独立的代码，多个线程之间“同时”执行着多份代码。 1.2为什么要有线程 “并发编程”成为刚需，单核CPU的发展遇到瓶颈，想要提高算力，需要多核CPU（可以简单地理解为多个CPU组成），虽然多进程也能实现“并发编程”，但线程比进程更加轻量： ①创建线程比创建进程更快 ②销毁线程比销毁进程更快 ③调度线程比调度进程更快 ※进程和线程地区别： ①从
Java_SE:java基础学习
05-20
9. **多线程** - 线程的创建：通过实现Runnable接口或继承Thread类。 - 线程控制：sleep(), join(), yield(), interrupt()等方法。 - 同步机制：synchronized关键字，wait(), notify(), notifyAll()方法，以及...
java会话管理、多线程.docx
04-21
【Java会话管理与多线程详解】 Java会话管理主要涉及的是在Web应用程序中如何维护用户的状态信息。在Web应用中，用户打开一个页面，然后进行一系列操作，这些操作可能跨越多个HTTP请求。为了保持用户的上下文信息，...
VOORBEELDEN_SE:Java SE的示例
05-02
Thread类和Runnable接口是实现多线程的基础。 7. **反射API**：Java反射机制允许程序在运行时动态地获取类的信息（如类名、属性、方法等）并操作对象。这对于元编程和插件系统非常有用。 8. **Java Swing和JavaFX*...
Java-SE:Java 学习笔记，JAVA SE
05-18
6. **多线程** - **线程创建**：通过实现Runnable接口或继承Thread类创建线程。 - **同步机制**：synchronized关键字用于保证线程安全，防止数据竞争。还有wait()、notify()和notifyAll()方法用于线程间的通信。 ...
java-se:java基础巩固，思考
04-13
6. **多线程**：Java内置了对多线程的支持，通过Thread类或实现Runnable接口可以创建线程。同步机制如synchronized关键字、wait/notify、ReentrantLock等，能防止并发问题。 7. **输入输出流**：Java的IO系统提供了...
Java多线程Thread详细讲解（万字教程）
最新发布
2301_81749759的博客
03-25 792
面试前一定少不了刷题，为了方便大家复习，我分享一波个人整理的面试大全宝典Java核心知识整理Java核心知识Spring全家桶（实战系列）其他电子书资料Step3：刷题既然是要面试，那么就少不了刷题，实际上春节回家后，哪儿也去不了，我自己是刷了不少面试题的，所以在面试过程中才能够做到心中有数，基本上会清楚面试过程中会问到哪些知识点，高频题又有哪些，所以刷题是面试前期准备过程中非常重要的一点。” />面试前一定少不了刷题，为了方便大家复习，我分享一波个人整理的面试大全宝典Java核心知识整理。
编程必备：JAVA多线程详解
拾一二的博客
06-14 8001
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
多线程—Thread类的用法
m0_62824239的博客
03-23 727
目录什么是Thread类Thread类的基本用法线程创建最基本的创建方法实现runnable接口使用匿名内部类lambda表达式 Java这个生态中最常用的并发编程方式是多线程。 什么是Thread类 在java标准库中，就提供了一个Thread类，来表示/操作线程。Thread类也可以视为Java标准库提供的API，创建好的Thread实例，其实和操作系统中的线程是一一对应的关系，操作系统，提供了一组关于线程的API，Java对于这组API进一步封装，就成了Thread类。 Thread类的基本用法 线程
第二篇、Thread类实现多线程
weixin_45796249的博客
09-18 533
继承Thread类实现多线程。
Java中的多线程（Thread）（一）概念篇
weixin_44918667的博客
05-22 2055
学习目标 知识点 要求 多线程介绍 了解 线程的创建 掌握 线程的使用 掌握 线程的优先级 掌握 守护线程 掌握 线程同步 掌握 线程并发协作 掌握 一、 多线程介绍 多线程的基本概..
多线程（Thread）
mx861656762的博客
03-25 631
进程 定义：应用程序的执行实例（最小单位）；有独立的内存空间与系统资源 线程 定义：包含在进程里面；CPU调度与分派的基本单位；执行运算的最小单位，可以完成独立的顺序流程的控制 多线程定义 一个进程当中同时运行了多个线程，用来完成不同的工作，这就叫做多线程 优点 1.充分利用CPU的资源 2.简化编程模型 3.带来良好的用户体验 主线程 main()方法就是主线程的入口 产生请其他子线程的线程 必须最后完成，因为他要执行各种的关闭动作 使用线程步骤 1.定义线程 2.创建线程
【Java学习笔记】多线程
weixin_52144018的博客
03-20 338
【Java学习笔记】多线程
Java SE多线程详解：线程实现与同步
本资源是一份关于Java SE多线程的详细教程，由讲师秦疆提供，版权归属于西安西部开源教育科技有限公司。该系列文档是基于B站视频项目的学习总结，旨在帮助个人深入理解多线程概念和实践。 1. 线程简介： 多线程是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

食懵你啊

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值