多线程全面详解

已于 2023-02-01 19:54:27 修改
阅读量246 收藏 1
点赞数 1
分类专栏： Java基础 文章标签： java Powered by 金山文档
于 2023-01-14 00:18:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58673188/article/details/128680740
版权

线程

从软硬件实现多条执行流程的技术

多线程的创建

  1. 继承Thread类

优点：编码简单

缺点：无法继承其他类了，不利于扩展

public class Thread_1 {
    //3.创建线程对象
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();//直接调用run方法会被当成普通方法执行，调用start方法才是启动一个新的的线程
        //主线程，要把子线程任务放到主线程之前，否则就是单线程了
        for (int i = 0; i < 3; i++) {
            System.out.println("主线程"+i);
        }
    }
}
//1.继承Thread类
class MyThread extends Thread {
    //2.重写run方法
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println("子线程"+i);
        }
    }
}

  1. 实现Runnable接口

优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强

缺点：编程多一层对象包装，如果线程有执行结果不可以直接返回

public class Thread_2 {
    public static void main(String[] args) {
        // 2.创建MyRunnable对象
        Runnable runnable = new MyRunnable();
        // 3.把MyRunnable对象交给Thread处理
        Thread thread = new Thread(runnable);
        // 4.调用线程对象的start方法启动线程
        thread.start();

        //主线程
            for (int i = 0; i < 3; i++) {
                System.out.println("主线程"+i);
            }
    }
}
class MyRunnable implements Runnable{
    @Override
    // 1.定义一个线程任务类MyRunnable实现Runnable接口，重写run方法
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println("子线程"+i);
        }
    }
}

//简化版
public class Thread_2 {
    public static void main(String[] args) {

         new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 3; i++) {
                    System.out.println("子线程"+i);
                }
            }
        }).start();
         
        //主线程
            for (int i = 0; i < 3; i++) {
                System.out.println("主线程"+i);
            }
    }
}

  1. 实现Callable接口

优点：可以得到线程执行的结果

缺点：代码相对较多

public class Thread_3 {
    public static void main(String[] args) {

        Callable call = new MyCallable(100);
        //把Callable对象交给Futuretask对象，可以交给thread处理，并获得结果
        FutureTask<String> task = new FutureTask<String>(call);
        new Thread(task).start();

        //主线程
        Callable call2 = new MyCallable(200);
        FutureTask<String> task2 = new FutureTask<String>(call2);
        new Thread(task2).start();

        try {
            //通过get方法获取数据
            String s = task.get();
            System.out.println("第一个"+s);
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            String s1 = task2.get();
            System.out.println("第二个"+s1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class MyCallable implements Callable<String>{
    private int n;
    public MyCallable(int n) {
        this.n = n;
    }
    @Override
    public String call() throws Exception {
        n+=1;
        return "结果为"+n;
    }
}

线程常用方法

setName(),getName(),currentThread()

public class ThreadDemo01 {
    // main方法是由主线程负责调度的
    public static void main(String[] args) {
        Thread t1 = new MyThread("1号");
        // t1.setName("1号");
        t1.start();
        System.out.println(t1.getName());

        Thread t2 = new MyThread("2号");
        // t2.setName("2号");
        t2.start();
        System.out.println(t2.getName());

        // 哪个线程执行它，它就得到哪个线程对象（当前线程对象）
        // 主线程的名称就叫main
        Thread m = Thread.currentThread();
        System.out.println(m.getName());
        m.setName("最牛的线程");

        for (int i = 0; i < 5; i++) {
            System.out.println( m.getName() + "输出：" + i);
        }
    }
}
public class MyThread extends Thread{
    public MyThread() {
    }

    public MyThread(String name) {
        // 为当前线程对象设置名称，送给父类的有参数构造器初始化名称
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println( Thread.currentThread().getName() + "输出：" + i);
        }
    }
}

线程的休眠

public class ThreadDemo02 {
    // main方法是由主线程负责调度的
    public static void main(String[] args) throws Exception {
        for (int i = 1; i <= 5; i++) {
            System.out.println("输出：" + i);
            if(i == 3){
                // 让当前线程进入休眠状态
                // 段子：项目经理让我加上这行代码，如果用户愿意交钱，我就注释掉。
                Thread.sleep(3000);
            }
        }
    }
}

线程同步

为了解决线程安全问题，让多个线程实现先后依次访问共享资源

加锁：把共享资源上锁，每次只能一个线程进入访问，完毕以后解锁，然后其他线程才能进来

方式一：同步代码块

把出现线程安全问题的核心代码上锁,用synchronized环绕，不推荐，一把锁住了所有线程

会影响其他无关线程的执行

规范：1.建议使用共享资源作为锁对象

2.实例方法建议使用this作为锁对象

3.静态方法用字节码（类名.class）作为锁对象

synchronized (this) {
            // 2、判断余额是否足够
            if (this.money >= money) {
                // 钱够了
                System.out.println(name + "来取钱，吐出：" + money);
                // 更新余额
                this.money -= money;
                System.out.println(name + "取钱后，余额剩余：" + this.money);
            } else {
                // 3、余额不足
                System.out.println(name + "来取钱，余额不足！");
            }

方式二：同步方法

给核心方法上锁，每次只能一个线程进入方法，执行后解锁，其它线程再次进入

public synchronized void drawMoney(double money)

方式三：同步锁

private final Lock lock = new ReentrantLock();
public void drawMoney(double money) {
        // 1、拿到是谁来取钱
        String name = Thread.currentThread().getName();
        // 2、判断余额是否足够
        // 小明  小红
        lock.lock(); // 上锁
        try {
            if(this.money >= money){
                // 钱够了
                System.out.println(name+"来取钱，吐出：" + money);
                // 更新余额
                this.money -= money;
                System.out.println(name+"取钱后，余额剩余：" + this.money);
            }else{
                // 3、余额不足
                System.out.println(name+"来取钱，余额不足！");
            }
        } finally {
            lock.unlock(); // 解锁
        }
    }

线程池

可以复用线程的技术，反复创建线程的开销会很大，会严重影响系统性能

问题：

  • 谁代表线程池？

ExecutorService接口

实现类：

  • 临时线程什么时候创建？

新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程

  • 什么时候会开始拒绝任务？

核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始任务拒绝

线程池处理Runnable任务

ExecutorService pool = new ThreadPoolExecutor(3, 5 ,6, TimeUnit.SECONDS, new ArrayBlockingQueue<>(5) , Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy() );
       
        // 2、给任务线程池处理。
        Runnable target = new MyRunnable();
        pool.execute(target);

线程池处理Callable任务

 ExecutorService pool = new ThreadPoolExecutor(3, 5 ,6, TimeUnit.SECONDS, new ArrayBlockingQueue<>(5) , Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy() );

        // 2、给任务线程池处理。
        Future<String> f1 = pool.submit(new MyCallable(100));
        System.out.println(f1.get());

Executors得到线程池对象的常用方法

定时器

方式一：Timer定时器

Timer timer = new Timer();  // 定时器本身就是一个单线程。
        // 2、调用方法，处理定时任务
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行AAA~~~" + new Date());
            }
        }, 0, 2000);

方式二：ScheduledExecutorServiced定时器

 // 1、创建ScheduledExecutorService线程池，做定时器
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(3);

        // 2、开启定时任务
        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行输出：AAA  ==》 " + new Date());

并发：CPU分时轮询的执行线程

并行：同一时刻同时在执行

胡春祥
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程
Li某人_初学者
07-28 166
线程 进程与线程_并行与并发的概念 进程：是“操作系统”的概念，指一个“独立运行的程序”，由操作系统管理。 线程：是由“进程”创建。指一个“进程”中可以将一段代码分离出来，与“主进程”“同时”执行。这样可以使我们的程序同时做多件事情，提高程序的运行效率。 其实Java程序本身都是“多线程”的。JVM启动(进程)，会加载我们的main()方法，会被JVM以“线程”的方式执行。 “垃圾回收器(GC)”也会被JVM以“线程”的方式在运行。 并发：一颗CPU,多个线程； 并行：两颗CPU，两个线程； 创建线程的
Java多线程详解及示例
07-20
本文将深入探讨Java多线程编程的重要性和使用方法。介绍多线程概念，讨论多线程的优势，并提供实际示例。此外，还将探讨多线程编程中的常见问题以及如何...通过本文，您将获得对Java多线程编程的全面理解和实践经验。
多线程简介
Bug_marker的博客
11-29 4674
一、概念 1、并发与并行 并行：多个任务在同一个时刻点同时执行。效率高 并发：多个任务在同一段时间内分时执行。效率低，宏观上同时执行，微观上分时执行。 2、进程与线程 进程：内存中正在运行的应用程序，是系统进行资源分配和调度的基本单位。每一个进程有自己独立的运行空间，相互之间不影响。进程就是程序的一次执行过程，即是一个进程从加载到内存到从内存中释放消亡的过程。 线程：进程内部的独立运行单元，是操作系统能够进行运算调度的最小单位，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序.
Java多线程的知识点
weixin_59796310的博客
05-28 4862
Java多线程的知识点
多线程（Multi-Thread)
张议的博客
01-21 6501
文章目录线程概念多线程编程的目的进程单线程多线程线程与进程的区别Process vs ThreadJava线程模型多线程的优势线程的实现停止线程线程的生命周期线程的优先级多线程的同步线程组 线程概念 什么是线程： 线程就是程序中单独顺序的流控制。线程本身不能运行，它只能用于程序中。 什么是多线程： 多线程则指的是在单个程序中可以同时运行多个不同的线程执行不同的任务. 说明：线程是程序内的顺序...
多线程（基础）
Maddoxzhi的博客
10-30 192
进程是进程实体的运行过程，是系统进行资源分配和调度的一个独立单位 进程实体（进程映像）：由程序段、相关的数据段和PCB（进程控制块）三部分构成 线程是一个基本的CPU执行单元，也是程序执行流的最小单位。线程是为了减少程序并发执行时的开销引入的。
JAVA高质量并发详解,多线程并发深入讲解
最新发布
04-24
本书全面解析了Java并发编程的核心概念、原理和实践，帮助读者深入理解多线程并发编程的精髓，提升编程能力和系统性能。 书中首先介绍了并发编程的基础知识，包括线程的基本概念、线程的生命周期、线程安全等问题。...
C++多线程编程视频教程（C++11多线程并发）【122212】多线程API详解（一）.rar
03-13
《C++面向对象多线程编程》推荐：毫无疑问，这是我见过的最好的、最全面的多线程方面的图书。如果你把自己看作一位程序员，而不是组件装配员，那你就需要了解多线程方面的知识。只要不是刚刚入门的C++程序员都可以从...
Java多线程中ReentrantLock与Condition详解
08-28
Java多线程中ReentrantLock与Condition详解 ReentrantLock是Java多线程中一种高级的锁机制，它实现了Lock接口，提供了与synchronized相同的并发性和内存语义，但添加了一些特性，如锁投票、定时锁等候和可中断锁...
Java多线程编程详解
09-11
Java多线程编程详解,系统、全面、详细的讲解了java多线程编程，结合经典实例描述了演示了多线程的使用。
多线程范例
01-30
在C＋＋Builer中多线程的实现，首先，先介绍一下实现多线程的具体步骤。在C＋＋Builder中虽然用Tthread对象说明了线程的概念，但是Tthread对象本身并不完整，需要在TThread下新建其子类，并重载Execute方法来使用线程对象。多线程的编程一般的书籍都介绍得比较少，而实际应用中，多线程编程又是如此的重要，因此，通过对多线程编程比较全面的介绍，愿能达到抛砖引玉之效。
Java通俗易懂30天 第18天:多线程(上)
程序员小刘
09-16 1150
文章目录文章目录第8章 多线程基本概念：程序、进程、线程进程与线程使用多线程的优点何时需要多线程线程的创建和使用线程的创建和启动Thread类API中创建线程的两种方式创建多线程的方式一：继承Thread类创建过程中的两个问题说明练习1Thread类的有关方法线程的调度; 线程的优先级练习2练习3创建多线程的方式二：实现Runnable接口继承方式和实现方式的联系与区别补充：线程的分类 文章目录 全部源码：https://github.com/name365/JavaSE-30Day 第8章 多线程 .
多线程详解
wsmbnyzwn的博客
09-03 135
对Java中的多线程进行讲解
2021-01-27
sun131217的博客
01-27 114
多线程概述与线程池介绍 一、多线程概述 1.进程与线程 1）进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间 2）线程：是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行，一个进程最少有一个线程。 线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程。 2.线程调度 1）分时调度 所有线程轮流使用 CPU 的使用权...
多线程常见的面试题
热门推荐
上山打卤面的博客
09-16 1万+
多线程常见的面试题： 1. 什么是线程和进程? 线程与进程的关系,区别及优缺点？ 进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。 在 Java 中，当我们启动 main 函数时其实就是启动了一个 JVM 的进程，而 main 函数所在的线程就是这个进程中的一个线程，也称主线程。 如下图所示，在 windows 中通过查看任务管理器的方式，我们就可以清楚看到 window 当前运行的进程（.exe 文件的运行）。 线程与进程相似，
进程和线程是操作系统基本概念，了解一下
tklwj的专栏
09-18 704
进程（process）和线程（thread）是操作系统的基本概念，但是它们比较抽象，不容易掌握。最近，我读到一篇材料，发现有一个很好的类比，可以把它们解释地清晰易懂。计算机的核心是CPU，它承担了所有的计算任务。...
多线程的深入理解
张叔的博客
09-30 2236
单线程和多线程的比较 多线程的创建方式 调用start方法和调用run方法的区别
多线程 详解(掌握这篇就够了)
qq_43377329的博客
03-18 5610
文章目录一、线程简介Process和Thread程序 进程 线程核心概念二、线程创建(重点)1、继承Thread2、实现Runnable接口(推荐使用)3、 实现Callable接口4、龟兔赛跑5、小结继承Thread类实现Runnable接口静态代理Thread静态代理底层剖析动态代理newProxyInstance解析动态代理多个接口动态代理的秘密代理的作用总结lambda表达式三、线程状态（五大状态）状态概念线程方法停止线程（使用标志位）线程休眠（sleep）模拟网络延迟sleep获取当前时间线程礼让
Android 多线程
07-27
Android 多线程可以通过使用AsyncTask类或Handler类来实现。引用\[1\]中提到了AsyncTask类的使用方法。AsyncTask是一个封装好的线程池，可以方便地在后台执行任务，并在主线程更新UI。在AsyncTask中，需要在主线程中创建实例，并在主线程中调用execute()方法来执行任务。每个AsyncTask实例只能执行一次execute()，如果需要执行多次，则需要创建多个实例。在AsyncTask的子类中，需要重写doInBackground()方法来执行后台任务，可以通过isCancelled()方法来判断任务是否被取消。当任务被取消时，会回调onCanceled(obj)方法，而不会调用onPostExecute()方法。引用\[2\]中提到了使用Handler类来实现多线程。可以在主线程中创建Handler实例，并在工作线程中使用Handler.post()方法发送消息到消息队列中，然后在Handler的回调方法中指定操作UI内容。通过这种方式，可以在工作线程中更新UI。需要注意的是，Handler只能在主线程中创建，并且需要在工作线程中开启Handler。以上是Android中实现多线程的两种常用方法。 #### 引用[.reference_title] - *1* *3* [Android开发中四种常用的多线程实现方式](https://blog.csdn.net/star_nwe/article/details/130140238)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* [全面详解Android实现多线程的几种方式（史上最全，最详细）](https://blog.csdn.net/fubrty/article/details/124689121)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值