AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Java 基础入门 | 第十五章 Java多线程

2023-01-13 65
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 目录线程的概念线程的使用线程的状态线程同步问题死锁和解决办法线程的概念什么是线程在一个程序中同时运行的多个独立流程，每一个独立的流程就是一个线程线程并发多个线程并发执行主线程 CPU 优先级 时间片 资源当

 线程的概念

什么是线程

在一个程序中同时运行的多个独立流程，每一个独立的流程就是一个线程

线程并发

多个线程并发执行

主线程  CPU  优先级   时间片  资源

当JVM启动之后，加载类文件，发现main方法，那么就会为main方法创建一个线程，用于main方法执行，这个为main方法创建的线程称为主线程

线程的使用

在Java中创建线程的方法有两种

    • 方法一  继承java.lang.Thread类
    • 方法二  实现java.lang.Runnable接口

    继承Thread类

      • 自定义一个线程类继承自Thread
      • 重写Thread的run方法
      • 创建一个该类的对象
      • 调用该类继承自Thread的start方法开启线程

      代码示例

      public class MyThread1 extends Thread{
    public void run(){
        for (int i = 0; i < 1000; i++) {
            System.out.println(i+" $$$");
        }
    }
}

      image.gif

      public class MyThread2 extends Thread{
    public void run(){
        for (int i = 0; i < 1000; i++) {
            System.out.println(i+" ###");
        }
    }
}

      image.gif

      public class ThreadTest {
    public static void main(String[] args) {
        Thread t1=new MyThread1();
        Thread t2=new MyThread2();
        //启动线程
        t1.start();
        t2.start();
    }
}

      image.gif

      Runnable接口开发线程

        • 用户开发一个类实现Runnable接口
        • 实现run()
        • 运行线程

        代码示例 

        public class MyRunnable1 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println(i+" $$$");
        }
    }
}

        image.gif

        public class MyRunnable2 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println(i+" ###");
        }
    }
}

        image.gif

        public class ThreadTest {
    public static void main(String[] args) {
        Runnable r1=new MyRunnable1();
        Thread t1=new Thread(r1);
        Runnable r2=new MyRunnable2();
        Thread t2=new Thread(r2);
        //启动线程
        t1.start();
        t2.start();
    }
}

        image.gif

        线程使用总结

          • 根据学习过的知识判断，以上两种线程创建方法，哪一种更好--第二种实现了任务代码和API的分离
          • 程序的输出结果固定吗？
          • 程序中存在几个线程？执行的先后顺序
          • 可不可以直接在main方法中直接调用run()

          线程的状态

            • 初始状态
            • 可运行状态
            • 运行状态
            • 终结状态

            image.gif编辑

            sleep方法

            void sleep(long time)方法用于使当前线程休眠指定的毫秒数

            public class MyThread1 extends Thread{
    public void run(){
        for (int i = 0; i < 1000; i++) {
            System.out.println(i+" $$$");
            try {
                //睡眠1秒
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

            image.gif

            public class MyRunnable1 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println(i+" $$$");
            try {
                //睡眠1秒
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

            image.gif

            一旦调用了sleep方法，该线程就由运行状态进入了阻塞状态

            image.gif编辑join方法的使用

              • 利用sleep方法对线程的控制是非常不精确的
              • join方法可以精确控制线程
              • join方法也会导致线程阻塞
              • 特点：如果当前线程中调用了另外一个线程的 join方法，当前线程会立即阻塞，直到另外一个线程运行完成
              public class MyThread1 extends Thread{
    public void run(){
        for (int i = 0; i < 1000; i++) {
            System.out.println(i+" $$$");
        }
    }
}

              image.gif

              public class MyThread2 extends Thread{
    Thread thread;
    public void run(){
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i < 1000; i++) {
            System.out.println(i+" ###");
        }
    }
}

              image.gif

              public class ThreadTest {
    public static void main(String[] args) {
        MyThread1 t1=new MyThread1();
        MyThread2 t2=new MyThread2();
        //将线程1赋值到MyThread2的属性thread
        t2.thread=t1;
        //启动线程
        t1.start();
        t2.start();
    }
}

              image.gif

              join方法的问题

              如果2个线程彼此调用对方的join方法，会导致程序无法进行。

              解决办法

              调用 void join(long millis)  方法

              客户存取款多线程实例

              public class Account {
    //银行账户余额
    private int balance;
    public Account(int balance) {
        this.balance = balance;
    }
    //存款方法
    public void deposit(int money){
        balance=balance+money;
    }
    //取款方法
    public void withdrawal(int money){
        if(money>balance){
            System.out.println("余额不足");
        }else{
            balance=balance-money;
        }
    }
    public int getBalance() {
        return balance;
    }
}

              image.gif

              public class PersonA extends Thread{
    //用户A的账户属性
    private  Account account;
    public PersonA(Account account){
        this.account=account;
    }
    public void run(){
        for (int i = 0; i < 2; i++) {
            System.out.println("此时账户还有"+account.getBalance()+"元");
            account.deposit(500);
            System.out.println("用户A存款500元");
            System.out.println("此时账户还有"+account.getBalance()+"元");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

              image.gif

              public class PersonB extends Thread{
    //用户B的账户属性
    private  Account account;
    public PersonB(Account account){
        this.account=account;
    }
    public void run(){
        for (int i = 0; i < 2; i++) {
            System.out.println("此时账户还有"+account.getBalance()+"元");
            account.withdrawal(1000);
            System.out.println("用户B取款1000元");
            System.out.println("此时账户还有"+account.getBalance()+"元");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

              image.gif

              public class BankDemo {
    public static void main(String[] args) {
        //初始账户余额3000块
        Account account=new Account(3000);
        PersonA personA=new PersonA(account);
        PersonB personB=new PersonB(account);
        //启动线程
        personA.start();
        personB.start();
    }
}

              image.gif

              线程同步问题

                • 产生数据不一致的原因：多个线程并发访问了同一个对象，如果破坏了不可分割的操作，从而就会造成数据不一致
                • 被多线程并发访问时如果一个对象有可能出现数据不一致的问题,那么这个对象称为线程不安全的对象

                如何解决多线程并发访问的问题

                利用synchronized 同步锁

                synchronized(Object o){
      代码块
    }

                image.gif

                public class Account {
    //银行账户余额
    private int balance;
    private Object o=new Object();
    public Account(int balance) {
        this.balance = balance;
    }
    //存款方法
    public void deposit(int money){
        synchronized (o){
            balance=balance+money;
        }
    }
    //取款方法
    public void withdrawal(int money){
        synchronized (o){
            if(money>balance){
                System.out.println("余额不足");
            }else{
                balance=balance-money;
            } 
        }
    }
    public int getBalance() {
        return balance;
    }
}

                image.gif

                死锁和解决办法

                什么是死锁

                死锁是因为多线程访问共享资源，由于访问的顺序不当所造成的，通常是一个线程锁定了一个资源A，而又想去锁定资源B；在另一个线程中，锁定了资源B，而又想去锁定资源A以完成自身的操作，两个线程都想得到对方的资源，而不愿释放自己的资源，造成两个线程都在等待，而无法执行的情况。

                public class MyThread1 extends Thread{
    //资源a
    private Object a;
    //资源b;
    private Object b;
    public MyThread1(Object a,Object b){
        this.a=a;
        this.b=b;
    }
    public void run(){
        //当前线程名称
        String name = Thread.currentThread().getName();
        System.out.println(name+"获取资源a");
        synchronized (a){
            System.out.println(name+"获取资源b");
            await();
            synchronized (b){
                System.out.println(name+"释放资源b");
                await();
            }
            System.out.println(name+"释放资源a");
        }
    }
    private void await() {
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

                image.gif

                public class MyThread2 extends Thread{
    //资源a
    private Object a;
    //资源b;
    private Object b;
    public MyThread2(Object a,Object b){
        this.a=a;
        this.b=b;
    }
    public void run(){
        //当前线程名称
        String name = Thread.currentThread().getName();
        System.out.println("获取资源b");
        synchronized (b){
            System.out.println(name+"获取资源b");
            await();
            synchronized (a){
                System.out.println(name+"释放资源a");
                await();
            }
            System.out.println(name+"释放资源b");
        }
    }
    private void await() {
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

                image.gif

                public class ThreadTest {
    public static void main(String[] args) {
        Object a=new Object();
        Object b=new Object();
        MyThread1 t1=new MyThread1(a,b);
        MyThread2 t2=new MyThread2(a,b);
        //启动线程
        t1.start();
        t2.start();
    }
}

                image.gif

                解决死锁

                利用wait()方法和notify()方法

                  • wait()：等待，如果线程执行了wait方法，那么该线程会进入等待的状态，等待状态下的线程必须要被其他线程调用notify()方法才能唤醒。
                  • notify()：唤醒，唤醒线程池等待线程其中的一个。
                  • notifyAll()：唤醒线程池所有等待线程。

                  wait与notify方法要注意的事项：

                    1. wait方法与notify方法是属于Object对象的。
                    2. wait方法与notify方法必须要在同步代码块或者是同步函数中才能使用。
                    3. wait方法与notify方法必须要由所对象调用。
                    public class MyThread1 extends Thread{
    //资源a
    private Object a;
    //资源b;
    private Object b;
    public MyThread1(Object a,Object b){
        this.a=a;
        this.b=b;
    }
    public void run(){
        //当前线程名称
        String name = Thread.currentThread().getName();
        System.out.println(name+"获取资源a");
        synchronized (a){
            try {
                a.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(name+"获取资源b");
            await();
            synchronized (b){
                System.out.println(name+"释放资源b");
                await();
            }
            System.out.println(name+"释放资源a");
        }
    }
    private void await() {
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

                    image.gif

                    public class MyThread2 extends Thread{
    //资源a
    private Object a;
    //资源b;
    private Object b;
    public MyThread2(Object a,Object b){
        this.a=a;
        this.b=b;
    }
    public void run(){
        //当前线程名称
        String name = Thread.currentThread().getName();
        System.out.println("获取资源b");
        synchronized (b){
            System.out.println(name+"获取资源b");
            await();
            synchronized (a){
                System.out.println(name+"释放资源a");
                a.notify();
                await();
            }
            System.out.println(name+"释放资源b");
        }
    }
    private void await() {
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

                    image.gif

                    public class ThreadTest {
    public static void main(String[] args) {
        Object a=new Object();
        Object b=new Object();
        MyThread1 t1=new MyThread1(a,b);
        MyThread2 t2=new MyThread2(a,b);
        //启动线程
        t1.start();
        t2.start();
    }
}

                    image.gif


                    文章标签：
                    Java
                    API
                    关键词：
                    Java线程
                    Java多线程
                    Java入门
                    java基础线程
                    Java基础入门
                    洛阳泰山
                    目录
                    相关文章
                    蓝易云
                    |
                    2天前
                    |
                    安全 Java API
                    java如何请求接口然后终止某个线程
                    通过本文的介绍，您应该能够理解如何在Java中请求接口并根据返回结果终止某个线程。合理使用标志位或 `interrupt`方法可以确保线程的安全终止，而处理好网络请求中的各种异常情况，可以提高程序的稳定性和可靠性。
                    蓝易云
                    24 6
                    游客762btuqu5wybw666
                    |
                    15天前
                    |
                    存储 监控 小程序
                    Java中的线程池优化实践####
                    本文深入探讨了Java中线程池的工作原理，分析了常见的线程池类型及其适用场景，并通过实际案例展示了如何根据应用需求进行线程池的优化配置。文章首先介绍了线程池的基本概念和核心参数，随后详细阐述了几种常见的线程池实现（如FixedThreadPool、CachedThreadPool、ScheduledThreadPool等）的特点及使用场景。接着，通过一个电商系统订单处理的实际案例，分析了线程池参数设置不当导致的性能问题，并提出了相应的优化策略。最终，总结了线程池优化的最佳实践，旨在帮助开发者更好地利用Java线程池提升应用性能和稳定性。 ####
                    游客762btuqu5wybw666
                    42 13
                    游客7ofzsdfcat7ls
                    |
                    11天前
                    |
                    监控 架构师 Java
                    Java虚拟机调优的艺术：从入门到精通####
                    本文作为一篇深入浅出的技术指南，旨在为Java开发者揭示JVM调优的神秘面纱，通过剖析其背后的原理、分享实战经验与最佳实践，引领读者踏上从调优新手到高手的进阶之路。不同于传统的摘要概述，本文将以一场虚拟的对话形式，模拟一位经验丰富的架构师向初学者传授JVM调优的心法，激发学习兴趣，同时概括性地介绍文章将探讨的核心议题——性能监控、垃圾回收优化、内存管理及常见问题解决策略。 ####
                    游客7ofzsdfcat7ls
                    30 7
                    游客nmbcre4jd7shs
                    |
                    10天前
                    |
                    安全 算法 Java
                    Java多线程编程中的陷阱与最佳实践####
                    本文探讨了Java多线程编程中常见的陷阱，并介绍了如何通过最佳实践来避免这些问题。我们将从基础概念入手，逐步深入到具体的代码示例，帮助开发者更好地理解和应用多线程技术。无论是初学者还是有经验的开发者，都能从中获得有价值的见解和建议。 ####
                    游客nmbcre4jd7shs
                    27 4
                    mg的嘟嘟
                    |
                    10天前
                    |
                    Java 调度
                    Java中的多线程编程与并发控制
                    本文深入探讨了Java编程语言中多线程编程的基础知识和并发控制机制。文章首先介绍了多线程的基本概念，包括线程的定义、生命周期以及在Java中创建和管理线程的方法。接着，详细讲解了Java提供的同步机制，如synchronized关键字、wait()和notify()方法等，以及如何通过这些机制实现线程间的协调与通信。最后，本文还讨论了一些常见的并发问题，例如死锁、竞态条件等，并提供了相应的解决策略。
                    mg的嘟嘟
                    30 3
                    游客7v53mftipku2u
                    |
                    12天前
                    |
                    监控 Java 开发者
                    深入理解Java中的线程池实现原理及其性能优化####
                    本文旨在揭示Java中线程池的核心工作机制，通过剖析其背后的设计思想与实现细节，为读者提供一份详尽的线程池性能优化指南。不同于传统的技术教程，本文将采用一种互动式探索的方式，带领大家从理论到实践，逐步揭开线程池高效管理线程资源的奥秘。无论你是Java并发编程的初学者，还是寻求性能调优技巧的资深开发者，都能在本文中找到有价值的内容。 ####
                    游客7v53mftipku2u
                    27 1
                    最好zzz
                    |
                    15天前
                    |
                    监控 Java 数据库连接
                    Java线程管理：守护线程与用户线程的区分与应用
                    在Java多线程编程中，线程可以分为守护线程（Daemon Thread）和用户线程（User Thread）。这两种线程在行为和用途上有着明显的区别，了解它们的差异对于编写高效、稳定的并发程序至关重要。
                    最好zzz
                    24 2
                    潇洒洒
                    |
                    15天前
                    |
                    监控 Java 开发者
                    Java线程管理：守护线程与本地线程的深入剖析
                    在Java编程语言中，线程是程序执行的最小单元，它们可以并行执行以提高程序的效率和响应性。Java提供了两种特殊的线程类型：守护线程和本地线程。本文将深入探讨这两种线程的区别，并探讨它们在实际开发中的应用。
                    潇洒洒
                    21 1
                    石小浪♪
                    |
                    2月前
                    |
                    存储 消息中间件 资源调度
                    C++ 多线程之初识多线程
                    这篇文章介绍了C++多线程的基本概念，包括进程和线程的定义、并发的实现方式，以及如何在C++中创建和管理线程，包括使用`std::thread`库、线程的join和detach方法，并通过示例代码展示了如何创建和使用多线程。
                    石小浪♪
                    52 1
                    C++ 多线程之初识多线程
                    龙大吉
                    |
                    2月前
                    |
                    Java 开发者
                    在Java多线程编程中，创建线程的方法有两种：继承Thread类和实现Runnable接口
                    【10月更文挑战第20天】在Java多线程编程中，创建线程的方法有两种：继承Thread类和实现Runnable接口。本文揭示了这两种方式的微妙差异和潜在陷阱，帮助你更好地理解和选择适合项目需求的线程创建方式。
                    龙大吉
                    26 3

                    热门文章

                    最新文章

                  1. 1
                    WPF 线程:使用调度程序构建反应速度更快的应用程序
                  2. 2
                    线程状态&&Wait和sleep的区别？
                  3. 3
                    ConcurrentDictionary线程不安全么
                  4. 4
                    threading多线程总结
                  5. 5
                    线程的优先级
                  6. 6
                    java中线程存活和线程执行的问题！
                  7. 7
                    明述java中线程(thread)的使用(1)
                  8. 8
                    object-c 多线程 加锁
                  9. 9
                    线程基础知识系列(二）线程的管理
                  10. 10
                    Semaphore维护当前访问自身的线程个数
                  11. 1
                    MaxCompute产品使用合集之使用Tunnel Java SDK上传BINARY数据类型时，应该使用什么作为数据类字节
                    41
                  12. 2
                    Java无模版导出Excel 0基础教程
                    110
                  13. 3
                    Java 将Markdown文件转换为Word和PDF文档
                    324
                  14. 4
                    深入理解Java中的Lambda表达式
                    47
                  15. 5
                    Java进阶之内部类
                    43
                  16. 6
                    压测分析Java内存和CPU暂用
                    73
                  17. 7
                    day18：Java零基础 - 包装类
                    43
                  18. 8
                    java 如何实现监听mysql的binlog文件
                    452
                  19. 9
                    java中本地路径写成接口传输到前端
                    53
                  20. 10
                    java编程语言常用框架有哪些？
                    83

                    21. 相关课程

                    更多
                  21. Java面试疑难点解析 - 面试技巧及语言基础
                  22. Java面试疑难点解析 - Java Web开发
                  23. Java面试疑难点解析 - 系统架构及项目设计
                  24. Java编程入门
                  25. Java面向对象编程
                  26. Java高级编程

                    27. 相关电子书

                    更多
                  27. Spring Cloud Alibaba - 重新定义 Java Cloud-Native
                  28. The Reactive Cloud Native Arch
                  29. JAVA开发手册1.5.0

                    30. 相关实验场景

                    更多
                  30. 阿里云平台上进行Java程序的编译与运行
                  31. 使用Java面向对象编写网络通信程序应用
                  32. Arthas 进阶教程
                  33. 手动部署Java Web环境（Alibaba Cloud Linux 2）
                  34. 搭建Java Web开发环境（Anolis OS）
                  35. RocketMQ中使用Java客户端发送消息和消费的应用
                    36. 下一篇
                    阿里云对象存储OSS收费标准：存储、流量和请求等多个计费项详解