javaSE之多线程

最新推荐文章于 2024-07-12 15:51:39 发布
最新推荐文章于 2024-07-12 15:51:39 发布
阅读量159 收藏
点赞数
文章标签： java servlet jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51523399/article/details/126410441
版权


 

活动地址：CSDN21天学习挑战赛

6. 多线程

6.1 简介

现代计算机绝大部分都有多核处理器，使得程序可以并发的执行多个任务。在Java中，使用多线程编程，可以使得程序运行速度更快。

6.2 进程与线程

  • Process：进程就是应用程序的一个实例。进程中包含了程序中所需要的所有数据以及相关其它资源，并且占用一定内存空间。操作系统在同一时间可以运行多个进程。（进程级别的并发）

  • Thread：线程，从技术上来讲，就是由多个指令或操作形成的序列（线程名称的由来），或者说线程就是执行我们所写代码的“主体”。一个进程至少由一个主线程（main thread）组成，同时，我们还可以创建更多的线程执行其它的任务。（线程级别的并发）

 

// 获取当前活跃线程数量
System.out.println(Thread.activeCount());
// 获取当前处理器数量
System.out.println(Runtime.getRuntime().availableProcessors());

6.3 线程基本操作

6.3.1 创建与启动线程

public class DownloadFileTask implements Runnable {
    @Override
    public void run() {
        System.out.println("Download:" + Thread.currentThread().getName());
    }
}
​
public class ThreadDemo {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName());
        for (int i = 0; i < 3; i++) {
            Thread t0 = new Thread(new DownloadFileTask());
            t0.start();
        }
    }
}

6.3.2 暂停线程

public class DownloadFileTask implements Runnable {
    @Override
    public void run() {
        System.out.println("Download:" + Thread.currentThread().getName());
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Download complete:" + Thread.currentThread().getName());
    }
}

  • sleep()：当前线程进入“睡眠”，它将会挂起（暂停）当前线程，同时使得其它线程有机会使用CPU资源（processor）

  • 睡眠时间只是“约等于” 5 秒，具体取决于当前操作系统。

如果创建的线程数量大于CPU的线程数，情况会如何呢？

在我们的操作系统中，有一个专门的线程调度器，它负责给每个线程分配CPU时间片，并且在每个线程间进行快速切换，使得每个线程有机会使用processor来进行运算，这就造就了“并发”的效果。

6.3.3 join

等待加入

public class ThreadDemo {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName());
        Thread t0 = new Thread(new DownloadFileTask());
        t0.start();
        try {
            t0.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("下载完毕，可以开始扫描病毒");
    }
}

join()将会使得当前线程（main thread）进入等待状态，直到t0线程执行完毕，才能继续往下执行剩余逻辑，在此期间，main thread什么都不能做。

6.3.4 interrupt

中断线程

public class DownloadFileTask implements Runnable {
    @Override
    public void run() {
        System.out.println("Download:" + Thread.currentThread().getName());
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            if (Thread.currentThread().isInterrupted()) return;
            System.out.println("Downloading - " + i);
        }
        System.out.println("Download complete:" + Thread.currentThread().getName());
    }
}
​
public class ThreadDemo {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName());
        Thread t0 = new Thread(new DownloadFileTask());
        t0.start();
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t0.interrupt();
    }
}

  • interrupt()并不会强制中断线程，它只是发出一个中断请求，由被中断线程来决定是否应该中断。

  • 被中断线程需要持续检查是否收到中断请求，编写相应逻辑进行中断。

6.4 并发带来的问题

 

在此前演示的案例中，每个线程都是单独下载自己的文件，这并不会带来任何负面的影响，但是，如果多个线程共同下载同一个文件，便会引发如下问题：

  • Race Condition：竞争状况。多个线程比赛和竞争，同时想修改同一份数据。

  • Visibility Problem：可见性一个线程修改了共享数据，但是其修改对其它线程并不可见，导致多个线程针对同一份数据，看到的数据视图是不一样的。

所以，多个线程访问同一个数据，但其中有一个线程想要修改数据，那么以上问题就会出现；如果所有线程只是读取数据，那么这些问题就不存在。

在多个线程访问同一个数据并且想要进行修改时，为了预防以上问题发生，我们就需要编写线程安全的代码（Thread safe - Code）来解决并发问题。

在JDK中，有些类或方法解决了以上并发带来的问题，我们就称之为线程安全的类或线程安全的方法

6.5 竞争状况

public class DownloadStatus {
    private int totalBytes;
​
    public void incrementTotalBytes(){
        totalBytes++;
    }
​
    public int getTotalBytes() {
        return totalBytes;
    }
}
​
public class DownloadFileTask implements Runnable {
    private DownloadStatus status;
​
    public DownloadFileTask(DownloadStatus status) {
        this.status = status;
    }
​
    @Override
    public void run() {
        System.out.println("Download:" + Thread.currentThread().getName());
        for (int i = 0; i < 10_000; i++) {
            if (Thread.currentThread().isInterrupted()) return;
            status.incrementTotalBytes();
        }
        System.out.println("Download complete:" + Thread.currentThread().getName());
    }
}
​
public class ThreadDemo {
    public static void main(String[] args) {
        var status = new DownloadStatus();
        List<Thread> threads = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            var thread = new Thread(new DownloadFileTask(status));
            threads.add(thread);
            thread.start();
        }
​
        for (var thread : threads) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(status.getTotalBytes());
    }
}

运行该程序以后，我们会观察到最终结果并非是 10 个线程下载的总和，主要原因在于：

public void incrementTotalBytes(){
  totalBytes++;
}

在这个方法中，修改状态的代码虽然只有一行，但实际上包含了 3 步操作：

  1. 首先从主存储器（main memory）把这个状态的值拷贝到CPU中

  2. CPU对这个值进行add操作

  3. CPU将这个更新后的值写回到主存储器（main memory）

整个方法的逻辑由于包含了 3 步操作，因此我们称之为非原子操作（non - atomic operation，不能再进一步细分的操作），假定发生如下场景，那么就会导致对要修改的数据，其中某一个线程的修改操作无效（被另一个线程的修改操作覆盖）：

 

解决方案：

  • 将被修改的数据根据访问线程的数量，切割为对应的份数分配给对应的线程，在所有线程操作完毕后再进行合并。

  • 待访问的数据使用不可改变（immutable）的对象，例如字符串就是不可变对象（当我们把字符串修改为大写时，实际上将会创建一个新的字符串对象）

  • 将线程同步化（synchronization）：使用锁（Lock）防止多个线程在同一时间访问同一个数据

     

    我们可以给某一部分代码加上lock，让这份代码在同一时间只能被一个线程执行，在执行期间，其它线程只能等待前一个线程执行完毕，才能继续访问这块代码。这最终就形成了所有线程对同一个数据的多个操作只能依次有序进行。（线程同步非常容易导致死锁，dead lock）

  • 使用原子对象（atomic object）：原子对象所有的方法或操作都是不可再细分的，这本身就意味着，不可能有两个以上的线程同时修改一份数据。

  • 分区技术：允许多个线程访问同一个数据的不同区域或片段

6.6 切割与合并数据

public class DownloadFileTask implements Runnable {
    private DownloadStatus status;
​
    public DownloadFileTask() {
        this.status = new DownloadStatus();
    }
​
    @Override
    public void run() {
        System.out.println("Download:" + Thread.currentThread().getName());
        for (int i = 0; i < 10_000; i++) {
            if (Thread.currentThread().isInterrupted()) return;
            status.incrementTotalBytes();
        }
        System.out.println("Download complete:" + Thread.currentThread().getName());
    }
​
    public DownloadStatus getStatus() {
        return status;
    }
}
​
public class ThreadDemo {
    public static void main(String[] args) {
        var status = new DownloadStatus();
        List<Thread> threads = new ArrayList<>();
        List<DownloadFileTask> tasks = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            var task = new DownloadFileTask();
            tasks.add(task);
            var thread = new Thread(task);
            threads.add(thread);
            thread.start();
        }
​
        for (var thread : threads)
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        var totalBytes = tasks.stream()
                .map(task -> task.getStatus().getTotalBytes())
                .reduce(Integer::sum);
        System.out.println(totalBytes);
    }
}

6.7 Lock

public class DownloadStatus {
    private int totalBytes;
    private Lock lock = new ReentrantLock();
​
    public void incrementTotalBytes(){
        lock.lock();
        try {
            totalBytes++;
        } finally {
            lock.unlock();
        }
    }
​
    public int getTotalBytes() {
        return totalBytes;
    }
}
我们还可以使用synchronized关键字：

public class DownloadStatus {
    private int totalBytes;
​
    public synchronized void incrementTotalBytes() {
        totalBytes++;
    }
​
    public int getTotalBytes() {
        return totalBytes;
    }
}
public class DownloadStatus {
    private int totalBytes;
    private final Object totalBytesLock = new Object();
​
    public void incrementTotalBytes() {
        synchronized (totalBytesLock) {
            totalBytes++;
        }
    }
​
    public int getTotalBytes() {
        return totalBytes;
    }
}

6.8 volatile关键字

public class DownloadStatus {
    private int totalBytes;
    private boolean isDone;
​
    public synchronized void incrementTotalBytes() {
            totalBytes++;
    }
​
    public int getTotalBytes() {
        return totalBytes;
    }
​
    public boolean isDone() {
        return isDone;
    }
​
    public void setDone(boolean done) {
        isDone = done;
    }
}
​
public class DownloadFileTask implements Runnable {
    private DownloadStatus status;
​
    public DownloadFileTask(DownloadStatus status) {
        this.status = status;
    }
​
    @Override
    public void run() {
        System.out.println("Download:" + Thread.currentThread().getName());
        for (int i = 0; i < 1_000_000; i++) {
            if (Thread.currentThread().isInterrupted()) return;
            status.incrementTotalBytes();
        }
        status.setDone(true);
        System.out.println("Download complete:" + Thread.currentThread().getName());
    }
}
​
public class ThreadDemo {
    public static void main(String[] args) {
        var status = new DownloadStatus();
        var t1 = new Thread(new DownloadFileTask(status));
        t1.start();
​
        var t2 = new Thread(() -> {
            while (!status.isDone()) {
            }
            System.out.println(status.getTotalBytes());
        });
        t2.start();
​
    }
}

在这个案例中，我们会发现程序一直运行不能停止，且t2线程无法输出最终结果，主要原因在于：

  • 在计算机的CPU运行过程中，存在一套缓存机制：为了优化程序执行速度，会首先把主存储器（main memory）中的数据拷贝到自己的缓存（cache）中，然后再继续运算。由于直接从自己的cache中读取数据的速度更快，因此减少了不断传值带来的时间损耗。

  • t1线程和t2线程首先都把这个值拷贝到自己的缓存中，然后t1线程对这个值做出了修改，由于缓存中的数据只有自己可以访问，因此t2线程并看不到这个修改，甚至当t1线程将这个修改写回到主存储器，这种修改对于t2仍然是不可见的。

这种场景，就称为多线程并发的可见性问题：

 

解决方法：

public class DownloadStatus {
    private int totalBytes;
    private volatile boolean isDone;
​
    public synchronized void incrementTotalBytes() {
            totalBytes++;
    }
​
    public int getTotalBytes() {
        return totalBytes;
    }
​
    public boolean isDone() {
        return isDone;
    }
​
    public void setDone(boolean done) {
        isDone = done;
    }
}

当isDone被volatile修饰时，意味着告诉JVM这个变量是不稳定的，不要在计算的时候依赖存储在缓存中的值，而总是从主存储器中读取它，同时，当一个线程修改isDone时，会立刻更新存储在主存储器中的值。

6.9 线程间通信

上述案例中，t2线程通过一个while循环不断检测状态值的变化，这个操作有可能会循环很多次，从而浪费CPU的运算时间，我们可以进一步调整为：

public class ThreadDemo {
    public static void main(String[] args) {
        var status = new DownloadStatus();
        var t1 = new Thread(new DownloadFileTask(status));
        t1.start();
​
        var t2 = new Thread(() -> {
            while (!status.isDone()) {
                synchronized (status) {
                    try {
                        status.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
            System.out.println(status.getTotalBytes());
        });
        t2.start();
    }
}
​
public class DownloadFileTask implements Runnable {
    private DownloadStatus status;
​
    public DownloadFileTask(DownloadStatus status) {
        this.status = status;
    }
​
    @Override
    public void run() {
        System.out.println("Download:" + Thread.currentThread().getName());
        for (int i = 0; i < 10_000; i++) {
            if (Thread.currentThread().isInterrupted()) return;
            status.incrementTotalBytes();
        }
        status.setDone(true);
        synchronized (status) {
            status.notifyAll();
        }
        System.out.println("Download complete:" + Thread.currentThread().getName());
    }
}

  • wait()：将会导致该线程一直处于等待状态，直到其它线程唤醒它。

  • notifyAll()：唤醒等待在该对象上的其它线程

  • JVM要求调用wait()和notifyAll()的时候，对代码进行同步化。

6.10 原子对象

为了更有效的进行线程间通信，同时解决多线程并发带来的问题，最有效的方式是使用原子对象：

public class DownloadStatus {
    private AtomicInteger totalBytes = new AtomicInteger();
​
    public void incrementTotalBytes() {
        totalBytes.getAndIncrement();
    }
​
    public int getTotalBytes() {
        return totalBytes.get();
    }
}
​
public class DownloadFileTask implements Runnable {
    private DownloadStatus status;
​
    public DownloadFileTask(DownloadStatus status) {
        this.status = status;
    }
​
    @Override
    public void run() {
        System.out.println("Download:" + Thread.currentThread().getName());
        for (int i = 0; i < 10_000; i++) {
            if (Thread.currentThread().isInterrupted()) return;
            status.incrementTotalBytes();
        }
        System.out.println("Download complete:" + Thread.currentThread().getName());
    }
}
​
public class ThreadDemo {
    public static void main(String[] args) {
        var status = new DownloadStatus();
        List<Thread> threads = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            var thread = new Thread(new DownloadFileTask(status));
            threads.add(thread);
            thread.start();
        }
​
        for (var thread : threads) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(status.getTotalBytes());
    }
}

6.11 同步集合

public class ThreadDemo {
    public static void main(String[] args) {
        Collection<Integer> collection = Collections.synchronizedList(new ArrayList<>());
        var t1 = new Thread(()-> collection.addAll(Arrays.asList(1, 2, 3)));
        var t2 = new Thread(()-> collection.addAll(Arrays.asList(4, 5, 6)));
        t1.start();
        t2.start();
    }
}

6.12 并发集合

同步集合，会使用synchronized机制对代码执行锁，但因此也带来了一些负面影响，即其它线程需要等待前面的线程执行完毕才能继续访问。

而JDK中，提供了并发集合来提供更高效的访问方式，即允许多个线程采用分区的方式访问同一个数据的不同区域或片段：

Map<String, Integer> map = new ConcurrentHashMap<>();
Java哈奇士
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
创建线程四种方式
任丽媛的博客
05-30 4321
第一种方式：Thread class 继承Thread类（重点） 自定义线程类继承Thread类 重写run()方法，编写线程执行体 创建线程对象，调用start()方法启动线程 //创建线程方法一，继承Thread类，重写run()方法，调用start开启线程 public class TestThread1 extends Thread{ public void run(){ for (int i = 0; i < 20; i++) { S
JavaSE --- 多线程
MemoryTa的博客
08-06 210
多线程。。概述生产者消费者模式是一个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对多线程编程的理解更加深刻。所谓生产者消费者问题，实际上主要是包含了两类线程：一类是生产者线程用于生产数据一类是消费者线程用于消费数据为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为Object类的等待和唤醒方法。............
Java多线程详解（附详细代码演示）
weixin_44183721的博客
08-14 4402
Java多线程、并发问题、同步、原子类、volatile、synchronized、集合
多线程——Runnable 创建线程
beishanqiye的博客
09-10 190
package thread; // 创建线程方法2 public class testRunnable implements Runnable{ @Override public void run() { for (int i = 0; i < 5000; i++) { //循环尽量大点，越了解线程的处理方式 System.out.println("!!!!!!"+i); } } public stat
线程的创建方式
weixin_46760166的博客
09-19 8867
1、继承 Tread类， 重写 run方法2、实现 Runnable接口，实现 run方法3、实现 Callable接口，实现 call方法，该方式可以获取线程的执行结果。
java多线程详解（二）之创建线程的方式
qq_37080455的博客
07-22 279
实现Runnable接口创建的线程，ThreadNameThread-1线程状态stateRUNNABLE线程的上下文类加载器sun.misc.Launcher$AppClassLoader@b4aac2线程Id10线程所属分组java.lang.ThreadGroup[name=main,maxpri=10]线程的优先级5。从结果上可以看到，线程执行的顺序是随机的，只要不改变最终的结果，执行的顺序可以进行调整的。2、getState()获取当前线程的运行状态。......
javaJSE---多线程
weixin_64112304的博客
05-10 168
一、线程的概念 二、进程与线程 三、线程的状态 四、线程同步 --------------------------------------------------------------------------------------------------------------------------------- 一、线程的概念 ▪ 程序:Program,是一个指令的集合 ▪ 进程:Process,(正在执行中的程序)是一个静态的概念 进程是程序的一次静态态执行过程, 占用特定的地址空.
javase之多线程技术
10-16
Java中的多线程技术是Java进阶学习的重要组成部分，它涉及到并发编程的理论与实践，旨在提高程序的执行效率和响应速度。以下是对多线程技术的详细解释： 1. **CPU调度算法原理** - **先来先服务（FCFS）**：按照...
JavaSE之多线程实战视频课程
06-09
JavaSE之多线程实战视频课程是一系列深入探讨Java中多线程技术的教程，适合对Java编程有一定基础的学习者。课程涵盖了多线程的基本概念，以及如何在Java环境中实现和管理多线程，旨在提升开发者对并发编程的理解和...
JavaSE多线程
09-15
JavaSE的多线程特性是其强大的功能之一，它允许开发者编写能够同时处理多个任务的程序，从而提高程序的效率和响应性。在Java中，线程是程序执行的最小单位，而进程则是资源分配的基本单位。每个Java应用程序至少有一...
JavaSE异常与多线程
06-04
入门级笔记，适合查漏补缺。
JavaSE 多线程资料
04-06
JavaSE 多线程是Java编程中至关重要的概念，它涉及到如何在单个程序中同时执行多个任务，从而提升程序的效率和响应性。在Java中，线程是程序执行的最小单位，与进程一同构成了操作系统的基础运行模型。 首先，线程...
配置Java开发环境
Broken_x的博客
07-10 1462
Java开发环境配置
java版的上门家政系统和PHP版的上门家政有什么区别？
最新发布
baina666的博客
07-12 356
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 427
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 2326
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
java Object 转 Integer
servepeople的博客
07-09 1420
在 Java 中，可以通过多种方法将一个Object转换为Integer。
java占位符替换五种方式
weixin_61478518的博客
07-08 548
在业务开发中，经常需要输出文本串。其中，部分场景下大部分文本内容是一样的，只有少部分点是不一样。简单做法是直接拼接字段，但是这会有个问题。后面如果想要修改内容，那么每个地方都要修改，这不符合设计模式中的开闭原则，面向应该对扩展开放，对修改关闭。如何解决这个问题？先来看现实生活中的例子，个人信息填写。一般会要填写表格，已经定义好了姓名，性别，年龄等字段，只要填写对应的个人信息就好了。在程序开发中，我们会预先定义好一个字符串模板，需要改动的点使用占位符。
elk部署springboot
Chihirozy的博客
07-11 259
elk部署springboot。
JavaSE专题-多线程总结.doc
06-03
多线程的常见问题总结分析 1、多线程技术介绍 2、主线程介绍 3、创建线程的方式 4、线程中的异常问题 5、线程运行状态 6、线程第二种创建方式 7、多线程练习 8、线程安全问题分析和解决 9、多线程细节 10、同步使用的锁

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值