JUC（一）：进程与线程

已于 2022-07-29 23:15:14 修改
阅读量140 收藏
点赞数
分类专栏： 一起学JUC吧！ 文章标签： java jvm 开发语言
于 2022-07-24 22:40:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013494827/article/details/125960121
版权

目录

1. 进程与线程

进程

  • 程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载至 CPU，数据加载至内存。在 指令运行过程中还需要用到磁盘、网络等设备。进程就是用来加载指令、管理内存、管理 IO 的 。
  • 当一个程序被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程。
  • 进程就可以视为程序的一个实例。大部分程序可以同时运行多个实例进程（例如记事本、画图、浏览器 等），也有的程序只能启动一个实例进程（例如网易云音乐、360 安全卫士等）

线程

  • 一个进程之内可以分为一到多个线程。

  • 一个线程就是一个指令流，将指令流中的一条条指令以一定的顺序交给 CPU 执行

  • Java 中，线程作为最小调度单位，进程作为资源分配的最小单位。 在 windows 中进程是不活动的，只是作 为线程的容器

二者对比

  • 进程基本上相互独立的，而线程存在于进程内，是进程的一个子集

  • 进程拥有共享的资源，如内存空间等，供其内部的线程共享

  • 进程间通信较为复杂

    • 同一台计算机的进程通信称为 IPC（Inter-process communication）
    • 不同计算机之间的进程通信，需要通过网络，并遵守共同的协议，例如 HTTP

  • 线程通信相对简单，因为它们共享进程内的内存，一个例子是多个线程可以访问同一个共享变量

  • 线程更轻量，线程上下文切换成本一般上要比进程上下文切换低

2. 并行与并发

单核cpu下，线程实际还是串行执行的。操作系统中有一个组件叫做任务调度器，将 cpu 的时间片（windows 下时间片最小约为 15 毫秒）分给不同的程序使用，只是由于 cpu 在线程间（时间片很短）的切换非常快，人类感觉是同时运行的 。总结为一句话就是： 微观串行，宏观并行 。

一般会将这种线程轮流使用 CPU 的做法称为并发， concurrent

CPU时间片 1时间片 2时间片 3时间片 4
core线程 1线程 2线程 3线程 4

在这里插入图片描述

多核 cpu下，每个 核（core） 都可以调度运行线程，这时候线程可以是并行的。

CPU时间片 1时间片 2时间片 3时间片 4
core1线程 1线程 2线程 3线程 4
core2线程 4线程 4线程 2线程 2

在这里插入图片描述

引用 Rob Pike 的一段描述：

  • 并发（concurrent）是同一时间应对（dealing with）多件事情的能力 。
  • 并行（parallel）是同一时间动手做（doing）多件事情的能力。

3. 应用

∗ 应用之异步调用（案例 1 ） \textcolor{Green}{*应用之异步调用（案例1）} ∗应用之异步调用（案例1）

需要等待结果

这时既可以使用同步处理，也可以使用异步来处理

join 实现（同步）

static int result = 0;
private static void test1() throws InterruptedException {
    log.debug("开始");
    Thread t1 = new Thread(() -> {
        log.debug("开始");
        sleep(1);
        log.debug("结束");
        result = 10;
    }, "t1");
    t1.start();
    t1.join();
    log.debug("结果为:{}", result);
}

输出

20:30:40.453 [main] c.TestJoin - 开始
20:30:40.541 [Thread-0] c.TestJoin - 开始
20:30:41.543 [Thread-0] c.TestJoin - 结束
20:30:41.551 [main] c.TestJoin - 结果为:10

评价

  • 需要外部共享变量，不符合面向对象封装的思想
  • 必须等待线程结束，不能配合线程池使用
Future 实现（同步）
private static void test2() throws InterruptedException, ExecutionException {
    log.debug("开始");
    FutureTask<Integer> result = new FutureTask<>(() -> {
        log.debug("开始");
        sleep(1);
        log.debug("结束");
        return 10;
    });
    new Thread(result, "t1").start();
    log.debug("结果为:{}", result.get());
}

输出

10:11:57.880 c.TestSync [main] - 开始
10:11:57.942 c.TestSync [t1] - 开始
10:11:58.943 c.TestSync [t1] - 结束
10:11:58.943 c.TestSync [main] - 结果为:10

评价

  • 规避了使用 join 之前的缺点
  • 可以方便配合线程池使用
private static void test3() throws InterruptedException, ExecutionException {
    ExecutorService service = Executors.newFixedThreadPool(1);
    log.debug("开始");
    Future<Integer> result = service.submit(() -> {
        log.debug("开始");
        sleep(1);
        log.debug("结束");
        return 10;
    });
    log.debug("结果为:{}, result 的类型:{}", result.get(), result.getClass());
    service.shutdown();
}

输出

10:17:40.090 c.TestSync [main] - 开始
10:17:40.150 c.TestSync [pool-1-thread-1] - 开始
10:17:41.151 c.TestSync [pool-1-thread-1] - 结束
10:17:41.151 c.TestSync [main] - 结果为:10, result 的类型:class java.util.concurrent.FutureTask

评价

  • 仍然是 main 线程接收结果
  • get 方法是让调用线程同步等待
自定义实现（同步）

见模式篇：保护性暂停模式

CompletableFuture 实现（异步）
private static void test4() {
    // 进行计算的线程池
    ExecutorService computeService = Executors.newFixedThreadPool(1);
    // 接收结果的线程池
    ExecutorService resultService = Executors.newFixedThreadPool(1);
    log.debug("开始");
    CompletableFuture.supplyAsync(() -> {
        log.debug("开始");
        sleep(1);
        log.debug("结束");
        return 10;
    }, computeService).thenAcceptAsync((result) -> {
        log.debug("结果为:{}", result);
    }, resultService);
}

输出

10:36:28.114 c.TestSync [main] - 开始
10:36:28.164 c.TestSync [pool-1-thread-1] - 开始
10:36:29.165 c.TestSync [pool-1-thread-1] - 结束
10:36:29.165 c.TestSync [pool-2-thread-1] - 结果为:10

评价

  • 可以让调用线程异步处理结果，实际是其他线程去同步等待
  • 可以方便地分离不同职责的线程池
  • 以任务为中心，而不是以线程为中心
BlockingQueue 实现（异步）
private static void test6() {
    ExecutorService consumer = Executors.newFixedThreadPool(1);
    ExecutorService producer = Executors.newFixedThreadPool(1);
    BlockingQueue<Integer> queue = new SynchronousQueue<>();
    log.debug("开始");
    producer.submit(() -> {
        log.debug("开始");
        sleep(1);
        log.debug("结束");
        try {
            queue.put(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });
    consumer.submit(() -> {
        try {
            Integer result = queue.take();
            log.debug("结果为:{}", result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });
}
不需等待结果

这时最好是使用异步来处理

普通线程实现
@Slf4j(topic = "c.FileReader")
public class FileReader {
    public static void read(String filename) {
        int idx = filename.lastIndexOf(File.separator);
        String shortName = filename.substring(idx + 1);
        try (FileInputStream in = new FileInputStream(filename)) {
            long start = System.currentTimeMillis();
            log.debug("read [{}] start ...", shortName);
            byte[] buf = new byte[1024];
            int n = -1;
            do {
                n = in.read(buf);
            } while (n != -1);
            long end = System.currentTimeMillis();
            log.debug("read [{}] end ... cost: {} ms", shortName, end - start);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

没有用线程时，方法的调用是同步的：

@Slf4j(topic = "c.Sync")
public class Sync {
    public static void main(String[] args) {
        String fullPath = "E:\\1.mp4";
        FileReader.read(fullPath);
        log.debug("do other things ...");
    }
}

输出

18:39:15 [main] c.FileReader - read [1.mp4] start ...
18:39:19 [main] c.FileReader - read [1.mp4] end ... cost: 4090 ms
18:39:19 [main] c.Sync - do other things ...

使用了线程后，方法的调用时异步的：

private static void test1() {
    new Thread(() -> FileReader.read(Constants.MP4_FULL_PATH)).start();
    log.debug("do other things ...");
}

输出

18:41:53 [main] c.Async - do other things ...
18:41:53 [Thread-0] c.FileReader - read [1.mp4] start ...
18:41:57 [Thread-0] c.FileReader - read [1.mp4] end ... cost: 4197 ms
线程池实现
private static void test2() {
    ExecutorService service = Executors.newFixedThreadPool(1);
    service.execute(() -> FileReader.read(Constants.MP4_FULL_PATH));
    log.debug("do other things ...");
    service.shutdown();
}

输出

11:03:31.245 c.TestAsyc [main] - do other things ... 
11:03:31.245 c.FileReader [pool-1-thread-1] - read [1.mp4] start ... 
11:03:33.479 c.FileReader [pool-1-thread-1] - read [1.mp4] end ... cost: 2235 ms
CompletableFuture 实现
private static void test3() throws IOException {
    CompletableFuture.runAsync(() -> FileReader.read(Constants.MP4_FULL_PATH));
    log.debug("do other things ...");
    System.in.read();
}

输出

11:09:38.145 c.TestAsyc [main] - do other things ... 
11:09:38.145 c.FileReader [ForkJoinPool.commonPool-worker-1] - read [1.mp4] start ... 
11:09:40.514 c.FileReader [ForkJoinPool.commonPool-worker-1] - read [1.mp4] end ... cost: 2369 ms

以调用方角度来讲，

  • 如果 需要等待结果返回，才能继续运行就是同步
  • 不需要等待结果返回，就能继续运行就是异步

1.设计

多线程可以让方法执行变为异步的（即不要巴巴干等着）、比如说读取磁盘文件时，假设读取操作花费了 5 秒钟，如果没有线程调度机制，这 5 秒 cpu 什么都做不了，其它代码都得暂停…

2.结论

  • 比如在项目中，视频文件需要转换格式等操作比较费时，这时开一个新线程处理视频转换，避免阻塞主线程
  • tomcat 的异步 servlet 也是类似的目的，让用户线程处理耗时较长的操作，避免阻塞 tomcat 的工作线程
  • ui 程序中，开线程进行其他操作，避免阻塞 ui 线程

∗ 应用之提高效率（案例 1 ） \textcolor{Green}{*应用之提高效率（案例1） } ∗应用之提高效率（案例1）

充分利用多核 cpu 的优势，提高运行效率。想象下面的场景，执行 3 个计算，最后将计算结果汇总。

计算 1 花费 10 ms
计算 2 花费 11 ms
计算 3 花费 9 ms
汇总需要 1 ms

  • 如果是串行执行，那么总共花费的时间是 10 + 11 + 9 + 1 = 31ms

  • 但如果是四核 cpu，各个核心分别使用线程 1 执行计算 1，线程 2 执行计算 2，线程 3 执行计算 3，那么 3 个 线程是并行的，花费时间只取决于最长的那个线程运行的时间，即 11ms 最后加上汇总时间只会花费 12ms

注意： 需要在多核 cpu 才能提高效率，单核仍然时是轮流执行

1.设计
使用多线程充分利用CPU
环境搭建

  • 基准测试工具选择，使用了比较靠谱的 JMH，它会执行程序预热，执行多次测试并平均

  • cpu 核数限制，有两种思路

    1. 使用虚拟机，分配合适的核
    2. 使用 msconfifig，分配合适的核，需要重启比较麻烦

  • 并行计算方式的选择

    1. 最初想直接使用 parallel stream，后来发现它有自己的问题
    2. 改为了自己手动控制 thread，实现简单的并行计算

  • 测试代码如下

    mvn archetype:generate -DinteractiveMode=false -DarchetypeGroupId=org.openjdk.jmh -DarchetypeArtifactId=jmh-java-benchmark-archetype -DgroupId=org.sample -DartifactId=test -Dversion=1.0

    package org.sample;

import java.util.Arrays;
import java.util.concurrent.FutureTask;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.Warmup;

@Fork(1)
@BenchmarkMode(Mode.AverageTime)
@Warmup(iterations = 3)
@Measurement(iterations = 5)
public class MyBenchmark {
    static int[] ARRAY = new int[1000_000_00];

    static {
        Arrays.fill(ARRAY, 1);
    }

    @Benchmark
    public int c() throws Exception {
        int[] array = ARRAY;
        FutureTask<Integer> t1 = new FutureTask<>(() -> {
            int sum = 0;
            for (int i = 0; i < 250_000_00; i++) {
                sum += array[0 + i];
            }
            return sum;
        });
        FutureTask<Integer> t2 = new FutureTask<>(() -> {
            int sum = 0;
            for (int i = 0; i < 250_000_00; i++) {
                sum += array[250_000_00 + i];
            }
            return sum;
        });
        FutureTask<Integer> t3 = new FutureTask<>(() -> {
            int sum = 0;
            for (int i = 0; i < 250_000_00; i++) {
                sum += array[500_000_00 + i];
            }
            return sum;
        });
        FutureTask<Integer> t4 = new FutureTask<>(() -> {
            int sum = 0;
            for (int i = 0; i < 250_000_00; i++) {
                sum += array[750_000_00 + i];
            }
            return sum;
        });
        new Thread(t1).start();
        new Thread(t2).start();
        new Thread(t3).start();
        new Thread(t4).start();
        return t1.get() + t2.get() + t3.get() + t4.get();
    }

    @Benchmark
    public int d() throws Exception {
        int[] array = ARRAY;
        FutureTask<Integer> t1 = new FutureTask<>(() -> {
            int sum = 0;
            for (int i = 0; i < 1000_000_00; i++) {
                sum += array[0 + i];
            }
            return sum;
        });
        new Thread(t1).start();
        return t1.get();
    }
}
双核 CPU（4个逻辑CPU）
C:\Users\lenovo\eclipse-workspace\test>java -jar target/benchmarks.jar
# VM invoker: C:\Program Files\Java\jdk-11\bin\java.exe
# VM options: <none>
# Warmup: 3 iterations, 1 s each
# Measurement: 5 iterations, 1 s each
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: org.sample.MyBenchmark.c
# Run progress: 0.00% complete, ETA 00:00:16
# Fork: 1 of 1
# Warmup Iteration 1: 0.022 s/op
# Warmup Iteration 2: 0.019 s/op
# Warmup Iteration 3: 0.020 s/op
Iteration 1: 0.020 s/op
Iteration 2: 0.020 s/op
Iteration 3: 0.020 s/op
Iteration 4: 0.020 s/op
Iteration 5: 0.020 s/op
Result: 0.020 ±(99.9%) 0.001 s/op [Average]
 Statistics: (min, avg, max) = (0.020, 0.020, 0.020), stdev = 0.000
 Confidence interval (99.9%): [0.019, 0.021]
# VM invoker: C:\Program Files\Java\jdk-11\bin\java.exe
# VM options: <none>
# Warmup: 3 iterations, 1 s each
# Measurement: 5 iterations, 1 s each
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: org.sample.MyBenchmark.d
# Run progress: 50.00% complete, ETA 00:00:10
# Fork: 1 of 1
# Warmup Iteration 1: 0.042 s/op
# Warmup Iteration 2: 0.042 s/op
# Warmup Iteration 3: 0.041 s/op
Iteration 1: 0.043 s/op
Iteration 2: 0.042 s/op
Iteration 3: 0.042 s/op
Iteration 4: 0.044 s/op
Iteration 5: 0.042 s/op
Result: 0.043 ±(99.9%) 0.003 s/op [Average]
 Statistics: (min, avg, max) = (0.042, 0.043, 0.044), stdev = 0.001
 Confidence interval (99.9%): [0.040, 0.045]
# Run complete. Total time: 00:00:20
Benchmark Mode Samples Score Score error Units
o.s.MyBenchmark.c avgt 5 0.020 0.001 s/op
o.s.MyBenchmark.d avgt 5 0.043 0.003 s/op
  • 可以看到多核下，效率提升还是很明显的，快了一倍左右
单核 CPU
C:\Users\lenovo\eclipse-workspace\test>java -jar target/benchmarks.jar
# VM invoker: C:\Program Files\Java\jdk-11\bin\java.exe
# VM options: <none>
# Warmup: 3 iterations, 1 s each
# Measurement: 5 iterations, 1 s each
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: org.sample.MyBenchmark.c
# Run progress: 0.00% complete, ETA 00:00:16
# Fork: 1 of 1
# Warmup Iteration 1: 0.064 s/op
# Warmup Iteration 2: 0.052 s/op
# Warmup Iteration 3: 1.127 s/op
Iteration 1: 0.053 s/op
Iteration 2: 0.052 s/op
Iteration 3: 0.053 s/op
Iteration 4: 0.057 s/op
Iteration 5: 0.088 s/op
Result: 0.061 ±(99.9%) 0.060 s/op [Average]
 Statistics: (min, avg, max) = (0.052, 0.061, 0.088), stdev = 0.016
 Confidence interval (99.9%): [0.001, 0.121]
# VM invoker: C:\Program Files\Java\jdk-11\bin\java.exe
# VM options: <none>
# Warmup: 3 iterations, 1 s each
# Measurement: 5 iterations, 1 s each
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: org.sample.MyBenchmark.d
# Run progress: 50.00% complete, ETA 00:00:11
# Fork: 1 of 1
# Warmup Iteration 1: 0.054 s/op
# Warmup Iteration 2: 0.053 s/op
# Warmup Iteration 3: 0.051 s/op
Iteration 1: 0.096 s/op
Iteration 2: 0.054 s/op
Iteration 3: 0.065 s/op
Iteration 4: 0.050 s/op
Iteration 5: 0.055 s/op
Result: 0.064 ±(99.9%) 0.071 s/op [Average]
 Statistics: (min, avg, max) = (0.050, 0.064, 0.096), stdev = 0.018
 Confidence interval (99.9%): [-0.007, 0.135]
# Run complete. Total time: 00:00:22
Benchmark Mode Samples Score Score error Units
o.s.MyBenchmark.c avgt 5 0.061 0.060 s/op
o.s.MyBenchmark.d avgt 5 0.064 0.071 s/op
  • 性能几乎是一样的
2.结论
  1. 单核 cpu 下，多线程不能实际提高程序运行效率，只是为了能够在不同的任务之间切换，不同线程轮流使用 cpu ，不至于一个线程总占用 cpu，别的线程没法干活
  2. 多核 cpu 可以并行跑多个线程，但能否提高程序运行效率还是要分情况的
    • 有些任务，经过精心设计，将任务拆分，并行执行，当然可以提高程序的运行效率。但不是所有计算任 务都能拆分（参考后文的【阿姆达尔定律】）
    • 也不是所有任务都需要拆分，任务的目的如果不同，谈拆分和效率没啥意义
  3. IO 操作不占用 cpu，只是我们一般拷贝文件使用的是【阻塞 IO】，这时相当于线程虽然不用 cpu，但需要一 直等待 IO 结束，没能充分利用线程。所以才有后面的【非阻塞 IO】和【异步 IO】优化。
打工仔呀~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java8源码-JUC:日常使用进程/线程的案例或者case
06-04
线程:进程当中的一个执行单元 关系: 进程包含线程 面试问题: 日常使用进程/线程的案例或者case ###线程的各种状态: Thread.state --枚举 (需手写记忆) 进入源码:NEW --新建 RUNNABLE --运行 BLOCKED --阻塞 WAITING ...
juc:Java多线程学习笔记源码部分
04-13
进程是一个独立的运行环境，而线程是在进程中执行的一个任务。他们两个本质的区别是是否单独占有内存地址空间及其它系统资源（比如I/O）。 进程单独占有一定的内存地址空间，所以进程间存在内存隔离，数据是分开的，...
JUC简介：进程和线程、线程的状态、wait与sleep的区别、串行与并行、并行与并发、管程、用户线程与守护线程
weixin_46245201的博客
04-24 351
文章目录1. 简介2. 进程和线程3. 线程的状态4. wait与sleep的区别5. 串行与并行5.1 串行模式5.2 并行模式6. 并行与并发7. 管程的概念8. 用户线程与守护线程 1. 简介 在Java中，线程部分是一个重点，本篇文章说的JUC也是关于线程的。JUC就是java.util.concurrent工具包的简称。这是一个处理线程的工具包，JDK1.5开始出现的。 2. 进程和线程 进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操
1、JUC：什么是JUC及进程与线程
cxycxytony的博客
10-29 222
JUC是java.util.concurrent包的缩写，是java并发包。 java.util 工具包 业务：普通的线程代码 Thread Runnable 没有返回值，效率相比于Callable相对较低！ 1.2、进程、线程 进程：一个程序，QQ.exe Music.exe 程序的集合。 一个进程可以包含多个线程，至少包含一个！ java默认有有几个线程? 2个 main线程、GC 线程：开了一个进程Typora，写字，自动保存（线程负责的） 对于java而言：Thread、Runnable、Ca
1、JUC:线程和进程
Garry
11-19 101
学习过程观看视频：[狂神说Java] https://www.bilibili.com/video/BV1B7411L7tE?p=2 欢迎大家支持噢，很良心的老师了！ java真的可以开启线程吗？ 答：开不了，是调用本地方法开启的线程，调用本地c++开启的线程，java无法直接操作硬件 并发和并行 运行结果 ...
JUC1-进程与线程
m0_73902080的博客
08-15 907
4.线程通信相对简单，因为它们共享进程内的内存，一个例子是多个线程可以访问同一个共享变量。1.进程基本上相互独立，而线程存在于进程内，是进程的一个子集。2.进程拥有共享的资源，如内存空间等，供其内部的线程共享。5.线程更轻量，线程上下文切换成本一般比进程上下文切换低。3.进程间通信较为复杂。
JUC—线程与进程
showadwalker的博客
09-04 106
这里写自定义目录标题一、进程与线程1.1 线程Java开启线程的方式Java真的可以开启线程吗？线程的状态wait 和 sleep 的区别1.2 进程二、并发和并行2.1 并发2.2 并行 一、进程与线程 1.1 线程 Java开启线程的方式 Thread、Runnable、Callable Java真的可以开启线程吗？ 不可以，Java不能直接操作硬件。是通过调用 native 本地方法 start，底层是C++ private native void start(); 线程的状态 // Thread.
JUC学习：什么是线程安全
冷雨清的博客
11-08 226
什么是线程安全？ 其实线程安全指的也就是内存安全，操作系统里面会有很多进程，为了保证安全，操作系统会为这些进程分配各自的内存，每个进程就只能访问自己的那部分内存，而这个内存就叫堆内存。但每个进程里面可能又有许多的线程，为了安全也会为它们分配一个自己的内存，这个内存就叫栈内存。 而现实场景中不可能每个线程都只访问栈内存，有部分变量就需要放到一个公共空间里面，但如何保证这个公共空间资源的安全呢？ 解决方案以下几种， 局部变量 直接放到每个线程的栈内存中 就是资源复制多几份给每个线程都能分到一份一样的资源，
JUC学习笔记一进程与线程
JMU_software19的博客
11-20 320
进程与线程的概念 进程 程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载至 CPU，数据加载至内存。在 指令运行过程中还需要用到磁盘、网络等设备。进程就是用来加载指令、管理内存、管理 IO 的 当一个程序被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程。 进程就可以视为程序的一个实例。大部分程序可以同时运行多个实例进程（例如记事本、画图、浏览器 等），也有的程序只能启动一个实例进程（例如网易云音乐、360 安全卫士等） 线程 线程是操作系
JUC——进程与线程
m0_51710682的博客
08-01 970
【阻塞状态】 如果调用了阻塞 API，如 BIO 读写文件，这时该线程实际不会用到 CPU，会导致线程上下文切换，进入 【阻塞状态】 等 BIO 操作完毕，会由操作系统唤醒阻塞的线程，转换至【可运行状态】 与【可运行状态】的区别是，对【阻塞状态】的线程来说只要它们一直不唤醒，调度器就一直不会考虑调度它们。有一种特殊的线程叫做守护线程，只要其它非守护线程运行结束了，即使守护线程的代码没有执行完，也会强制结束。单核虽然不能通过多线程提高效率，但可以让不同的线程轮流使用CPU ，避免被一个线程长时间占用。
JUC-进程和线程
诗和远方，代码和你
07-21 298
进程：程序是静止的，进程实体的运行过程就是进程，是系统进行资源分配的基本单位进程的特征：并发性、异步性、动态性、独立性、结构性线程：线程是属于进程的，是一个基本的 CPU 执行单元，是程序执行流的最小单元。线程是进程中的一个实体，是系统独立调度的基本单位，线程本身不拥有系统资源，只拥有一点在运行中必不可少的资源，与同属一个进程的其他线程共享进程所拥有的全部资源关系：一个进程可以包含多个线程，这就是多线程，比如看视频是进程，图画、声音、广告等就是多个线程线程的作用：使多道程序更好的并发执行，提高资源利用率和系
笨蛋学JUC并发编程-进程与线程
YSL_Monet的博客
01-17 1028
用Runnable更容易与线程池等高级API配合用Runnable让任务类脱离了Thread继承体系，更灵活。
JUC代码演示 Java多线程并发
05-03
在给定的代码示例中，通过以下方式设置了一个名为`ydy`的守护线程： ```java Thread thread = new Thread(() -> { System.out.println(Thread.currentThread().getName() + "::" + Thread.currentThread()....
JUC多线程学习个人笔记
07-08
5. **并发工具类**：JUC还包含了一些并发编程的实用工具，如Semaphore（信号量，用于限制同时访问某个资源的线程数量），CountDownLatch（计数下标，用于等待一组线程完成任务），CyclicBarrier（循环栅栏，使一组...
Java-JUC-多线程 进阶
07-05
线程是进程中的执行单元，可以与其他线程共享同一个进程的资源。Java 中的线程可以通过继承 Thread 类或实现 Runnable 接口来创建。 Lock 锁 锁（Lock）是 Java 中的一种同步机制，用于保护共享资源免受多个线程的...
JAVA进阶补充
2301_80150315的博客
08-15 770
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
手撕快排——三种实现方法（附动图及源码）
最新发布
jsjs1346的博客
08-16 556
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
进程间通信 ---共享内存
BUG制造机的博客
08-14 1033
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
Java Spring|day3.SpringBoot
weixin_60364343的博客
08-15 338
告诉Spring boot需要什么功能,它就能引入需要的依赖库起步依赖就是特殊的Maven依赖，利用了传递依赖解析，把常用库聚合在一起，组成几个为特定功能而定制的依赖。
理解Java JUC并发编程：进程与线程的区别与ZFS笔记
JUC编程笔记中的"JUC编程"主要讨论了Java并发编程（Java Util Concurrency, JUC）的相关概念和技术，涉及的关键知识点包括进程与线程、并发与并行以及它们之间的关系。以下是详细的解释： 1. **进程与线程**: - ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值