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

Java线程

2023-02-06 168
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 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线程
跟我一起秃秃秃
目录
相关文章
小白学大数据
|
16天前
|
数据采集 存储 弹性计算
高并发Java爬虫的瓶颈分析与动态线程优化方案
高并发Java爬虫的瓶颈分析与动态线程优化方案
小白学大数据
101 1
Java 数据库 Spring
49 0
蓝易云
|
28天前
|
算法 Java
Java多线程编程：实现线程间数据共享机制
以上就是Java中几种主要处理多线程序列化资源以及协调各自独立运行但需相互配合以完成任务threads 的技术手段与策略。正确应用上述技术将大大增强你程序稳定性与效率同时也降低bug出现率因此深刻理解每项技术背后理论至关重要.
蓝易云
64 16
艾伦~耶格尔
|
2月前
|
缓存 并行计算 安全
关于Java多线程详解
本文深入讲解Java多线程编程，涵盖基础概念、线程创建与管理、同步机制、并发工具类、线程池、线程安全集合、实战案例及常见问题解决方案，助你掌握高性能并发编程技巧，应对多线程开发中的挑战。
艾伦~耶格尔
125 0
小白学大数据
|
2月前
|
数据采集 存储 前端开发
Java爬虫性能优化：多线程抓取JSP动态数据实践
Java爬虫性能优化：多线程抓取JSP动态数据实践
小白学大数据
85 0
欲揽西江月
|
3月前
|
Java API 调度
从阻塞到畅通：Java虚拟线程开启并发新纪元
从阻塞到畅通：Java虚拟线程开启并发新纪元
欲揽西江月
303 83
AI小云
|
3月前
|
安全 算法 Java
Java 多线程：线程安全与同步控制的深度解析
本文介绍了 Java 多线程开发的关键技术，涵盖线程的创建与启动、线程安全问题及其解决方案，包括 synchronized 关键字、原子类和线程间通信机制。通过示例代码讲解了多线程编程中的常见问题与优化方法，帮助开发者提升程序性能与稳定性。
AI小云
140 0
欲揽西江月
|
3月前
|
存储 Java 调度
Java虚拟线程：轻量级并发的革命性突破
Java虚拟线程：轻量级并发的革命性突破
欲揽西江月
258 83
程序员小假
|
4月前
|
移动开发 Java
说一说 Java 是如何实现线程间通信
我是小假 期待与你的下一次相遇 ~
程序员小假
64 4

热门文章

最新文章

  • 1
    阿里出手！Java 开发者狂喜！开源 AI Agent 框架 JManus 来了，初次见面就心动～
  • 2
    帮助新手快速上手的 JAVA 学习路线最详细版涵盖从入门到进阶的 JAVA 学习路线
  • 3
    Java并发编程：CountDownLatch实战解析
  • 4
    Java 转 AI 不用慌！3 周求职打卡表，帮你按天推进、高效拿 offer
  • 5
    2025 年最新 Java 实操学习路线，从入门到高级应用详细指南
  • 6
    从 Java 到 AI：三周求职冲刺打卡，步步为营拿 offer
  • 7
    最详细Java正则表达式详解
  • 8
    热门小程序源码合集：微信抖音小程序源码支持PHP/Java/uni-app完整项目实践指南
  • 9
    2025 年全新出炉的 Java 学习路线：从入门起步到实操精通的详细指南
  • 10
    终于可以解放双手了，使用Jenkins、ArgoCD 部署 Java 应用程序，最终部署在 Kubernetes 集群上
  • 1
    滚雪球学Java(57)：解密Java中List接口底层实现原理
    109
  • 2
    Java一分钟之-Micrometer：应用指标库
    294
  • 3
    Java一分钟之-GraphQL：查询语言与API设计
    593
  • 4
    Java一分钟之-Netty：高性能异步网络库
    191
  • 5
    Java一分钟之-Vert.x：轻量级事件驱动框架
    515
  • 6
    Java一分钟之-RabbitMQ：AMQP协议实现
    273
  • 7
    Java一分钟之-Kafka：分布式消息队列
    217
  • 8
    Java一分钟之-ActiveMQ：消息中间件
    306
  • 9
    Java一分钟之-JMS：Java消息服务
    481
  • 10
    Java中的ORM框架——myBatis
    201

    • 相关课程

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

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0
    • 下一篇
    阿里云免费云服务器:个人用户每月750小时免费