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

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

2023-01-13 64
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 目录线程的概念线程的使用线程的状态线程同步问题死锁和解决办法线程的概念什么是线程在一个程序中同时运行的多个独立流程，每一个独立的流程就是一个线程线程并发多个线程并发执行主线程 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基础线程
                    洛阳泰山
                    目录
                    相关文章
                    游客sjjs6jgz4gp7m1
                    |
                    5天前
                    |
                    缓存 Java 开发者
                    Java多线程编程的陷阱与最佳实践####
                    本文深入探讨了Java多线程编程中常见的陷阱，如竞态条件、死锁和内存一致性错误，并提供了实用的避免策略。通过分析典型错误案例，本文旨在帮助开发者更好地理解和掌握多线程环境下的编程技巧，从而提升并发程序的稳定性和性能。 ####
                    游客sjjs6jgz4gp7m1
                    31 11
                    java的细水长流
                    |
                    4天前
                    |
                    缓存 Java 开发者
                    Java多线程并发编程：同步机制与实践应用
                    本文深入探讨Java多线程中的同步机制，分析了多线程并发带来的数据不一致等问题，详细介绍了`synchronized`关键字、`ReentrantLock`显式锁及`ReentrantReadWriteLock`读写锁的应用，结合代码示例展示了如何有效解决竞态条件，提升程序性能与稳定性。
                    java的细水长流
                    30 5
                    muxiaoxi
                    |
                    4天前
                    |
                    安全 Java 开发者
                    Java中的多线程编程：从基础到实践
                    本文深入探讨了Java多线程编程的核心概念和实践技巧，旨在帮助读者理解多线程的工作原理，掌握线程的创建、管理和同步机制。通过具体示例和最佳实践，本文展示了如何在Java应用中有效地利用多线程技术，提高程序性能和响应速度。
                    muxiaoxi
                    27 1
                    java的细水长流
                    |
                    12天前
                    |
                    安全 Java 开发者
                    Java 多线程并发控制：深入理解与实战应用
                    《Java多线程并发控制：深入理解与实战应用》一书详细解析了Java多线程编程的核心概念、并发控制技术及其实战技巧，适合Java开发者深入学习和实践参考。
                    java的细水长流
                    38 6
                    游客5fdji2pvmf8888
                    |
                    13天前
                    |
                    Java 开发者
                    Java多线程编程的艺术与实践####
                    本文深入探讨了Java多线程编程的核心概念、应用场景及实践技巧。不同于传统的技术文档，本文以实战为导向，通过生动的实例和详尽的代码解析，引领读者领略多线程编程的魅力，掌握其在提升应用性能、优化资源利用方面的关键作用。无论你是Java初学者还是有一定经验的开发者，本文都将为你打开多线程编程的新视角。 ####
                    游客5fdji2pvmf8888
                    33 6
                    游客762btuqu5wybw666
                    |
                    12天前
                    |
                    存储 安全 Java
                    Java多线程编程中的并发容器：深入解析与实战应用####
                    在本文中，我们将探讨Java多线程编程中的一个核心话题——并发容器。不同于传统单一线程环境下的数据结构，并发容器专为多线程场景设计，确保数据访问的线程安全性和高效性。我们将从基础概念出发，逐步深入到`java.util.concurrent`包下的核心并发容器实现，如`ConcurrentHashMap`、`CopyOnWriteArrayList`以及`BlockingQueue`等，通过实例代码演示其使用方法，并分析它们背后的设计原理与适用场景。无论你是Java并发编程的初学者还是希望深化理解的开发者，本文都将为你提供有价值的见解与实践指导。 --- ####
                    游客762btuqu5wybw666
                    26 3
                    叫个什么名字
                    |
                    14天前
                    |
                    Java 开发者
                    Java多线程编程中的常见误区与最佳实践####
                    本文深入剖析了Java多线程编程中开发者常遇到的几个典型误区，如对`start()`与`run()`方法的混淆使用、忽视线程安全问题、错误处理未同步的共享变量等，并针对这些问题提出了具体的解决方案和最佳实践。通过实例代码对比，直观展示了正确与错误的实现方式，旨在帮助读者构建更加健壮、高效的多线程应用程序。 ####
                    叫个什么名字
                    36 5
                    运营研究坊
                    |
                    21天前
                    |
                    安全 Java 测试技术
                    Java并行流陷阱：为什么指定线程池可能是个坏主意
                    本文探讨了Java并行流的使用陷阱，尤其是指定线程池的问题。文章分析了并行流的设计思想，指出了指定线程池的弊端，并提供了使用CompletableFuture等替代方案。同时，介绍了Parallel Collector库在处理阻塞任务时的优势和特点。
                    运营研究坊
                    59 2
                    众所周知
                    |
                    18天前
                    |
                    安全 Java 开发者
                    深入解读JAVA多线程：wait()、notify()、notifyAll()的奥秘
                    在Java多线程编程中，`wait()`、`notify()`和`notifyAll()`方法是实现线程间通信和同步的关键机制。这些方法定义在`java.lang.Object`类中，每个Java对象都可以作为线程间通信的媒介。本文将详细解析这三个方法的使用方法和最佳实践，帮助开发者更高效地进行多线程编程。 示例代码展示了如何在同步方法中使用这些方法，确保线程安全和高效的通信。
                    众所周知
                    44 9
                    叫个什么名字
                    |
                    15天前
                    |
                    安全 Java 开发者
                    Java多线程编程中的常见问题与解决方案
                    本文深入探讨了Java多线程编程中常见的问题，包括线程安全问题、死锁、竞态条件等，并提供了相应的解决策略。文章首先介绍了多线程的基础知识，随后详细分析了每个问题的产生原因和典型场景，最后提出了实用的解决方案，旨在帮助开发者提高多线程程序的稳定性和性能。
                    叫个什么名字
                    53 1

                    热门文章

                    最新文章

                  1. 1
                    线程状态&&Wait和sleep的区别？
                  2. 2
                    ConcurrentDictionary线程不安全么
                  3. 3
                    WPF 线程:使用调度程序构建反应速度更快的应用程序
                  4. 4
                    java中线程存活和线程执行的问题！
                  5. 5
                    【C/C++ 单线程性能分析工具 Gprof】 GNU的C/C++ 性能分析工具 Gprof 使用全面指南
                  6. 6
                    线程的优先级
                  7. 7
                    明述java中线程(thread)的使用(1)
                  8. 8
                    Java多线程的~~~synchronized加入参数，以实现独立片段
                  9. 9
                    Semaphore维护当前访问自身的线程个数
                  10. 10
                    过程 线 多线程 并发 同步异步
                  11. 1
                    面试官：素有Java锁王称号的‘StampedLock’你知道吗？我：这什么鬼？
                    99
                  12. 2
                    Java的取余如何编写代码
                    75
                  13. 3
                    Java获取字符串最后一位
                    568
                  14. 4
                    Java一分钟之-Lambda表达式与函数式接口
                    74
                  15. 5
                    Java一分钟之-Java内部类与匿名类
                    46
                  16. 6
                    Java一分钟之-Java注解的理解与应用
                    46
                  17. 7
                    Java一分钟之-Java反射机制：动态操作类与对象
                    77
                  18. 8
                    Java一分钟之线程池：ExecutorService与Future
                    140
                  19. 9
                    深入理解Java并发编程：线程安全与性能优化
                    46
                  20. 10
                    Java中Lambda表达式的深入理解与应用
                    47

                    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. 下一篇
                    阿里云无影云电脑免费试用，最长可试用3个月