JAVA多线程简述

最新推荐文章于 2024-07-27 13:31:57 发布
最新推荐文章于 2024-07-27 13:31:57 发布
阅读量81 收藏
点赞数 1
分类专栏： JAVASE Object 文章标签： java 多线程 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29568755/article/details/118466430
版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

前言

为什么要使用多线程呢，在Java中多线程是指一个进程拥有多个线程，多线程程序并不能提高程序运行的速度，但能够提高程序运行效率让CPU的使用率更高。

注：欢迎各位指出错误

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

进程：是指一个内存中运行的程序，每个进程都有一个独立的内存空间。
线程：是进程中的一个执行路径，多个线程共享一个内存空间，线程之间可以相互切换，并发执行一个线程至少有一个线程。

二、思维导图（1）多线程概述

为方便大家理解做了一份简易思维导图
在这里插入图片描述

二、用法介绍

1.Runnable

代码如下（示例）：

/**
 * @author 26591
 * 实现runnable与继承thread相比有如下优势
 * 1. 通过创建任务然后给线程分配的方式来实现的多线程，更适合多个线程同时执行相同任务的情况。
 * 2. 可以避免单继承所带来的局限性。
 * 3. 任务与线程本身是分离的，提高了程序的健壮性。
 */
public class mainRunnable {
    public static void main(String[] args) {
        //实现Runnable
        //1.    创建一个任务对象
        Myrunnable r=new Myrunnable();
        //2.   创建一个线程，并为其分配一个任务
        Thread t=new Thread(r,"锄禾日当午");
        //thread.currentThread表示当前正在执行线程
        System.out.println(Thread.currentThread().getName());
        //3.    执行这个线程
        t.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("汗滴禾下土"+i);
        }
    }
}

结果
在这里插入图片描述

2.线程中断与守护

代码如下（示例）：

/**
 * @author 26591
 */
public class ThreadInterrupt {
    public static void main(String[] args) {
        //线程的中断
        //一个线程是一个独立的执行路径，它是否应该结束，应该由其自身的决定
        //线程分为守护线程和用户线程
        //守护线程：守护用户线程，当最后一个用户线程结束时，所有守护线程自动死亡。
       Thread t1=   new Thread(new MyRunnable());
       //守护线程设置方式,main线程死亡t1线程自动结束
            t1.setDaemon(true);
            t1.start();
        for (int i = 0; i <= 5; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();

            }
        }
        //给线程t1打上中断标记
        t1.interrupt();
    }
    static class MyRunnable 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();
                    //程序员可以控制线程是否继续运行
                    System.out.println("检查到标记我自杀了");
                    return;

                }
            }
        }
    }
}

本应该继续执行的代码当主程序执行完成后线程检测到中断标记自我中断。
并且此处也表明了t1线程属于守护线程就算是没有中断标记，当用户线程也就是主线程结束后该线程也会自动消亡。
在这里插入图片描述

3、线程安全

方式一同步代码块（隐式锁）

/**
 * @author 26591
 * 线程同步：synchronized
 */
public class ThreadSafetyDemo1 {
    public static void main(String[] args) {
        //线程不安全
        //解决方案1.同步代码块
        //格式：synchronized（锁对象）{}排队执行
        //任何对象都可以成为锁对象
        Runnable run=new Ticket();
        //多个线程同时争抢同一资源时容易出现问题
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }
    static class Ticket implements Runnable{
        //票数
        private int count = 10;
        private Object o=new Object();
        @Override
        public void run() {
            //注：使用同一把锁要避免锁对象不为一
            //错误示例Object o=new Object();
            while (true) {
                //锁对象
                 synchronized (o) {
                     if (count > 0) {
                        //卖票
                        System.out.println("正在准备卖票");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        count--;
                        System.out.println(Thread.currentThread().getName()+"出票成功，余票：" + count);
                    }else {
                         break;
                     }

                }
            }
        }
    }
}

方式二同步方法（隐式锁）

/**
 * //使用synchronized (){}到方法
 * @author 26591
 */

public class ThreadSafetyDemo2 {
    public static void main(String[] args) {
        //线程不安全
        //解决方案2 同步方法


        Runnable run=new Ticket();

        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }
    static class Ticket implements Runnable{
        //票数
        private int count = 10;
        @Override
        public void run() {
            while (true) {
                //锁对象
               boolean flag= sale();
               if (!flag){//!flag=false
                   System.out.println("票已售空");
                   break;
               }
            }

        }
        public synchronized boolean sale(){
            /*synchronized对象是调用者this
            若被静态修饰则为字节码同步对象例如
               Ticket.class
             */
            if (count > 0) {
                //卖票
                System.out.println("正在准备卖票");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println(Thread.currentThread().getName()+"出票成功，余票：" + count);
                return true;
            }else {
               return false;
            }
        }
    }
}

方案三显示锁Lock

public class ThreadSafetyDemo3 {
    public static void main(String[] args) {
    //线程不安全
        // 解决方案3。显示锁 Lock 子类 Reentrantlock
        //
    Runnable run=new Ticket();
    //多个线程同时争抢同一资源时容易出现问题
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
}
static class Ticket implements Runnable{
    //票数
    private int count = 10;
    //显示锁:参数为True表示 是公平锁谁先来谁先得
    private  Lock l=new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            //锁住
             l.lock();
            //锁对象
                if (count > 0) {
                    //卖票
                    System.out.println("正在准备卖票");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    count--;
                    System.out.println(Thread.currentThread().getName()+"出票成功，余票：" + count);
                }else {
                    break;
                }
            l.unlock();
        }
    }
}
}

思维导图（2）常用方法概述

在这里插入图片描述
在这里插入图片描述

思维导图（3）线程池

1.如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程 就会大大降低 系统的效率，因为频繁创建线程和销毁线程需要时间. 线程池就是一个容纳多个线程的容 器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。
2.线程池的好处
降低资源消耗。
提高响应速度。
提高线程的可管理性
在这里插入图片描述

（1）缓存线程池

public class CacheThreadPool {
    /**
     * 缓存线程池。
     * （长度无限制）
     * 任务加入后执行的流程
     *      1.判断线程池是否存在空闲线程
     *      2.存在则使用
     *      3.不存在，则创建线程 并放入线程池，然后使用
     * @param args
     */
    public static void main(String[] args) {
        ExecutorService service= Executors.newCachedThreadPool();
        //指挥线程池中执行新的任务
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        });

        //当最开始的三个线程执行完毕后此时线程池中拥有三个空闲线程选取其中一个执行下次任务
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        });
    }
}

执行结果：
在这里插入图片描述

（2） 定长线程池

public class FixedLengthThreadPool {
    /**
     * 定长线程池
     * （长度时指定的数值）
     * 任务加入后的执行流程
     *      1.判断线程池是否存在空闲线程
     *      2.存在即使用
     *      3.不存在空闲线程，且线程池未免的情况下，则创建线程 并放入线程池，然后使用
     *      4.不存在空闲线程，且线程池已满的情况下，则等待线程池存在空闲线程
     * @param args
     */
    public static void main(String[] args) {
        ExecutorService service= Executors.newFixedThreadPool(2);
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");

            }
        });
    }
}

执行结果：
在这里插入图片描述

（3） 单线线程池

public class SingleThreadPool {
/**
 * 单线程线程池
 * 执行流程：
 *      1.判断线程池 的那个线程 是否空闲
 *      2.空闲则使用
 *      3.不空闲，则等待 池中的单个线程空闲后 使用
 */
    public static void main(String[] args) {
        ExecutorService service= Executors.newSingleThreadExecutor();
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        });
    }
}

执行结果：
在这里插入图片描述

（4） 缓存线程池

public class PeriodicFixedLengthTP {
    /**
     * 周期任务 定长线程池
     * 执行流程：
     *      1.判断线程池是否存在空闲线程
     *      2.存在即使用
     *      3.不存在空闲线程，且线程池未满的情况下，则创建线程 并放入线程池，然后使用
     *      4.不存在空闲线程，且线程池已满的情况下，则等在线程池存在空闲线程
     *
     * 周期性任务执行时：
     *      定时执行，当某个时机触发时，自动执行某任务。
     * @param args
     */
    public static void main(String[] args) {
      ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
        /**
         *   定时执行一次
         *  参数1.定时执行的任务
         *  参数2.时常数字
         *  参数3.时常数字的时间单位TimeUnit的常量指定
        service.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("锄禾日当午");
            }
        },5, TimeUnit.SECONDS);
        */
        /**
         * 周期性执行任务
         * 参数1.任务
         * 参数2.延迟时长数字（第一次执行在什么时间以后）
         * 参数3.周期性时长数字
         * 参数4.时常数字的单位
         */
        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("汗滴禾下土");
            }
        },3,1,TimeUnit.SECONDS);
    }
}

执行结果：
在这里插入图片描述

总结

提示：这里对文章进行总结：
例如：以上就是今天要讲的内容，本文仅仅简单介绍了JAVA多线程的使用，而JAVA多线程使我们快速便捷地处理数据的效率。

风口上的鱼
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 多线程 选择题_Java多线程题库
weixin_36227100的博客
02-12 3452
一、填空题处于运行状态的线程在某些情况下，如执行了sleep(睡眠)方法，或等待I/O设备等资源，将让出CPU并暂时停止自己的运行，进入____阻塞_____状态。处于新建状态的线程被启动后，将进入线程队列排队等待CPU，此时它已具备了运行条件，一旦轮到享用CPU资源就可以获得执行机会。上述线程是处于就绪状态。解析： 线程的生命周期—五个阶段新建状态---- new关键字创建线程对象就绪状态---...
Java多线程-多线程知识点总结和企业真题
02-04
### Java多线程知识点总结及企业真题解析 #### 一、知识点总结 ##### （1）多线程相关概念 1. **程序、进程和线程的区分**： - **程序**：为了完成特定的任务而编写的指令集合。它是静态的概念。 - **进程**：...
Java 多线程(一) 多线程基本概念
yuanchun的知识整理
11-02 681
Java 多线程(一) 多线程基本概念
java 多线程简述
荒野哞的专栏
02-16 1823
多线程的基本实现      进程指运行中的程序，每个进程都会分配一个内存空间，一个进程中存在多个线程，启动一个JAVA虚拟机，就是打开个一个进程，一个进程有多个线程，当多个线程同时进行，就叫并发。    J ava创建线程的两种方式为： 继承Thread类 和实现Runnable接口    Thread类    1、通过覆盖run方法实现线程要执行的程序代码    2、Start()开始
java多线程的优点_Java多线程编程的优势与风险
weixin_39724362的博客
03-08 467
Java多线程编程的优势与风险Java多线程编程具有以下优势：1、提高系统的吞吐率(Throughout). 多线程编程可以使一个进程有多个并发(concurrent,即同时进行的)的操作。2、提高响应性(Responsiveness).Web服务器会采用一些专门的线程负责用户的请求处理,缩短了用户的等待时间。3、充分利用多核(Multicore)处理器资源. 通过多线程可以充分的利用CPU资源。...
java创建多线程的四种方式
weixin_48016395的博客
02-15 4665
java多线程的创建方式是面试经常会被问到的一个问题，因此在这里我对java创建多线程的四种方式做一个简单的归纳与总结，便于复习。 一、继承Thread类创建多线程 ① 创建一个继承于Thread类的子类。 ② 重写Thread类中的run()方法，在run()方法中实现线程需要完成的功能。 ③ 创建Thread类的子类的对象，并调用这个对象的start()方法，调用start()后会自动启动当前线程，并调用当前线程的run()方法。 ...
java 多线程的好处_线程多有什么好处？使用多线程的优势
weixin_42217306的博客
02-19 2425
线程多有什么好处？提高CPU的利用率，更好地利用系统资源，使用Monitor类可以同步静态/实例化的方法的全部代码或者部分代码段，使用不同的同步类创建自己的同步机制。多线程指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程提升整体处理性能。多线程是指程序中包含多个执行流，即在一个程序中可以同时运行多个不同制的线程来执行不同的任务，允许单...
Java实现多线程有几种方式(满分回答)
Gang-bb的博客
02-22 5652
Java实现多线程有几种方式
JAVA多线程作业-多人买票
m0_46288176的博客
04-23 1225
JAVA多线程作业 作业要求： 1、 假设现在有一个售票员进行售票，票价为5元，初始状态：票数不限，票售员手中有1张10元钱； 2、 每来一个顾客买票，相当于是创建一个线程，注意，此时顾客共享的资源是售票员及其手中的钱； 3、 当一个顾客到达后相当于创建一个线程，创建该线程时有两个参数，一是线程名，也就是顾客的名字，二是顾客带的钱（规定顾客带的钱只能为5元，10元，20元和50元）。 4、 某一个顾客买票时，如果售票员无法找零，则让该顾客等待，如果某一个顾客买票成功，则唤醒所有等待的顾客。 5、 主线程中用
多线程处理大量数据 java
热门推荐
tiantian929的博客
09-27 1万+
项目场景： 简述项目相关背景： 例如：获取大量数据并处理，生成execl文件导出 问题描述： 5W条数据处理后生成execl文件需要6个小时，效率慢 APP 中接收数据代码： @Override public void run() { bytes = mmInStream.read(buffer); mHandler.obtainMessage(READ_DATA, bytes, -1, buffer).sendToTarget();
java 多线程好处_java多线程有哪些优缺点？详细解析
weixin_42449422的博客
02-12 1263
java中多线程的使用是非常频繁的，而且它的作用也是很明显的。很多人可能对于java中多线程的一些知识不是很了解，今天就来详细简述一下java多线程的优缺点，一起来看看吧。首先我们需要知道的是，java 中使用synchronized是用来表示该资源或者该方法是不能进行多个线程的共享的，所以当多个线程都在请求该资源的时候，就跟串行是一样的也就是单线程效果一样，但是当不为共享的时候就可以利用并发来大...
java多线程，高并发面试题.pdf
07-04
### Java多线程与高并发面试题解析 #### 一、`stop()` 和 `suspend()` 方法为何不推荐使用？ 在Java多线程编程中，`Thread` 类提供了多个方法用于控制线程的行为，包括 `stop()` 和 `suspend()`。然而，这两个方法...
Java定时器Timer简述
08-31
- `TimerTask`中的`run`方法必须是线程安全的，因为多个任务可能在同一时刻被调用。 - 如果你不再需要Timer，记得调用`timer.cancel()`来取消所有未来的调度任务并终止Timer线程，防止内存泄漏。 - 当Timer的`...
Java垃圾回收机制简述
08-28
Parallel垃圾收集器是Serial垃圾收集器的多线程版本，使用多个线程来回收垃圾对象。G1垃圾收集器是Java 7中引入的新的垃圾收集器，使用标记-整理算法来回收垃圾对象。 垃圾回收机制的优点 垃圾回收机制有很多优点...
Java定时器Timer简述.pdf
10-03
总结来说，Java定时器Timer是Java多线程编程中的重要工具，可以用于实现各种定时任务的需求，如定时发送邮件、定期检查数据库等。不过，在高性能或实时性要求较高的场景下，可能需要考虑使用其他更专业的定时框架，...
golang 接口
m0_70982551的博客
07-24 868
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 454
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 542
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
最新发布
訾博（ZiBo）的博客
07-27 471
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
java多线程概念简述
12-16
Java多线程是指在一个程序中同时运行多个线程，每个线程都可以独立执行不同的任务。Java多线程的概念可以简单地理解为在一个程序中同时运行多个线程，每个线程都可以独立执行不同的任务。Java多线程的实现方式有两种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值