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

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

2023-01-13 62
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 目录线程的概念线程的使用线程的状态线程同步问题死锁和解决办法线程的概念什么是线程在一个程序中同时运行的多个独立流程，每一个独立的流程就是一个线程线程并发多个线程并发执行主线程 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基础线程
                    洛阳泰山
                    目录
                    相关文章
                    运营研究坊
                    |
                    1天前
                    |
                    安全 Java 测试技术
                    Java并行流陷阱：为什么指定线程池可能是个坏主意
                    本文探讨了Java并行流的使用陷阱，尤其是指定线程池的问题。文章分析了并行流的设计思想，指出了指定线程池的弊端，并提供了使用CompletableFuture等替代方案。同时，介绍了Parallel Collector库在处理阻塞任务时的优势和特点。
                    运营研究坊
                    13 2
                    萝卜带泥
                    |
                    1天前
                    |
                    安全 Java 编译器
                    Java多线程编程的陷阱与最佳实践####
                    【10月更文挑战第29天】 本文深入探讨了Java多线程编程中的常见陷阱，如竞态条件、死锁、内存一致性错误等，并通过实例分析揭示了这些陷阱的成因。同时，文章也分享了一系列最佳实践，包括使用volatile关键字、原子类、线程安全集合以及并发框架（如java.util.concurrent包下的工具类），帮助开发者有效避免多线程编程中的问题，提升应用的稳定性和性能。 ####
                    萝卜带泥
                    18 1
                    叫个什么名字
                    |
                    5天前
                    |
                    存储 设计模式 分布式计算
                    Java中的多线程编程：并发与并行的深度解析####
                    在当今软件开发领域，多线程编程已成为提升应用性能、响应速度及资源利用率的关键手段之一。本文将深入探讨Java平台上的多线程机制，从基础概念到高级应用，全面解析并发与并行编程的核心理念、实现方式及其在实际项目中的应用策略。不同于常规摘要的简洁概述，本文旨在通过详尽的技术剖析，为读者构建一个系统化的多线程知识框架，辅以生动实例，让抽象概念具体化，复杂问题简单化。 ####
                    叫个什么名字
                    36 4
                    游客gavtnh6pi64i6
                    |
                    3天前
                    |
                    Java 大数据 API
                    14天Java基础学习——第1天：Java入门和环境搭建
                    本文介绍了Java的基础知识，包括Java的简介、历史和应用领域。详细讲解了如何安装JDK并配置环境变量，以及如何使用IntelliJ IDEA创建和运行Java项目。通过示例代码“HelloWorld.java”，展示了从编写到运行的全过程。适合初学者快速入门Java编程。
                    游客gavtnh6pi64i6
                    25 2
                    东方睿赢
                    |
                    6天前
                    |
                    Java 开发者
                    在Java多线程编程的世界里，Lock接口正逐渐成为高手们的首选，取代了传统的synchronized关键字
                    在Java多线程编程的世界里，Lock接口正逐渐成为高手们的首选，取代了传统的synchronized关键字
                    东方睿赢
                    31 4
                    东方睿赢
                    |
                    3月前
                    |
                    存储 监控 Java
                    Java多线程优化：提高线程池性能的技巧与实践
                    Java多线程优化：提高线程池性能的技巧与实践
                    东方睿赢
                    108 1
                    碳基肥宅
                    |
                    6月前
                    |
                    设计模式 监控 Java
                    Java多线程基础-11：工厂模式及代码案例之线程池（一）
                    本文介绍了Java并发框架中的线程池工具，特别是`java.util.concurrent`包中的`Executors`和`ThreadPoolExecutor`类。线程池通过预先创建并管理一组线程，可以提高多线程任务的效率和响应速度，减少线程创建和销毁的开销。
                    碳基肥宅
                    188 2
                    Hacynn
                    |
                    6月前
                    |
                    Java 数据库
                    【Java多线程】对线程池的理解并模拟实现线程池
                    【Java多线程】对线程池的理解并模拟实现线程池
                    Hacynn
                    57 1
                    yinying293
                    |
                    3月前
                    |
                    安全 算法 Java
                    17 Java多线程（线程创建+线程状态+线程安全+死锁+线程池+Lock接口+线程安全集合）（下）
                    17 Java多线程（线程创建+线程状态+线程安全+死锁+线程池+Lock接口+线程安全集合）
                    yinying293
                    75 6
                    yinying293
                    |
                    3月前
                    |
                    存储 安全 Java
                    17 Java多线程（线程创建+线程状态+线程安全+死锁+线程池+Lock接口+线程安全集合）（中）
                    17 Java多线程（线程创建+线程状态+线程安全+死锁+线程池+Lock接口+线程安全集合）
                    yinying293
                    83 5

                    热门文章

                    最新文章

                  1. 1
                    【Java】留下没有基础眼泪的面试题
                  2. 2
                    Java中各种死锁详细讲述及其解决方案（图文并茂，浅显易懂）
                  3. 3
                    简述Java类的“初始化”
                  4. 4
                    Java实现高效的枚举元素集合
                  5. 5
                    通过java api提交自定义hadoop 作业
                  6. 6
                    16.2. jps - Java Virtual Machine Process Status Tool
                  7. 7
                    Java的HashMap遍历方法
                  8. 8
                    JAVA SERVLET 属性范围样例
                  9. 9
                    Java——基于java自身包实现消息系统间的通信（TCP/IP+BIO）
                  10. 10
                    Java 打开文件的两种方式
                  11. 1
                    C#学习系列相关之多线程（五）----线程池ThreadPool用法
                    83
                  12. 2
                    【java进阶】Java中线程的实现方式
                    59
                  13. 3
                    深入理解 Java 多线程、Lambda 表达式及线程安全最佳实践
                    206
                  14. 4
                    【C++】—— C++11之线程库
                    85
                  15. 5
                    C/C++ 线程超详细讲解（系统性学习day10）
                    69
                  16. 6
                    Swing通过后台线程实现页面更新
                    74
                  17. 7
                    Java中的线程安全集合
                    192
                  18. 8
                    浅析Python自带的线程池和进程池
                    444
                  19. 9
                    Python使用多线程解析超大日志文件
                    171
                  20. 10
                    3段代码详解python中的单线程、多线程和多进程
                    100

                    21. 相关课程

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

                    26. 相关电子书

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

                    29. 相关实验场景

                    更多
                  29. 基于ECS搭建Java Web开发环境
                  30. 使用Aliyun Java Intializr进行项目开发
                  31. 搭建Java Web开发环境
                  32. 部署基于Dragonwell的Java运行环境
                  33. 阿里云平台上进行Java程序的编译与运行
                    34. 下一篇
                    无影云桌面