超详细的多线程学习文档

最新推荐文章于 2024-08-22 21:30:30 发布
最新推荐文章于 2024-08-22 21:30:30 发布
阅读量583 收藏 20
点赞数 21
文章标签： 学习 java ide
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_76727129/article/details/140963919
版权

多线程

多线程的创建

创建方式1：继承Thread类

在这里插入图片描述

在这里插入图片描述

public class MainTest {
    public static void main(String[] args) {
        //创建线程对象
        MyThread myThread=new MyThread();
        //启动线程
        myThread.start();
        
        for (int i = 1; i <=5 ; i++) {
            System.out.println("主线程："+i);
        }
    }
}
public class MyThread extends Thread{
    @Override
    public void run() {
        //这里定义子线程完成的任务
        for (int i = 1; i <= 5; i++) {
            System.out.println("子线程MyThread："+i);
        }
    }
}

在这里插入图片描述

创建方式2：实现Runnable接口

在这里插入图片描述

public class MainTest {
    public static void main(String[] args) {
       
        MyRunnable myRunnable=new MyRunnable();
        new Thread(myRunnable).start();
       
        for (int i = 1; i <=5 ; i++) {
            System.out.println("主线程："+i);
        }
    }
}
public class MyRunnable implements Runnable{

    @Override
    public void run() {
        for (int i = 1; i <=5 ; i++) {
            System.out.println("子线程："+i);
        }
    }
}

在这里插入图片描述

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

        //子线程2,Lambda表达式
        new Thread(() ->{
            for (int i = 1; i <=5 ; i++) {
                System.out.println("子线程2："+i);
            }
        }).start();

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

        for (int i = 1; i <=5 ; i++) {
            System.out.println("主线程："+i);
        }

创建方式3：实现Callable接口

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

public class MainTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        //1、创建实现了Callable接口类的对象
        Callable<String> callable=new MyCallable(100);
        //2、把Callable的对象封装成一盒FutureTask对象（任务对象）
        //未来任务对象的作用？
        //1、是一个任务对象，实现列Runnable接口
        //2、可以在线程执行完毕后，用未来对象调用get方法获取线程执行完毕的返回值
        FutureTask<String> f1=new FutureTask<>(callable);
        //3、把任务对象交给一个Thread对象
        new Thread(f1).start();
        
        //4、获取线程执行完毕后返回的结果
        //注意：如果执行到这，假如上面的线程还没有执行完毕
        //这里的代码会暂停，等待上面线程执行完毕后才会获取结果
        //同时这里也要处理相应的异常
        String s = f1.get();
        System.out.println(s);

    }
}
public class MyCallable implements Callable<String> {
    private int n;

    public MyCallable(int n) {
        this.n = n;
    }

    @Override
    public String call() throws Exception {
        //描述此线程完成的任务
        int sum=0;
        for (int i = 1; i <=n ; i++) {
            sum+=i;
        }
        return "从1加到"+n+"的结果是："+sum;
    }
}

线程常用方法

在这里插入图片描述

public class MyThread extends Thread{
    public MyThread(String name){
        super(name); //1.执行父类Thread(String name)构造器，为当前线程设置名字了
    }
    @Override
    public void run() {
        //2.currentThread() 哪个线程执行它，它就会得到哪个线程对象。
        Thread t = Thread.currentThread();
        for (int i = 1; i <= 3; i++) {
            //3.getName() 获取线程名称
            System.out.println(t.getName() + "输出：" + i);
        }
    }
}
public class ThreadTest1 {
    public static void main(String[] args) {
        Thread t1 = new MyThread();
        t1.setName(String name) //设置线程名称;
        t1.start();
        System.out.println(t1.getName());  //Thread-0

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

        // 主线程对象的名字
        // 哪个线程执行它，它就会得到哪个线程对象。
        Thread m = Thread.currentThread();
        m.setName("最牛的线程");
        System.out.println(m.getName()); // main

        for (int i = 1; i <= 5; i++) {
            System.out.println(m.getName() + "线程输出：" + i);
        }
    }
}

在这里插入图片描述

join方法调用：

public class ThreadTest2 {
    public static void main(String[] args) throws Exception {
        // join方法作用：让当前调用这个方法的线程先执行完。
        Thread t1 = new MyThread("1号线程");
        t1.start();
        t1.join();

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

        Thread t3 = new MyThread("3号线程");
        t3.start();
        t3.join();
    }

执行效果是1号线程先执行完，再执行2号线程；2号线程执行完，再执行3号线程；3号线程执行完就结束了。

线程安全问题

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

线程同步：解决线程安全问题

同步思想概述

在这里插入图片描述

小红获得锁，操作完成后会释放锁

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

方式一：同步代码块

在这里插入图片描述

同步代码块的作用就是把访问共享数据的代码锁起来，以此保证线程安全。

//锁对象：必须是一个唯一的对象（同一个地址）
synchronized(锁对象){
    //...访问共享数据的代码...
}

使用同步代码块，来解决前面代码里面的线程安全问题。我们只需要修改DrawThread类中的代码即可。

// 小明 小红线程同时过来的
public void drawMoney(double money) {
    // 先搞清楚是谁来取钱？
    String name = Thread.currentThread().getName();
    // 1、判断余额是否足够
    // this正好代表共享资源！
    synchronized (this) {
        if(this.money >= money){
            System.out.println(name + "来取钱" + money + "成功！");
            this.money -= money;
            System.out.println(name + "来取钱后，余额剩余：" + this.money);
        }else {
            System.out.println(name + "来取钱：余额不足~");
        }
    }
}

此时再运行测试类，观察是否会出现不合理的情况。

最后，针对锁对象如何选择：

1.建议把共享资源作为锁对象, 不要将随便无关的对象当做锁对象
2.对于实例方法，建议使用this作为锁对象
3.对于静态方法，建议把类的字节码(类名.class)当做锁对象
方式二：同步方法

在这里插入图片描述

在这里插入图片描述

方式三：Lock锁

在这里插入图片描述

1.首先在成员变量位子，需要创建一个Lock接口的实现类对象（这个对象就是锁对象）
	private final Lock lk = new ReentrantLock();
2.在需要上锁的地方加入下面的代码
	 lk.lock(); // 加锁
	 //...中间是被锁住的代码...
	 lk.unlock(); // 解锁

// 创建了一个锁对象
private final Lock lk = new ReentrantLock();

public void drawMoney(double money) {
        // 先搞清楚是谁来取钱？
        String name = Thread.currentThread().getName();
        try {
            lk.lock(); // 加锁
            // 1、判断余额是否足够
            if(this.money >= money){
                System.out.println(name + "来取钱" + money + "成功！");
                this.money -= money;
                System.out.println(name + "来取钱后，余额剩余：" + this.money);
            }else {
                System.out.println(name + "来取钱：余额不足~");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lk.unlock(); // 解锁
        }
    }
}

线程通信（了解）

首先，什么是线程通信呢？

  • 当多个线程共同操作共享资源时，线程间通过某种方式互相告知自己的状态，以相互协调，避免无效的资源挣抢。

线程通信的常见模式：是生产者与消费者模型

  • 生产者线程负责生成数据
  • 消费者线程负责消费生产者生成的数据
  • 注意：生产者生产完数据后应该让自己等待，通知其他消费者消费；消费者消费完数据之后应该让自己等待，同时通知生产者生成。

比如下面案例中，有3个厨师（生产者线程），两个顾客（消费者线程）。

在这里插入图片描述

接下来，我们先分析一下完成这个案例的思路

1.先确定在这个案例中，什么是共享数据？
	答：这里案例中桌子是共享数据，因为厨师和顾客都需要对桌子上的包子进行操作。

2.再确定有那几条线程？哪个是生产者，哪个是消费者？
	答：厨师是生产者线程，3条生产者线程； 
	   顾客是消费者线程，2条消费者线程
	   
3.什么时候将哪一个线程设置为什么状态
	生产者线程(厨师)放包子：
		 1)先判断是否有包子
		 2)没有包子时，厨师开始做包子, 做完之后把别人唤醒，然后让自己等待
		 3)有包子时，不做包子了，直接唤醒别人、然后让自己等待
		 	
	消费者线程(顾客)吃包子：
		 1)先判断是否有包子
		 2)有包子时，顾客开始吃包子, 吃完之后把别人唤醒，然后让自己等待
		 3)没有包子时，不吃包子了，直接唤醒别人、然后让自己等待

在这里插入图片描述

按照上面分析的思路写代码。

桌子类：

public class Desk {
    private List<String> list=new ArrayList<>();

    /**
     * 同步方法，所得对象是this
     * 厨师1、厨师2、厨师3
     */
    public synchronized void put() {
        try {
            if (list.isEmpty()){
                String name = Thread.currentThread().getName();
                list.add(name+"做的包子！");
                System.out.println(name+"做了包子！");
                Thread.sleep(2000);

                //唤醒其他线程，该线程等待
                this.notifyAll();
                this.wait();
            }else
            {
                //唤醒其他线程，该线程等待
                this.notifyAll();
                this.wait();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    /**
     * 吃货1、吃货2
     * 这两个同步方法的锁是同一个即this
     */
    public synchronized  void get() {
        try {
            if (!list.isEmpty()){
                String name = Thread.currentThread().getName();
                System.out.println(name+"吃了"+list.get(0));
                Thread.sleep(1000);
                //清空集合
                list.clear();
                //唤醒其他线程，该线程等待
                this.notifyAll();
                this.wait();
            }else {
                //唤醒其他线程，该线程等待
                this.notifyAll();
                this.wait();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

测试类：

public class MainTest {
    public static void main(String[] args)  {
        //创建桌子对象
        Desk desk=new Desk();

        //创建3个厨师线程
        new Thread(() ->{
               while (true){
                   desk.put();
               }
        },"厨师1").start();
        new Thread(() ->{
            while (true){
                desk.put();
            }
        },"厨师2").start();
        new Thread(() ->{
            while (true){
                desk.put();
            }
        },"厨师3").start();
        new Thread(() ->{
            while (true){
                desk.get();
            }
        },"吃货1").start();
        new Thread(() ->{
            while (true){
                desk.get();
            }
        },"吃货2").start();

    }
}

线程池（重要）

认识线程池

在这里插入图片描述

而使用线程池，就可以解决上面的问题。如下图所示，线程池内部会有一个容器，存储几个核心线程，假设有3个核心线程，这3个核心线程可以处理3个任务。

在这里插入图片描述

但是任务总有被执行完的时候，假设第1个线程的任务执行完了，那么第1个线程就空闲下来了，有新的任务时，空闲下来的第1个线程可以去执行其他任务。依此内推，这3个线程可以不断的复用，也可以执行很多个任务。

在这里插入图片描述

所以，线程池就是一个线程复用技术，它可以提高线程的利用率。

创建线程池

在这里插入图片描述

面试时可能会问

在这里插入图片描述

在这里插入图片描述

注意：核心线程数的选择

需要根据具体需求具体分析，以下是一些经验（只做参考）：
1、计算密集型（基本上都是运算）的任务：核心线程数=CPU的核数+1
2、IO密集型（涉及读写文件）的任务：核心线程数=CPU的核数*2

在这里插入图片描述

线程池执行Runnable任务

在这里插入图片描述

public class MainTest {
    public static void main(String[] args) {
        //创建线程池对象
       ExecutorService pool=new ThreadPoolExecutor(
                3, 5, 8, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory()
                , new ThreadPoolExecutor.AbortPolicy());
       Runnable runnable=new MyRunnable();
       //执行Runnable任务
        pool.execute(runnable);//线程池会自动创建一个新线程，自动执行任务
        pool.execute(runnable);//线程池会自动创建一个新线程，自动执行任务
        pool.execute(runnable);//线程池会自动创建一个新线程，自动执行任务
        pool.execute(runnable);//复用核心线程池
        pool.execute(runnable);//复用核心线程池
        pool.execute(runnable);//复用核心线程池
        pool.execute(runnable);//复用核心线程池，此时，任务队列满了

//        pool.execute(runnable);//当核心线程都被占用且任务队列满了，此时若还能创建临时线程则创建临时线程
//        pool.execute(runnable);//创建临时线程
        //到了拒绝新任务的时候
        pool.execute(runnable);


//        pool.shutdown();//执行完线程任务关闭线程池
        pool.shutdownNow();//立即关闭线程池，停止正在执行的任务，并返回队列中未执行的任务

    }
}
public class MyRunnable implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
线程池执行Callable任务

在这里插入图片描述

public class MyCallable implements Callable<String> {
    private int n;
    public MyCallable(int n) {
        this.n = n;
    }

    // 2、重写call方法
    @Override
    public String call() throws Exception {
        // 描述线程的任务，返回线程执行返回后的结果。
        // 需求：求1-n的和返回。
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return Thread.currentThread().getName() + "求出了1-" + n + "的和是：" + sum;
    }
}
public class ThreadPoolTest2 {
    public static void main(String[] args) throws Exception {
        // 1、通过ThreadPoolExecutor创建一个线程池对象。
        ExecutorService pool = new ThreadPoolExecutor(
            3,
            5,
            8,
            TimeUnit.SECONDS, 
            new ArrayBlockingQueue<>(4),
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.CallerRunsPolicy());

        // 2、使用线程处理Callable任务。
        Future<String> f1 = pool.submit(new MyCallable(100));
        Future<String> f2 = pool.submit(new MyCallable(200));
        Future<String> f3 = pool.submit(new MyCallable(300));
        Future<String> f4 = pool.submit(new MyCallable(400));

        // 3、执行完Callable任务后，需要获取返回结果。
        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());
    }
}

执行后，结果如下图所示

在这里插入图片描述

Executors工具类实现线程池

在这里插入图片描述

在这里插入图片描述

补充：并行、并发、生命周期（重要）

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

多线程到底是怎么在执行的？

并发和并行同时进行！！！

线程的生命周期

在这里插入图片描述

在这里插入图片描述

补充：悲观锁与乐观锁

悲观锁：一上来就加锁，每一个线程都是要排队，没有安全感，每次只能一个线程进入访问完毕后，再解锁。线程安全，但性能较差！

乐观锁：一开始不上锁，认为是没有问题，大家一起跑，等要出现线程安全问题的时候才开始控制。线程安全，性能好！

乐观锁涉及到CAS算法（比较修改算法），其中对一些数的操作已经封装成了原子类，如Int类型的原子类是AtomicInteger，内部就是实现了乐观锁。
西格玛zzhh
关注
  • 21
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java 超详细api参考文档
08-17
8. **java.concurrent**：并发和多线程编程相关类，如Thread、ExecutorService、Semaphore等，帮助开发者编写高效的多线程程序。 9. **java.math**：提供大整数（BigInteger）和高精度浮点数（BigDecimal）运算，...
IOS线程学习文档+实例代码，特别适合新手学习，超好
06-21
在iOS开发中，多线程是一项至关重要的技术，它能够帮助开发者实现应用的高效运行，提升用户体验。本文将深入探讨iOS线程的概念、类型、管理方法，并结合实例代码，为初学者提供一个全面的学习指南。 一、iOS线程...
多线程01(md文档+代码)多线程01(md文档+代码)（超详细）
05-14
本资源包“多线程01”包含了关于多线程的详细讲解，包括Markdown文档和配套代码示例，旨在帮助初学者或有经验的开发者深入理解并熟练掌握多线程技术。 一、多线程基础 多线程是指在一个进程中同时运行多个独立的...
超级多文档文本编辑器源码
11-18
- 多线程：用于实现并发处理，提高编辑器的响应速度，特别是在处理大文件时。 - 内存管理：优化内存分配和释放，避免内存泄漏。 - 编译器接口：如果编辑器支持代码编译功能，需要与编译器进行交互，如C++的g++或Java...
超简单Java多线程填表源码.zip
11-16
"超简单Java多线程填表源码.zip"这个压缩包文件很可能包含了一个简单的示例，演示如何使用Java来实现多线程处理表格数据。下面我们将详细探讨Java中的多线程以及可能在源码中涉及的概念。 首先，我们要了解Java中...
Freertos学习笔记
qq_45031559的博客
08-21 577
Freertos学习笔记
零基础学习人工智能—Python—Pytorch学习（六）
kiba518的博客
08-21 525
前言 本文主要讲神经网络的上半部分。 这篇文章开始有很多公式了，这些公式都很简单，但是如果是不经常在脑海里思考公式的人，那可能需要多花点时间做一下自我训练，个人感觉，也就几天时间，就能把自己感觉给调整出来。 习惯了公式看下面内容就会轻松很多，另外如果要深入学习人工智能，熟练的认知公式也是个必须的事情。 另外，我发现我前面文章写的有歧义的地方还是挺多，虽然，已经改了一部分，但，可能还有没发现的，大...
学习分享： Java 中调用 API 的一般方式
weixin_71842181的博客
08-19 352
学习分享： Java 中调用 API 的一般方式。
一起学习LeetCode热题100道（48/100）
weixin_53224223的博客
08-20 498
7.注意：虽然代码中包含了回溯部分（即减少当前路径和的计数并从prefixSums中删除它），但在本问题中，由于树是无环的，并且我们不需要精确跟踪每条路径，因此这部分是多余的。输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22。输入：root = [10,5,-3,3,2,null,11,3,-2,null,1], targetSum = 8。1.这是主函数，接收根节点和目标和作为参数，并返回满足条件的路径数量。
编程的魅力及基础知识和学习路径
z86666610的博客
08-19 189
这包括了解计算机如何工作（硬件与软件的关系）、熟悉基本的数据类型（如整数、浮点数、字符串等）、掌握条件语句和循环结构以实现逻辑判断与重复执行、以及理解函数和模块的概念以实现代码的复用和模块化。从古老的汇编语言到现代的Python、Java、C++等高级语言，每一种语言都有其独特的优势和适用场景，为开发者提供了广阔的选择空间。在数字化浪潮席卷全球的今天，编程已不再是计算机科学专业人士的专属领地，它如同一把钥匙，解锁了通往未来世界的无数可能。在这个充满变革的时代，掌握编程技能，就是掌握了开启未来之门的钥匙。
sed & awk 第二版学习（一）—— sed 与 awk 基本操作
wzy0623的专栏
08-20 937
sed 与 awk 基本操作
FreeRTOS学习笔记（四）——延时函数，列表，软件定时器，低功耗模式，内存管理
个人风格极强的知识汇总
08-20 1284
FreeRTOS学习笔记（四）——延时函数，列表，软件定时器，低功耗模式，内存管理
【鸿蒙学习】HarmonyOS应用开发者高级认证 - 一次开发，多端部署
一个不断前行的程序者
08-21 1201
HarmonyOS 系统面向多终端提供了“一次开发，多端部署”（后文中简称为“一多”）的能力，让开发者可以基于一种设计，高效构建多端可运行的应用。定义：一套代码工程，一次开发上架，多端按需部署。目标：支撑开发者快速高效的开发支持多种终端设备形态的应用，实现对不同设备兼容的同时，提供跨设备的流转、迁移和协同的分布式体验。
Python基础知识学习总结（七）
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
08-22 962
函数+文件IO流
Qt/QML学习-SwipeView
QT、QML
08-18 531
Qt/QML学习-SwipeView
Linux基础知识学习（五）
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
08-21 298
Linux用户组管理+磁盘管理+进程管理
不同主机之间的网络通信学习
m0_63195218的博客
08-21 813
共享内存 //最高效的进程间通信方式共享内存:1.是一块，内核预留的空间2.最高效的通信方式//避免了用户空间 到 内核空间的数据拷贝IPC通信方式 ---操作流程类似的操作:system v ： 共享内存IPC对象操作通用框架：0x ftokkey值 ==> 申请 ==》读写 ==》关闭 ==》卸载。
FreeRTOS学习：信号量
kkbbaaii的博客
08-20 882
FreeRTOS学习：信号量
0成本学习Liunx系统【只需要一台笔记本电脑，无需购买云服务器】
最新发布
辣椒炒肉~的博客
08-22 214
0成本学习Liunx系统【只需要一台笔记本电脑，无需购买云服务器】
多线程编程与JDBC深度指南：提升应用性能的关键
本文档涵盖了这两个领域的深入学习材料，旨在帮助读者理解和掌握多线程编程的基础和实战技巧，以及JDBC的高级应用。 首先，文章从多线程编程的基础篇开始，介绍了随着计算机技术进步，多线程编程模型作为最终模型的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值