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

Java线程

2023-02-06 118
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 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线程
跟我一起秃秃秃
目录
相关文章
叫个什么名字
|
6天前
|
Java 开发者
Java多线程编程中的常见误区与最佳实践####
本文深入剖析了Java多线程编程中开发者常遇到的几个典型误区，如对`start()`与`run()`方法的混淆使用、忽视线程安全问题、错误处理未同步的共享变量等，并针对这些问题提出了具体的解决方案和最佳实践。通过实例代码对比，直观展示了正确与错误的实现方式，旨在帮助读者构建更加健壮、高效的多线程应用程序。 ####
叫个什么名字
20 5
运营研究坊
|
13天前
|
安全 Java 测试技术
Java并行流陷阱：为什么指定线程池可能是个坏主意
本文探讨了Java并行流的使用陷阱，尤其是指定线程池的问题。文章分析了并行流的设计思想，指出了指定线程池的弊端，并提供了使用CompletableFuture等替代方案。同时，介绍了Parallel Collector库在处理阻塞任务时的优势和特点。
运营研究坊
47 2
java的细水长流
|
4天前
|
安全 Java 开发者
Java 多线程并发控制：深入理解与实战应用
《Java多线程并发控制：深入理解与实战应用》一书详细解析了Java多线程编程的核心概念、并发控制技术及其实战技巧，适合Java开发者深入学习和实践参考。
java的细水长流
22 6
游客5fdji2pvmf8888
|
5天前
|
Java 开发者
Java多线程编程的艺术与实践####
本文深入探讨了Java多线程编程的核心概念、应用场景及实践技巧。不同于传统的技术文档，本文以实战为导向，通过生动的实例和详尽的代码解析，引领读者领略多线程编程的魅力，掌握其在提升应用性能、优化资源利用方面的关键作用。无论你是Java初学者还是有一定经验的开发者，本文都将为你打开多线程编程的新视角。 ####
游客5fdji2pvmf8888
22 6
运营研究坊
|
22天前
|
安全 Java
java 中 i++ 到底是否线程安全？
本文通过实例探讨了 `i++` 在多线程环境下的线程安全性问题。首先，使用 100 个线程分别执行 10000 次 `i++` 操作，发现最终结果小于预期的 1000000，证明 `i++` 是线程不安全的。接着，介绍了两种解决方法：使用 `synchronized` 关键字加锁和使用 `AtomicInteger` 类。其中，`AtomicInteger` 通过 `CAS` 操作实现了高效的线程安全。最后，通过分析字节码和源码，解释了 `i++` 为何线程不安全以及 `AtomicInteger` 如何保证线程安全。
运营研究坊
47 2
java 中 i++ 到底是否线程安全？
游客762btuqu5wybw666
|
4天前
|
存储 安全 Java
Java多线程编程中的并发容器：深入解析与实战应用####
在本文中，我们将探讨Java多线程编程中的一个核心话题——并发容器。不同于传统单一线程环境下的数据结构，并发容器专为多线程场景设计，确保数据访问的线程安全性和高效性。我们将从基础概念出发，逐步深入到`java.util.concurrent`包下的核心并发容器实现，如`ConcurrentHashMap`、`CopyOnWriteArrayList`以及`BlockingQueue`等，通过实例代码演示其使用方法，并分析它们背后的设计原理与适用场景。无论你是Java并发编程的初学者还是希望深化理解的开发者，本文都将为你提供有价值的见解与实践指导。 --- ####
游客762btuqu5wybw666
11 3
众所周知
|
9天前
|
安全 Java 开发者
深入解读JAVA多线程：wait()、notify()、notifyAll()的奥秘
在Java多线程编程中，`wait()`、`notify()`和`notifyAll()`方法是实现线程间通信和同步的关键机制。这些方法定义在`java.lang.Object`类中，每个Java对象都可以作为线程间通信的媒介。本文将详细解析这三个方法的使用方法和最佳实践，帮助开发者更高效地进行多线程编程。 示例代码展示了如何在同步方法中使用这些方法，确保线程安全和高效的通信。
众所周知
33 9
叫个什么名字
|
7天前
|
安全 Java 开发者
Java多线程编程中的常见问题与解决方案
本文深入探讨了Java多线程编程中常见的问题，包括线程安全问题、死锁、竞态条件等，并提供了相应的解决策略。文章首先介绍了多线程的基础知识，随后详细分析了每个问题的产生原因和典型场景，最后提出了实用的解决方案，旨在帮助开发者提高多线程程序的稳定性和性能。
叫个什么名字
29 1
叫个什么名字
|
12天前
|
存储 安全 Java
Java多线程编程的艺术：从基础到实践####
本文深入探讨了Java多线程编程的核心概念、应用场景及其实现方式，旨在帮助开发者理解并掌握多线程编程的基本技能。文章首先概述了多线程的重要性和常见挑战，随后详细介绍了Java中创建和管理线程的两种主要方式：继承Thread类与实现Runnable接口。通过实例代码，本文展示了如何正确启动、运行及同步线程，以及如何处理线程间的通信与协作问题。最后，文章总结了多线程编程的最佳实践，为读者在实际项目中应用多线程技术提供了宝贵的参考。 ####
叫个什么名字
50 5
ShaFaChuang-36210
|
9天前
|
监控 安全 Java
Java中的多线程编程：从入门到实践####
本文将深入浅出地探讨Java多线程编程的核心概念、应用场景及实践技巧。不同于传统的摘要形式，本文将以一个简短的代码示例作为开篇，直接展示多线程的魅力，随后再详细解析其背后的原理与实现方式，旨在帮助读者快速理解并掌握Java多线程编程的基本技能。 ```java // 简单的多线程示例：创建两个线程，分别打印不同的消息 public class SimpleMultithreading { public static void main(String[] args) { Thread thread1 = new Thread(() -> System.out.prin
ShaFaChuang-36210
26 1

热门文章

最新文章

  • 1
    【Java】留下没有基础眼泪的面试题
  • 2
    Java -- JDBC 学习--通过 ResultSet 执行查询操作
  • 3
    How to programmatically new a java class which implements sepecified interface in eclipse plugin development
  • 4
    java安全编码规范
  • 5
    从 Java 开始进入 Kotlin的世界： From Java to Kotlin: JKotlinor
  • 6
    关于安装多个版本jdk之后java -version不正确的问题
  • 7
    Elasticsearch Java API(九)--删除文档的field以及field的属性
  • 8
    Java基础之004-面向对象
  • 9
    [Java][Android][Process] 暴力的服务能够解决一切，暴力的方式运行命令行语句
  • 10
    java-subString方法易导致内存溢出
  • 1
    java接口防爬虫
    132
  • 2
    day14：Java零基础-条件运算符
    43
  • 3
    Java并发编程中的锁机制与性能优化
    53
  • 4
    深入理解Java虚拟机：垃圾收集机制的演变与最佳实践
    53
  • 5
    《手把手教你》系列基础篇（九十五）-java+ selenium自动化测试-框架之设计篇-java实现自定义日志输出（详解教程）
    297
  • 6
    Java并发编程之线程池深度解析
    65
  • 7
    Java中的并发编程：从基础到高级
    68
  • 8
    Java并发编程中的线程安全性与性能优化
    57
  • 9
    《手把手教你》系列基础篇（九十四）-java+ selenium自动化测试-框架设计基础-POM设计模式实现-下篇（详解教程）
    50
  • 10
    Spring Boot框架在java领域的优势
    78

    • 相关课程

    更多
  • 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运行环境
    • 下一篇
    手把手教你白嫖阿里云服务器(免费领服务器)