java基础13--线程

已于 2022-11-09 15:03:52 修改
阅读量296 收藏
点赞数 1
分类专栏： java学习 文章标签： java
于 2022-08-10 20:18:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43903745/article/details/126272572
版权

线程

线程

线程的相关概念

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

线程的其他概念

并行：指两个或多个事件在同一时刻点发生；
并发：指两个或多个事件在同一时间段内发生（交替进行）在这里插入图片描述

线程的使用

创建线程的两种方式

在这里插入图片描述

继承Thread类

如果主线程先结束了，子线程还没结束，不代表程序的进程结束了
在这里插入图片描述

public class ThreadUse {
    @Override
    public void run() {
        super.run();
    }

    public static void main(String[] args) throws InterruptedException {
        Cat cat = new Cat();
        cat.start();//启动线程
        //说明:当main线程启动一个子线程Thread-0,主线程不会阻塞.会继续执行
        //这时主线程和子线程会交替执行
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
            Thread.sleep(1000);

        }
    }
}

//1.当一个类继承了Thread该类就可以作为一个线程类了
//2.我们会重写run方法,写上自己的业务代码
//3.run Thread类实现类Runnable接口的run方法
class Cat extends Thread {
    int times = 0;

    @Override
    public void run() {//重写run方法,写上自己的逻辑
        while (times < 10) {
            System.out.println("我是小喵喵" + (++times) + "线程名" + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
run方法和start方法的区别

1、线程中的start()方法和run()方法的主要区别在于，当程序调用start()方法，将会创建一个新线程去执行run()方法中的代码。但是如果直接调用run()方法的话，会直接在当前线程中执行run()中的代码，注意，这里不会创建新线程。这样run()就像一个普通方法一样。

2、另外当一个线程启动之后，不能重复调用start()，否则会报IllegalStateException异常。但是可以重复调用run()方法。

总结起来就是run()就是一个普通的方法，而start()会创建一个新线程去执行run()的代码。

源码解读

真正实现多线程效果的是本地的start0方法而不是run方法
在这里插入图片描述

在这里插入图片描述

实现Runnable接口

java是单继承的，所以想要创建线程只能通过实现Runnable接口来实现
在这里插入图片描述
在这里插入图片描述

具体实现方法（静态代理方式）

在Thread实例中传入要创建线程的对象

public class ThreadUse02 {

    public static void main(String[] args) {
        Dog dog = new Dog();
        //dog.start();这里不能调用start,因为没有这个方法
        //只能创建Thread对象,把dog对象(实现了Runnable),放入Thread
        Thread thread = new Thread(dog);
        //然后调用thread的start方法
        thread.start();
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
        }
    }
}

class Dog implements Runnable {
    int times = 0;

    @Override
    public void run() {
        while (times < 10) {
            System.out.println("我是汪汪" + (++times));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
模拟静态代理方式

要点：
1. 代理类和被代理类要实现同一个接口
2. 代理的构造方法中传入被代理对象
3. 代理调用接口中的某个方法，但实际的运行类型是被代理的类型（这边start和start0是为了模拟底层实现）

//线程代理类,模拟了极简的的Thread类
class ThreadProxy implements Runnable {
    //定义了Runnable类型的target
    private Runnable target = null;

    @Override
    public void run() {
        if (target != null) {
            target.run();//动态绑定(运行类型是传入代理的实参的运行类型,也就是Tiger类型,然后会调用tiger的run方法)
        }
    }

    //把形参赋给实参
    public ThreadProxy(Runnable target) {
        this.target = target;
    }

    //代理实例化后,使用代理的start()方法来对用本地的start0方法,该方法会对用run方法
    public void start() {
        start0();
    }

    public void start0() {
        run();
    }
}

class Animal {
}

//java中单继承,所以继承了Animal就不能继承Thread类了,所以只能实现Runnable接口
class Tiger extends Animal implements Runnable {
    int count = 0;

    @Override
    public void run() {
        System.out.println("老虎在咆哮" + (++count));
    }
}

多线程执行

public class MulThread02 {
    public static void main(String[] args) {
        T1 t1 = new T1();
        T2 t2 = new T2();
        Thread thread1 = new Thread(t1);
        Thread thread2 = new Thread(t2);
        thread1.start();
        thread2.start();
    }
}

class T1 implements Runnable {
    int count = 0;

    @Override
    public void run() {
        while (count < 5) {
            System.out.println("hi" + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class T2 implements Runnable {
    int count = 0;

    @Override
    public void run() {
        while (count < 10) {
            System.out.println("hello world" + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

继承Thread和实现Runnable的区别

在这里插入图片描述

多线程售票问题

在这里插入图片描述
出现了超卖问题
在这里插入图片描述

线程终止

两种方式

在这里插入图片描述
这边的通知方式其实就是设计一个标志

public class quit {

    public static void main(String[] args) {
        T t = new T();
        t.start();
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t.setLoop(false);

    }
}

class T extends Thread {
    int i = 0;
    boolean loop = true;

    public void setLoop(boolean loop) {
        this.loop = loop;
    }

    @Override
    public void run() {
        while (loop) {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(++i);
        }
    }
}

线程常用方法

注意：

  • 继承了Thread类才有的
  • 优先级只是说概率变大了，并不一定按照优先级顺序执行
  • interrupt()方法只是改变中断状态，不会中断一个正在运行的线程，它会设置该线程的中断状态位，即设置为true，中断的结果线程是死亡、还是等待新的任务或是继续运行至下一步，就取决于这个程序本身。(可以利用使用interrupt方法会修改isInterrupted状态位来中断循环，或者使用interrupt方法中断sleep时会抛出异常来中断进程)

在这里插入图片描述

public class ThreadJoinDemo {
    public static void main(String[] args) throws InterruptedException {
        final Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("打开冰箱！");
            }
        });
  
        final Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    thread1.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("拿出一瓶牛奶！");
            }
        });
  
        final Thread thread3 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    thread2.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("关上冰箱！");
            }
        });
  
        //下面三行代码顺序可随意调整，程序运行结果不受影响，因为我们在子线程中通过“join()方法”已经指定了运行顺序。
        thread3.start();
        thread2.start();
        thread1.start();
  
    }
}

    2.在主线程中通过join()方法指定顺序

public class ThreadMainJoinDemo {
    public static void main(String[] args) throws InterruptedException {
        final Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("打开冰箱！");
            }
        });
  
        final Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("拿出一瓶牛奶！");
            }
        });
  
        final Thread thread3 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("关上冰箱！");
            }
        });
  
        thread1.start();
        thread1.join();
        thread2.start();
        thread2.join();
        thread3.start();
    }
}

在这里插入图片描述
注意：

  • yield不一定礼让成功
  • join一定成功，先start后join
  • 可以通过join指定线程的执行顺序
    1.在子线程中通过join()方法指定顺序

注意事项和细节

在这里插入图片描述

用户线程和守护线程

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

用法

daemon.setDaemon(true);
注意： 该方法在start方法前，否则报异常

线程的生命周期

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

线程同步

线程同步机制

在这里插入图片描述

线程同步的方法

Synchronized关键字

在这里插入图片描述

线程同步的原理

始终只能有一个线程去“开锁”，操作数据
在这里插入图片描述

互斥锁

售票问题（有助于充分理解线程）

注意事项：

  1. 要知道当前到底有几个线程
  2. 要知道当前的票是属于线程对象的还是属于线程类变量的
package com.bijing.thread.ticket;

/**
 * @author 毕晶
 * @date 2022/6/18 8:22 PM
 */
public class SellTicket {
    public static void main(String[] args) throws InterruptedException {
        //三个线程对象,只能通过static来实现资源"票"共享,锁的是类对象,资源也是类变量
        //类变量num=100;
//        T1 t1 = new T1();
//        T1 t2 = new T1();
//        T1 t3 = new T1();
//        t1.start();
//        t2.start();
//        t3.start();

//        三个线程对象,但是共享了同一个线程资源(类变量的),有static,锁定还是类对象
//        T2 t1 = new T2();
//        T2 t2 = new T2();
//        T2 t3 = new T2();
//        new Thread(t1).start();
//        new Thread(t2).start();
//        new Thread(t3).start();

//       同一份资源"票"被三个线程共享,无static,锁的是当前获得资源的线程对象,一个厕所三个人用,谁用谁上锁
        T3 t3 = new T3();
        new Thread(t3).start();
        new Thread(t3).start();
        new Thread(t3).start();

//        三份资源"票"被三个线程共享,无static,锁的是当前获得资源的线程对象,三个厕所三个人用,谁用谁上锁
//        T4 t1 = new T4();
//        T4 t2 = new T4();
//        T4 t3 = new T4();
//        new Thread(t1).start();
//        new Thread(t2).start();
//        new Thread(t3).start();

    }
}

class T1 extends Thread {
    public static int num = 500;
    public static boolean flag = true;

    @Override
    public void run() {
        while (flag) {
            sell();
        }
    }

    public synchronized static void sell() {
        if (num > 0) {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票, 剩余票数=" + (--num));
        } else {
            System.out.println("售票结束");
            flag = false;
            return;
        }
    }
}

class T2 implements Runnable {
    public static int num = 500;
    public static boolean flag = true;

    @Override
    public void run() {
        while (flag) {
            sell();
        }
    }

    public synchronized static void sell() {
        if (num > 0) {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票, 剩余票数=" + (--num));
        } else {
            System.out.println("售票结束");
            flag = false;
            return;
        }
    }
}

class T3 implements Runnable {
    public int num = 500;

    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                if (num > 0) {
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票, 剩余票数=" + (--num));
                } else {
                    System.out.println("售票结束");
                    break;
                }
            }
        }

    }
}

class T4 implements Runnable {
    public int num = 100;

    @Override
    public void run() {
        synchronized (this) {
            while (true) {
                if (num > 0) {
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票, 剩余票数=" + (--num));
                } else {
                    System.out.println("售票结束");
                    break;
                }
            }
        }

    }
}

线程死锁

在这里插入图片描述

释放锁

在这里插入图片描述

不释放锁

在这里插入图片描述

作业

在这里插入图片描述
分析：

  1. 一个类访问另一个类的数据，要么用static，要么实例化一个类，这边显示实例化更好
  2. 在随机打印过程中要读取Q，这显然是并发的，所以要使用多线程，如果就单线程的话会出现打印动作不结束，读取Q就不进行
public class Homework01 {

    public static void main(String[] args) {
        T1 t1 = new T1();
        T2 t2 = new T2(t1);
//        t1.setDaemon(true);  或者不用setLoop,用守护线程,把t1设为守护线程,t2完成后t1自动结束
        t1.start();
        t2.start();
    }
}

class T1 extends Thread {
    private boolean loop = true;

    @Override
    public void run() {
        while (loop) {
            System.out.println((int) (Math.random() * 100 + 1));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}

class T2 extends Thread {
    Scanner scanner = new Scanner(System.in);
    String input;
    T1 t1;
    
    // 确保t2操作的是同一个t1
    public T2(T1 t1) {
        this.t1 = t1;
    }

    @Override
    public void run() {
        while (true) {
            System.out.println("请输入:");
            input = scanner.next();
            if (input.contains("Q")) {
                t1.setLoop(false);
                break;
            }
        }
    }
}
*MaybE
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java基础---多线程宝典
codeLife
11-30 1万+
多线程 文章目录多线程核心概念`Process`与`Thread`线程三种创建方式继承`Thread`类使用多线程实现下载网络图片实现`Runnable`接口多线程同时操作同一个对象模拟龟兔赛跑(线程执行速度)实现`Callable`接口静态代理`Lanmda`表达式简介作用：函数式接口`Functional Interface`定义示例：Lambda表达式简化：总结线程状态创建总结就绪线程礼让运行阻塞线程休眠`Sleep``Join`合并线程死亡线程状态观测线程优先级守护线（daemon）程线程同步死锁产
java基础知识【第17期】-- 线程
小郭的博客
05-24 172
导读: 本篇是JAVA基础系列的第17篇，今天我们梳理java 多线程的相关知识点。多线程几乎是面试中必问的题，所以掌握一定的基础知识是必须的。而且线程是很多知识点的基础，例如我们之前在学习字符串操作类时，StringBuffer类就是线程安全。 1.线程与进程 进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同 时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序 即是一个进程从创建、运行到消亡的过程。 线程...
Java基础 -- 多线程的使用01
百世经纶『一页書』
01-26 8163
一文详解java 多线程的使用
Java高级特性 - 多线程基础（1）使用线程
weixin_62440328的博客
11-25 1133
【代码】Java高级特性 - 多线程基础（1）使用线程。
java基础--13
g_yaoyao的专栏
11-23 222
String类 1、概述  String s1="abc";  String s2=new String("abc");  s1是一个类类型变量，"abc"是一个对象  字符串最大特点：一旦被初始化就不可以被改变  String类复写了Object类中的equals方法，该方法用于判断字符串是否相同。  s1和s2的区别：s1在内存中有一个对象，s2在内存中有两个对象 2、获取和判
java基础教程----精华版
09-22
这个"java基础教程----精华版"显然是一份精心整理的资料，旨在帮助初学者快速掌握Java编程的基础知识。下面将详细介绍Java语言的核心概念和关键知识点。 1. **Java语法基础**： - **变量**：在Java中，变量是存储...
JAVA-多线程 所有文件
01-09
13. **并发集合**：Java并发库提供了一些线程安全的集合，如`ConcurrentHashMap`, `CopyOnWriteArrayList`, `ConcurrentLinkedQueue`等，它们在多线程环境下表现更优。 在实际项目中，理解和熟练运用这些多线程知识...
Java基础[06-多线程].ppt
12-09
Java中的多线程是编程中一个重要的概念，尤其在大数据处理和并发操作中不可或缺。Java提供了两种主要的方式来创建和管理线程：继承`Thread`类和实现`Runnable`接口。 **1. 继承Thread类实现多线程** 当你创建一个...
java线程1-10-720p版本
02-13
通过这10个视频的学习，你将能够掌握Java线程的基本操作，了解线程的创建、执行、协作和管理，为实现高效的并发程序打下坚实的基础。在实际开发中，结合这些知识，你可以编写出更加健壮、性能优异的多线程应用程序。
零基础Java入门课程-多线程
07-01
在IT行业中，Java是一种广泛应用的编程语言，尤其在企业级...文档"零基础Java入门课程-多线程-20201217202008101.docx"很可能是课程的详细讲义或笔记，包含了上述知识点的详细解释和实例，建议仔细研读，以加深理解。
golang 接口
m0_70982551的博客
07-24 965
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 519
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 658
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 595
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 367
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 429
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
学习笔记---java篇（0723）
m0_70630166的博客
07-23 863
java、数据类型、循环、选择等
新建springboot项目找不到java版本8?
最新发布
weixin_74009895的博客
07-28 103
新建springboot项目找不到java版本8?
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
PAP
07-26 188
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
Java线程编程基础与实战
守护线程是一种特殊的线程，当所有的非守护线程结束后，即使还有守护线程在运行，Java虚拟机也会退出。通常用于后台服务，如垃圾回收器。 15.7 线程池（Executor Service） Java提供的Executor框架允许创建和管理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值