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

Java线程

2023-02-06 105
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 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线程
跟我一起秃秃秃
目录
相关文章
2的n次方_
|
8天前
|
监控 Java 调度
【Java学习】多线程&JUC万字超详解
本文详细介绍了多线程的概念和三种实现方式，还有一些常见的成员方法，CPU的调动方式，多线程的生命周期，还有线程安全问题，锁和死锁的概念，以及等待唤醒机制，阻塞队列，多线程的六种状态，线程池等
2的n次方_
63 6
【Java学习】多线程&JUC万字超详解
游客zllgslqrsw3f6
|
1天前
|
Java 调度 开发者
Java并发编程：深入理解线程池
在Java的世界中，线程池是提升应用性能、实现高效并发处理的关键工具。本文将深入浅出地介绍线程池的核心概念、工作原理以及如何在实际应用中有效利用线程池来优化资源管理和任务调度。通过本文的学习，读者能够掌握线程池的基本使用技巧，并理解其背后的设计哲学。
游客zllgslqrsw3f6
23 13
游客7ofzsdfcat7ls
|
1天前
|
缓存 监控 Java
Java中的并发编程：理解并应用线程池
在Java的并发编程中，线程池是提高应用程序性能的关键工具。本文将深入探讨如何有效利用线程池来管理资源、提升效率和简化代码结构。我们将从基础概念出发，逐步介绍线程池的配置、使用场景以及最佳实践，帮助开发者更好地掌握并发编程的核心技巧。
游客7ofzsdfcat7ls
20 10
八百标兵奔北坡
|
3天前
|
缓存 监控 Java
java中线程池的使用
java中线程池的使用
八百标兵奔北坡
11 7
游客7v53mftipku2u
|
2天前
|
算法 Java 数据处理
Java并发编程：解锁多线程的力量
在Java的世界里，掌握并发编程是提升应用性能和响应能力的关键。本文将深入浅出地探讨如何利用Java的多线程特性来优化程序执行效率，从基础的线程创建到高级的并发工具类使用，带领读者一步步解锁Java并发编程的奥秘。你将学习到如何避免常见的并发陷阱，并实际应用这些知识来解决现实世界的问题。让我们一起开启高效编码的旅程吧！
游客7v53mftipku2u
6 1
智物科技库
|
7天前
|
存储 Java 程序员
优化Java多线程应用：是创建Thread对象直接调用start()方法？还是用个变量调用？
这篇文章探讨了Java中两种创建和启动线程的方法，并分析了它们的区别。作者建议直接调用 `Thread` 对象的 `start()` 方法，而非保持强引用，以避免内存泄漏、简化线程生命周期管理，并减少不必要的线程控制。文章详细解释了这种方法在使用 `ThreadLocal` 时的优势，并提供了代码示例。作者洛小豆，文章来源于稀土掘金。
智物科技库
17 6
shuj
|
4天前
|
Java 开发者
Java中的多线程编程基础与实战
【9月更文挑战第6天】本文将通过深入浅出的方式，带领读者了解并掌握Java中的多线程编程。我们将从基础概念出发，逐步深入到代码实践，最后探讨多线程在实际应用中的优势和注意事项。无论你是初学者还是有一定经验的开发者，这篇文章都能让你对Java多线程有更全面的认识。
shuj
14 1
请看我回答~
|
12天前
|
安全 Java 程序员
Java编程中实现线程安全的策略
【8月更文挑战第31天】在多线程环境下，保证数据一致性和程序的正确运行是每个程序员的挑战。本文将通过浅显易懂的语言和实际代码示例，带你了解并掌握在Java编程中确保线程安全的几种策略。让我们一起探索如何用同步机制、锁和原子变量等工具来保护我们的数据，就像保护自己的眼睛一样重要。
请看我回答~
22 6
请看我回答~
|
12天前
|
安全 Java 开发者
深入浅出Java多线程编程
【8月更文挑战第31天】本文旨在通过浅显易懂的语言和实例，为初学者揭开Java多线程编程的神秘面纱。我们将从基础概念出发，逐步深入到多线程的创建、同步机制及实际应用，帮助读者构建起完整的多线程知识体系。文章不仅包含理论介绍，还提供代码示例，让读者能够动手实践，加深理解。无论你是编程新手还是希望巩固多线程知识的开发者，这篇文章都将是你不可多得的学习资源。
请看我回答~
25 3
请看我回答~
|
11天前
|
Java 调度
Java中的多线程基础与实践
【8月更文挑战第31天】本文将深入浅出地讲解Java中多线程的基础知识，并通过实例展示如何在Java程序中实现多线程。我们将从多线程的基本概念出发，逐步深入到线程的创建、控制以及同步机制，最后通过一个简易版的生产者消费者模型来实践这些知识点。文章旨在帮助初学者快速掌握多线程编程的关键技能，并理解其背后的原理。
请看我回答~
24 2

热门文章

最新文章

  • 1
    java 读取音频/视频 文件时长
  • 2
    Java设计模式(一)----单例模式
  • 3
    Spring框架（SpringBoot）中redis报错（Could not get a resource from the pool、java.net.SocketTimeoutException）
  • 4
    Java中List集合的遍历
  • 5
    java多线程之：Java中的ReentrantLock和synchronized两种锁定机制的对比 （转载）
  • 6
    【java开发系列】—— JDK安装
  • 7
    Eclipse中启动tomcat报错java.lang.OutOfMemoryError: PermGen space的解决方法
  • 8
    java多线程 -- CountDownLatch 闭锁
  • 9
    java- 分布式- 一致性哈希算法（2）
  • 10
    java分层架构概念
  • 1
    18：面向切面编程-Java Spring
    60
  • 2
    17：缓存机制-Java Spring
    80
  • 3
    16：事务-Java Spring
    47
  • 4
    15：MyBatis对象关系与映射结构-Java Spring
    80
  • 5
    Java串口通信：从十六进制字符串到字节数组的正确转换与发送
    196
  • 6
    Java中如何使用Socket类检测端口是否存在
    77
  • 7
    Java串口通信技术探究3：RXTX库线程 优化系统性能的SerialPortEventListener类
    433
  • 8
    Java串口通信技术探究2：RXTX库单例测试及应用
    82
  • 9
    Java串口通信技术探究1：深入理解RXTX库
    160
  • 10
    20：基于EL与JSTL的产品管理页-Java Web
    45

    • 相关课程

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

    • 相关电子书

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

    • 相关实验场景

    更多
  • 基于ECS搭建Java Web开发环境
  • 使用Aliyun Java Intializr进行项目开发
  • 搭建Java Web开发环境
  • 部署基于Dragonwell的Java运行环境
  • 阿里云平台上进行Java程序的编译与运行
    • 下一篇
    对象存储 OSS 如何创建 bucket|学习笔记