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

Java线程

2023-02-06 124
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Java线程

Java线程

进程（process）：正在进行的一个过程或者说一个任务。而负责执行任务则是cpu。

所谓的进程就是运行的程序，而这个程序是否能够运行，是看这个程序是否能抢占到cpu内核的执行权。（类似于抢椅子，这也是为什么我们启动程序时通常会加载一会儿）

  • 我们自己写的一个程序就是一个进程。
  • 进程的名字就是执行的类的名字。

线程：一个进程中可以包含多个线程（至少有一条）。

  • Java程序在运行时，默认会产生一个进程。
  • 这个进程会有一条主线程。
  • 代码都在主线程中执行。
public class chapter09 {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName());// main
    }
}

创建线程

使用Thread类来创建线程，我们可以自己声明一个类来继承Thread。然后重写run方法，在使用start来启动线程时会调用这个方法。

public class chapter09 {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        System.out.println(Thread.currentThread().getName());
//        main
//        MyThread：Thread-0
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("MyThread：" + Thread.currentThread().getName());
    }
}

为什么main的打印比MyThread的打印早？因为main是主线程。另外，新建的线程的打印顺序是不一定的。

线程的生命周期

image-20230113183533033

线程对象必须为可运行状态才能运行，其他状态无法运行。

线程执行方式

默认情况下多线程并发执行。

并发执行：多个线程是独立的，谁先抢到cpu的执行权，谁先执行。

package chapter09;

public class Demo_02 {
    public static void main(String[] args) {
        MyThread1 myThread1 = new MyThread1();
        MyThread2 myThread2 = new MyThread2();
        myThread1.start();
        myThread2.start();
        System.out.println(Thread.currentThread().getName());
//        main
//        MyThread1：Thread-0 或者 MyThread2：Thread-1
//        MyThread2：Thread-1 或者 MyThread1：Thread-0
    }
}

class MyThread1 extends Thread {
    @Override
    public void run() {
        System.out.println("MyThread1：" + Thread.currentThread().getName());
    }
}

class MyThread2 extends Thread {
    @Override
    public void run() {
        System.out.println("MyThread2：" + Thread.currentThread().getName());
    }
}

为了让线程按照我们想要的顺序执行，我们可以使程序串行执行。

串行执行：多个线程连成串，按照顺序依次执行。

package chapter09;

public class Demo_02 {
    public static void main(String[] args) throws InterruptedException {
        MyThread1 myThread1 = new MyThread1();
        MyThread2 myThread2 = new MyThread2();

        myThread1.start();
        myThread1.join();

        myThread2.start();
        myThread2.join();
        System.out.println(Thread.currentThread().getName());
//        MyThread1：Thread-0
//        MyThread2：Thread-1
//        main
    }
}

class MyThread1 extends Thread {
    @Override
    public void run() {
        System.out.println("MyThread1：" + Thread.currentThread().getName());
    }
}

class MyThread2 extends Thread {
    @Override
    public void run() {
        System.out.println("MyThread2：" + Thread.currentThread().getName());
    }
}

线程休眠

可以使用Treads.sleep()方法进行休眠，执行时会对调用这个静态方法的线程进行指定时间的休眠

public static void main(String[] args) throws InterruptedException {
    Thread.sleep(3000);
    System.out.println("休眠三秒后得到打印");// 休眠三秒后得到打印
}

我们可以使用它来进行间歇性的循环打印：

public static void main(String[] args) throws InterruptedException {
    while (true) {
        Thread.sleep(1000);
        System.out.println("每休眠一秒打印一次");// 每休眠一秒打印一次
    }
}

构建线程对象

在上面的例子中，我们声明了一个类，但我们不需要创建这个类，我们可以使用lambda表达式来传逻辑：

Thread thread1 = new Thread(() -> {
    System.out.println("thread1执行");
});
thread1.start();

Thread thread2 = new Thread(() -> {
    System.out.println("thread2执行");
});
thread2.start();

System.out.println("主线程执行完毕");

也可以传递实现了Runnable接口的类的对象，一般使用匿名类

Thread thread1 = new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("thread1执行");
    }
});
thread1.start();

Thread thread2 = new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("thread2执行");
    }
});
thread2.start();

System.out.println("主线程执行完毕");

线程池

为了简化线程对象的创建过程，以及合理使用和分配资源，Java提供了一种特殊的处理方式来获取线程对象，这种处理方式叫线程池。

image-20230113215624517

当一个线程由不可运行状态变为可运行状态，新的submit就提交到这个线程上。

创建固定数的线程数量

创建3个线程，对这3个线程进行反复利用

ExecutorService executorService = Executors.newFixedThreadPool(3);
for (int i = 0; i < 5; i++) {
    executorService.submit(() -> System.out.println(Thread.currentThread().getName()));
}
// pool-1-thread-2
// pool-1-thread-1
// pool-1-thread-3
// pool-1-thread-1
// pool-1-thread-2

根据需求自动创建线程

可以根据任务的使用情况重复使用线程，但是发现我们的线程不够，就会创建新的线程

ExecutorService executorService = Executors.newCachedThreadPool();
for (int i = 0; i < 20; i++) {
    executorService.submit(() -> System.out.println(Thread.currentThread().getName()));
}

单一线程

都使用同一个线程。当我们想要某些工作按照某个顺序执行时，我们就可以使用单一线程。

ExecutorService executorService = Executors.newSingleThreadExecutor();
for (int i = 0; i < 3; i++) {
    executorService.submit(() -> System.out.println(Thread.currentThread().getName()));
}
// pool-1-thread-1
// pool-1-thread-1
// pool-1-thread-1

定时调度线程

与创建固定数的线程数量类似，但是这个方法有定时调度的功能，可以定义某个线程在什么时候执行。

ExecutorService executorService = Executors.newScheduledThreadPool(3);
for (int i = 0; i < 5; i++) {
    executorService.submit(() -> System.out.println(Thread.currentThread().getName()));
}

同步

在Java中使用synchronized关键字来表示这是一个同步方法。这个关键字表示在多线程下调用这个方法，只会在一个线程下进行调用。

image-20230113225154245

public class Demo_06 {
    public static void main(String[] args) {
        Num num = new Num(1);
        User user = new User(num);
        user.start();

        Bank bank = new Bank(num);
        bank.start();
        // 我是号码1银行还没开门，我等会儿
        // 开门了，开始叫号
        // 叫到我了！
    }
}

class Num {
    public int number;

    Num(int number) {
        this.number = number;
    }
}

class Bank extends Thread {
    private Num num;

    public Bank(Num num) {
        this.num = num;
    }

    @Override
    public void run() {
        synchronized (num) {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("开门了，开始叫号");
            num.notifyAll();
        }
    }
}

class User extends Thread {
    private Num num;

    public User(Num num) {
        this.num = num;
    }

    @Override
    public void run() {
        synchronized (num) {
            System.out.println("我是号码" + num.number + "银行还没开门，我等会儿");
            try {
                num.wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            System.out.println("叫到我了！");
        }
    }
}

wait和sleep

虽然wait和sleep都用于阻塞程序，但它们有很多不同：

  • 关于名字：wait（等待），sleep（睡眠）
  • 从属关系：wait（Object类的成员方法），sleep（Thread类的静态方法）
  • 使用方式：wait（只能用于同步代码中），sleep（任何地方）
  • 阻塞时间：wait：超时时间，等到一定时间不会再等（会发生错误），sleep：休眠时间（不会发生错误）
  • 同步处理：wait：如果使用wait方法，其他线程有机会执行当前的同步操作（等你做完了，就该我了）。sleep：如果使用sleep方法，其他线程没有机会执行当前的同步操作（就像睡着了，不知道外面发生了什么事，醒过来了继续干）。

线程的安全问题

所谓的线程安全问题，其实就是多个线程在并发执行时，修改了共享内存中共享对象中的属性，导致的数据冲突问题

image-20230113230134562

package chapter09;

public class Demo_07 {
    public static void main(String[] args) {
        User07 user = new User07();

        Thread thread1 = new Thread(() -> {
            user.name = "kevin";
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(user.name);
        });
        Thread thread2 = new Thread(() -> {
            user.name = "qian";
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(user.name);
        });

        thread1.start();
        thread2.start();

        System.out.println("主线程执行完毕");
        // 主线程执行完毕
        // qian
        // qian
    }
}

class User07 {
    public String name;
}

由于thread1中修改user.name后休眠了，然后在thread1醒来前thread2也修改了同一个user对象的name，所以它们打印同一个name

文章标签：
Java
调度
关键词：
Java线程
跟我一起秃秃秃
目录
相关文章
蓝易云
|
15天前
|
监控 Java
java异步判断线程池所有任务是否执行完
通过上述步骤，您可以在Java中实现异步判断线程池所有任务是否执行完毕。这种方法使用了 `CompletionService`来监控任务的完成情况，并通过一个独立线程异步检查所有任务的执行状态。这种设计不仅简洁高效，还能确保在大量任务处理时程序的稳定性和可维护性。希望本文能为您的开发工作提供实用的指导和帮助。
蓝易云
71 17
大数据文摘
|
26天前
|
Java
Java—多线程实现生产消费者
本文介绍了多线程实现生产消费者模式的三个版本。Version1包含四个类：`Producer`（生产者）、`Consumer`（消费者）、`Resource`（公共资源）和`TestMain`（测试类）。通过`synchronized`和`wait/notify`机制控制线程同步，但存在多个生产者或消费者时可能出现多次生产和消费的问题。 Version2将`if`改为`while`，解决了多次生产和消费的问题，但仍可能因`notify()`随机唤醒线程而导致死锁。因此，引入了`notifyAll()`来唤醒所有等待线程，但这会带来性能问题。
大数据文摘
68 1
Java—多线程实现生产消费者
游客r2tgrg3ez7yzc
|
11天前
|
缓存 安全 算法
Java 多线程 面试题
Java 多线程 相关基础面试题
游客r2tgrg3ez7yzc
30 2
2G冲浪词条
|
28天前
|
安全 Java Kotlin
Java多线程——synchronized、volatile 保障可见性
Java多线程中，`synchronized` 和 `volatile` 关键字用于保障可见性。`synchronized` 保证原子性、可见性和有序性，通过锁机制确保线程安全；`volatile` 仅保证可见性和有序性，不保证原子性。代码示例展示了如何使用 `synchronized` 和 `volatile` 解决主线程无法感知子线程修改共享变量的问题。总结：`volatile` 确保不同线程对共享变量操作的可见性，使一个线程修改后，其他线程能立即看到最新值。
2G冲浪词条
38 7
大数据文摘
|
28天前
|
消息中间件 缓存 安全
Java多线程是什么
Java多线程简介：本文介绍了Java中常见的线程池类型，包括`newCachedThreadPool`（适用于短期异步任务）、`newFixedThreadPool`（适用于固定数量的长期任务）、`newScheduledThreadPool`（支持定时和周期性任务）以及`newSingleThreadExecutor`（保证任务顺序执行）。同时，文章还讲解了Java中的锁机制，如`synchronized`关键字、CAS操作及其实现方式，并详细描述了可重入锁`ReentrantLock`和读写锁`ReadWriteLock`的工作原理与应用场景。
大数据文摘
42 7
栈江湖
|
28天前
|
安全 Java 编译器
深入理解Java中synchronized三种使用方式：助您写出线程安全的代码
`synchronized` 是 Java 中的关键字，用于实现线程同步，确保多个线程互斥访问共享资源。它通过内置的监视器锁机制，防止多个线程同时执行被 `synchronized` 修饰的方法或代码块。`synchronized` 可以修饰非静态方法、静态方法和代码块，分别锁定实例对象、类对象或指定的对象。其底层原理基于 JVM 的指令和对象的监视器，JDK 1.6 后引入了偏向锁、轻量级锁等优化措施，提高了性能。
栈江湖
54 3
栈江湖
|
28天前
|
存储 安全 Java
Java多线程编程秘籍：各种方案一网打尽，不要错过！
Java 中实现多线程的方式主要有四种：继承 Thread 类、实现 Runnable 接口、实现 Callable 接口和使用线程池。每种方式各有优缺点，适用于不同的场景。继承 Thread 类最简单，实现 Runnable 接口更灵活，Callable 接口支持返回结果，线程池则便于管理和复用线程。实际应用中可根据需求选择合适的方式。此外，还介绍了多线程相关的常见面试问题及答案，涵盖线程概念、线程安全、线程池等知识点。
栈江湖
154 2
蓝易云
|
1月前
|
安全 Java API
java如何请求接口然后终止某个线程
通过本文的介绍，您应该能够理解如何在Java中请求接口并根据返回结果终止某个线程。合理使用标志位或 `interrupt`方法可以确保线程的安全终止，而处理好网络请求中的各种异常情况，可以提高程序的稳定性和可靠性。
蓝易云
51 6
游客5fdji2pvmf8888
|
2月前
|
设计模式 Java 开发者
Java多线程编程的陷阱与解决方案####
本文深入探讨了Java多线程编程中常见的问题及其解决策略。通过分析竞态条件、死锁、活锁等典型场景，并结合代码示例和实用技巧，帮助开发者有效避免这些陷阱，提升并发程序的稳定性和性能。 ####
游客5fdji2pvmf8888
69 16
游客762btuqu5wybw666
|
1月前
|
存储 监控 小程序
Java中的线程池优化实践####
本文深入探讨了Java中线程池的工作原理，分析了常见的线程池类型及其适用场景，并通过实际案例展示了如何根据应用需求进行线程池的优化配置。文章首先介绍了线程池的基本概念和核心参数，随后详细阐述了几种常见的线程池实现（如FixedThreadPool、CachedThreadPool、ScheduledThreadPool等）的特点及使用场景。接着，通过一个电商系统订单处理的实际案例，分析了线程池参数设置不当导致的性能问题，并提出了相应的优化策略。最终，总结了线程池优化的最佳实践，旨在帮助开发者更好地利用Java线程池提升应用性能和稳定性。 ####
游客762btuqu5wybw666
85 13

热门文章

最新文章

  • 1
    Java volatile关键字：你真的懂了吗？
  • 2
    Java最新图形化界面开发技术——JavaFx教程（含UI控件用法介绍、属性绑定、事件监听、FXML）
  • 3
    java项目中jar启动执行日志报错：no main manifest attribute, in /www/wwwroot/snow-server/z-server.jar-jar打包的大小明显小于正常大小如何解决
  • 4
    springboot java.lang.ClassNotFoundException: dm.jdbc.driver.DmDriver应该如何解决
  • 5
    Java多线程编程秘籍：各种方案一网打尽，不要错过！
  • 6
    【Bug合集】——Java大小写引起传参失败，获取值为null的解决方案
  • 7
    Java中的数据类型
  • 8
    Java中的字符集编码入门－增补字符（转载）
  • 9
    JAVA线程池有哪些队列？ 以及它们的适用场景案例
  • 10
    如何在 Java 代码中使用 JSqlParser 解析复杂的 SQL 语句？
  • 1
    MaxCompute产品使用合集之使用Tunnel Java SDK上传BINARY数据类型时，应该使用什么作为数据类字节
    48
  • 2
    Java无模版导出Excel 0基础教程
    130
  • 3
    Java 将Markdown文件转换为Word和PDF文档
    369
  • 4
    深入理解Java中的Lambda表达式
    52
  • 5
    Java进阶之内部类
    54
  • 6
    压测分析Java内存和CPU暂用
    87
  • 7
    day18：Java零基础 - 包装类
    47
  • 8
    java 如何实现监听mysql的binlog文件
    491
  • 9
    java中本地路径写成接口传输到前端
    61
  • 10
    java编程语言常用框架有哪些？
    100

    • 相关课程

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

    • 相关电子书

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

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
  • 部署基于Dragonwell的Java运行环境
    • 下一篇
    阿里云开通OSS存储服务详细流程