002. 线程的使用

最新推荐文章于 2022-11-27 01:05:45 发布
最新推荐文章于 2022-11-27 01:05:45 发布
阅读量73 收藏
点赞数
分类专栏： java开发系列篇 文章标签： 多线程 java 面试 分布式 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/purplesky95/article/details/114633752
版权

概述

  • 今天主要看看以下几部分内容

    • 线程状态
    • 线程终止
    • 内存屏障和 CPU 缓存
    • 线程通信
    • 线程封闭

1. 线程状态

1. 6个状态
  • 网上的答案各种各样，有5个，有6个，还有7个的，大家直接从官方源码，从以下枚举中查看线程的状态就可以了。

java.lang.Thread.State

  • NEW: 尚未启动的线程的线程状态。
  • RUNNABLE: 可运行线程的线程状态，等待CPU调度。
  • BLOCKED: 线程阻塞等待监视器锁定的线程状态。处于 synchronized 同步代码块或方法中被阻塞。
  • WAITING: 等待线程的线程状态。下列不带超时的方式: Object.wait、Thread.join、LockSupport.park
  • TIMED_WAITING: 具有指定等待时间的等待线程的线程状态。下列带超时的方式: Thread.sleep、Object.wait、Thread.join、LockSupport.parkNanos、LockSupport.parkUntil
  • TERMINATED: 终止线程的线程状态。线程正常完成执行或者出现异常。
2. 线程状态切换

img

3. 线程状态切换示例代码
1. 新建 > 运行 > 终止
System.out.println("################### 第一种状态切换 - 新建 > 运行 > 终止 ###################");
Thread thread1 = new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("thread1 当前状态：" + Thread.currentThread().getState().toString());
        System.out.println("thread1 执行了");
    }
});
System.out.println("没调用 start 方法，thread1 当前状态: " + thread1.getState().toString());
thread1.start();
Thread.sleep(2000L); // 等待 thread1 执行结束，再看状态
System.out.println("等待两秒，再看 thread1 当前状态: " + thread1.getState().toString());
// thread1.start(); 当线程终止，再次调用 start 方法时，会抛出 IllegalThreadStateException 异常。
2. 新建 > 运行 > 等待 > 运行 > 终止(sleep方式)
System.out.println("################### 第二种状态切换 - 新建 > 运行 > 等待 > 运行 > 终止(sleep方式) ###################");
Thread thread2 = new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            Thread.sleep(1500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("thread2 当前状态: " + Thread.currentThread().getState().toString());
        System.out.println("thread2 执行了");
    }
});
System.out.println("没调用 start 方法，thread2 当前状态: " + thread2.getState().toString());
thread2.start();
System.out.println("调用 start 方法，thread2 当前状态: " + thread2.getState().toString());
Thread.sleep(200L); // 等待 200 毫秒，再看状态
System.out.println("等待 200 毫秒，再看 thread2 当前状态: " + thread2.getState().toString());
Thread.sleep(3000L); // 再等 3 秒，让 thread2 执行完毕，再看状态
System.out.println("等待 3 秒，再看 thread2 当前状态: " + thread2.getState().toString());
3. 新建 > 运行 > 阻塞 > 运行 > 终止
System.out.println("################### 第三种状态切换 - 新建 > 运行 > 阻塞 > 运行 > 终止 ###################");
Thread thread3 = new Thread(new Runnable() {
    @Override
    public void run() {
        synchronized (Demo2.class) {
            System.out.println("thread3 当前状态: " + Thread.currentThread().getState().toString());
            System.out.println("thread3 执行了");
        }
    }
});
synchronized (Demo2.class) {
    System.out.println("没调用 start 方法，thread3 当前状态: " + thread3.getState().toString());
    thread3.start();
    System.out.println("调用 start 方法，thread3 当前状态: " + thread3.getState().toString());
    Thread.sleep(200L); // 等待 200 毫秒，再看状态
    System.out.println("等待 200 毫秒，再看 thread3 当前状态: " + thread3.getState().toString());
}
Thread.sleep(3000L);

2. 线程终止

1. 不正确的线程终止 - stop
  • stop: 终止线程，并且清除监控器锁的信息，但是可能导致线程安全问题，JDK 不建议使用。
  • destory: JDK 未实现该方法。
2. 正确的线程终止 - interrupt

  • 如果目标线程在调用 Object class 的 wait()、wait(long) 或 wait(long,int)方法、join()、join(long,int) 或 sleep(long,int) 方法时被阻塞，那么 interrupt 会生效，则线程的中断状态将会被清除，抛出 InterruptedException 异常。

  • 如果目标线程是被 I/O 或者 NIO 中的 Channel 所阻塞，同样，I/O 操作会被中断或者返回异常值。达到终止线程的目的。

  • 如果以上条件都不满足，则会设置此线程的中断状态。

3. 正确的线程终止 - 标志位
  • 代码逻辑中，增加一个判断，用来控制线程执行的终止。
4. 代码演示
1. stop 和 interrupt
package com.study.hc.thread.chapter1.thread;

public class StopThread extends Thread {
    private int i = 0, j = 0;

    @Override
    public void run() {
        synchronized (this) {
            // 增加同步锁，确保线程安全
            ++i;
            try {
                // 休眠 10 秒，模拟耗时操作
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            ++j;
        }
    }

    /** 打印 i 和 j */
    public void print() {
        System.out.println("i=" + i + " j=" + j);
    }
}

package com.study.hc.thread.chapter1.thread;

/**
 * 示例3 - 线程 stop 强制性终止，破坏线程安全的示例
 */
public class Demo3 {
    public static void main(String[] args) throws InterruptedException {
        StopThread thread = new StopThread();
        thread.start();
        // 休眠 1 秒，确保变量 i 变量自增成功
        Thread.sleep(1000);
        // 中止线程
        // thread.stop();
        thread.interrupt(); // 正确终止
        while (thread.isAlive()) {
            // 确保线程已经终止
        }
        // 输出结束
        thread.print();
    }
}
2. 添加标志位
package com.study.hc.thread.chapter1.thread;

public class Demo4 {
    public volatile static boolean flag = true;

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            try {
                while (flag) {
                    System.out.println("运行中");
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        // 3 秒之后，将状态标志改为 false，代表不继续执行
        Thread.sleep(3000);
        flag = false;
        System.out.println("程序运行结束");
    }
}

3. 内存屏障和 CPU 缓存

1. CPU 性能优化手段 - 缓存
  • 为了提高程序运行的性能，现代 CPU 在很多方面对程序进行了优化。
  • 例如: CPU 高速缓存。尽可能地避免处理器访问主内存的时间开销，处理器大多会利用缓存(cache)以提高性能。

img

三级缓存

  • L1 Cache (一级缓存)是 CPU 第一层高速缓存，分为数据缓存和指令缓存。一般服务器 CPU 的 L1 缓存的容量通常在 32-4096KB。

  • L2 由于 L1 级高速缓存容量的限制，为了再次提高 CPU 的运算速度，在 CPU 外部放置一高速存储器，即二级缓存。

  • L3 现在的都是内置的。而它的实际作用是，L3 缓存的应用可以进一步降低内存延迟，同时提升大数据量计算时处理器的性能。具有较大 L3 缓存的处理器提供更有效的文件系统缓存行为及较短消息和处理器队列长度。一般是多核共享一个 L3 缓存。

CPU 在读取数据时，先在 L1 中寻找，再从 L2 寻找，再从 L3 寻找，然后是内存，再后是外存储器。

缓存同步协议

  • 多 CPU 读取同样的数据进行缓存，进行不同运算之后，最终写入主内存以那个 CPU 为准？

  • 在这种高速缓存回写的场景下，有一个缓存一致性协议多数 CPU 厂商对它进行了实现。

  • MESI 协议，它规定每条缓存有个状态位，同时定义了下面四种状态:

    • 修改态（Modified） - 此 cache 行已被修改过（脏行），内容已不同于主存，为此 cache 专有。
    • 专有态（Exclusive） - 此 cache 行内容同于主存，但不出现于其他 cache 中。
    • 共享态（Shared） - 此 cache 行内容同于主存，也出现于其他 cache 中。
    • 无效态（Invalid） - 此 cache 内容无效（空行）。

  • 多处理器时，单个 CPU 对缓存中数据进行了改动，需要通知给其他 CPU。

  • 也就意味着，CPU 处理要控制自己的读写操作，还要监听其他 CPU 发出的通知，从而保证最终一致性。

2. CPU 性能优化手段 - 运行时指令重排

img

  • 指令重排的场景：当 CPU 写缓存时发现缓存区块正被其他 CPU 占用，为了提高 CPU 处理性能，可能将后面的读缓存命令优先执行。

  • 并非随便重排，需要遵守 as-if-serial 语义。

  • as-if-serial 语义的意思指：不管怎么重排序（编译器和处理器为了提高并行度），（单线程）程序的执行结果不能改变。编译器，runtime 和处理器都必须遵守 as-if-serial 语义。

  • 也就是说，编译器和处理器不会对存在数据依赖关系的操作做重排序。

3. 两个问题

  1. CPU 高速缓存下有一个问题：缓存中的数据与主内容的数据并不是实时同步的，各 CPU（或 CPU 核心）间缓存的数据也不是实时同步的。在同一时间点，各 CPU 所看到同一内存地址的数据的值可能是不一致的。

  2. CPU 执行指令重排序优化下有一个问题：虽然遵守了 as-if-serial 语义，单仅在单 CPU 自己执行的情况下能保证结果正确。多核多线程中，指令逻辑无法分辨因果关联，可能出现乱序执行，导致程序运行结果错误。

4. 内存屏障
  • 处理器提供了两个内存屏障指令（Memory Barrier）用于解决上述两个问题。
1. 写内存屏障(Store Memory Barrier)
  • 在指令后插入 Store Barrier，能让写入缓存中的最新数据更新写入主内存，让其他线程可见。
  • 强制写入主内存，这种显示调用，CPU 就不会因为性能考虑而去对指令重排。
2. 读内存屏障(Load Memory Barrier)
  • 在指令前插入 Load Barrier，可以让告诉缓存中的数据失效，强制重新从主内存加载数据。
  • 强制读取主内存内容，让 CPU 缓存与主内存保持一致，避免了缓存存在的一致性问题。

4. 线程通信

1. 通信的方式

  • 想要实现多个线程之间的协同，如：线程执行先后顺序、获取某个线程执行的结果等等。

  • 涉及到线程之间相互通信，分为下面四类：

    • 文件共享
    • 网络共享
    • 共享变量
    • JDK 提供的线程协调 API
      • suspend/resume
      • wait/notify
      • park/unpark
2. 文件共享

img

代码演示
public class Demo5 {
    public static void main(String[] args) {
        // 线程 1 - 写入数据
        new Thread(() -> {
            try {
                while (true) {
                    Files.write(Paths.get("Demo5.log"),
                            ("当前时间 " + System.currentTimeMillis()).getBytes());
                    Thread.sleep(1000);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }).start();

        // 线程 2 - 读取数据
        new Thread(() -> {
            try {
                while (true) {
                    Thread.sleep(1000);
                    byte[] allBytes = Files.readAllBytes(Paths.get("Demo5.log"));
                    System.out.println(new String(allBytes));
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }).start();
    }
}
3. 变量共享

img

代码演示
public class Demo6 {
    public static String content = "空";

    public static void main(String[] args) {
        // 线程 1 - 写入数据
        new Thread(() -> {
            try {
                while (true) {
                    content = "当前时间： " + System.currentTimeMillis();
                    Thread.sleep(1000);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }).start();

        // 线程 2 - 读取数据
        new Thread(() -> {
            try {
                while (true) {
                    Thread.sleep(1000);
                    System.out.println(content);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }).start();
    }
}
4. JDK API

  • JDK 中对于需要多线程协作完成某一任务的场景，提供了对应的 API 支持。

  • 多线程协作的典型场景是：生产者-消费者模型。（线程阻塞、线程唤醒）

示例
  • 线程 1 去买包子，没有包子，则不再执行。线程 2 生产出包子，通知线程 1 继续执行。

img

1. 被弃用的 suspend 和 resume

  • 调用 suspend 挂起目标线程，通过 resume 可以恢复线程执行。

  • 代码示例

    public void suspendResumeTest() throws InterruptedException {
    // 启动线程
    Thread consumerThread = new Thread(() -> {
        if (baozidian == null) {
            System.out.println("1. 没包子，进入等待");
            Thread.currentThread().suspend();
        }
        System.out.println("2. 买到包子，回家");
    });
    consumerThread.start();

    // 3 秒之后，生产一个包子
    Thread.sleep(3000);
    baozidian = new Object();
    consumerThread.resume();
    System.out.println("3. 通知消费者");
}

  • 被弃用的主要原因是：容易写出死锁的代码。所以使用wait/notify和park/unpark机制对它进行替代。

  • 死锁示例 - 1. 同步代码中使用

    // suspend 挂起之后并不会释放锁，故此容易写出死锁代码
public void suspendResumeDeadLockTest() throws InterruptedException {
    // 启动线程
    Thread consumerThread = new Thread(() -> {
        if (baozidian == null) { // 如果没有包子，则进入等待
            System.out.println("1. 进入等待");
            // 当前线程拿到锁，然后挂起
            synchronized (this) {
                Thread.currentThread().suspend();
            }
        }
        System.out.println("2. 买到包子，回家");
    });
    consumerThread.start();

    // 3 秒之后，生产一个包子
    Thread.sleep(3000);
    baozidian = new Object();
    // 争取到锁以后，再恢复 consumerThread
    synchronized (this) {
        consumerThread.resume();
    }
    System.out.println("3. 通知消费者");
}

  • 死锁示例 - 2. suspend 比 resume 后执行

    // 先执行 suspend，后执行 resume，反之则死锁
public void suspendResumeDeadLockTest2() throws InterruptedException {
    // 启动线程
    Thread consumerThread = new Thread(() -> {
        if (baozidian == null) {
            System.out.println("1. 没包子，进入等待");
            try { // 为这个线程加上一点延时
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 这里的挂起执行在 resume 之后
            Thread.currentThread().suspend();
        }
        System.out.println("2. 买到包子，回家");
    });
    consumerThread.start();

    // 3 秒之后，生产一个包子
    Thread.sleep(3000);
    baozidian = new Object();
    consumerThread.resume();
    System.out.println("3. 通知消费者");
    consumerThread.join();
}
2. wait/notify 机制

  • 这些方法只能由同一对象锁的持有者线程调用，也就是写在同步块里面，否则会抛出 IllegalMonitorStateException 异常。

  • wait 方法导致当前线程等待，加入该对象的等待集合中，并且放弃当前持有的对象锁。

  • notify/notifyAll 方法唤醒一个或所有正在等待这个对象所的线程。

  • 注意：虽然 wait 会自动解锁，但是对顺序有要求，如果在 notify 被调用之后，才开始 wait 方法的调用，线程会永远处于 WAITING 状态。

  • 死锁代码示例

    // 会导致程序永久等待的 wait/notify
public void waitNotifyDeadLockTest() throws InterruptedException {
    // 启动线程
    new Thread(() -> {
        if (baozidian == null) { // 如果没有包子，则进入等待
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (this) {
                try {
                    System.out.println("1. 进入等待");
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println("2. 买到包子，回家");
    }).start();

    // 3 秒之后，产生一个包子
    Thread.sleep(3000);
    baozidian = new Object();
    synchronized (this) {
        this.notifyAll();
        System.out.println("3. 通知消费者");
    }
}
3. park/unpark 机制

  • 线程调用park则等待“许可”，unpark方法为指定线程提供“许可(permit)”。

  • 不要求park和unpark方法的调用顺序。

  • 多次调用unpark之后，再调用park，线程会直接运行，但不会叠加。也就是说，连续多次调用park方法，第一次会拿到“许可”直接运行，后续调用会进入等待。

// 正常的 park/unpark
public void parkUnparkTest() throws InterruptedException {
	// 启动线程
	Thread consumerThread = new Thread(() -> {
        if (baozidian == null) { // 如果没有包子，则进入等待
            System.out.println("1. 进入等待");
            LockSupport.park();
        }
        System.out.println("2. 买到包子，回家");
    });
    consumerThread.start();

    // 3 秒之后，生产一个包子
    Thread.sleep(3000);
    baozidian = new Object();
    LockSupport.unpark(consumerThread);
    System.out.println("3. 通知消费者");
}
  • 因 park/unpark 不会释放锁，所以同步代码块中会产生死锁。
// park/unpark 死锁
public void parkUnparkDeadLockTest() throws InterruptedException {
    // 启动线程
    Thread consumerThread = new Thread(() -> {
        if (baozidian == null) {
            synchronized (this) {
                System.out.println("1. 进入等待");
                LockSupport.park();
            }
        }
        System.out.println("2. 买到包子，回家");
    });
    consumerThread.start();

    // 3 秒之后，生产一个包子
    Thread.sleep(3000);
    baozidian = new Object();
    // 争取到锁以后，再恢复 consumerThread
    synchronized (this) {
        LockSupport.unpark(consumerThread);
    }
    System.out.println("3. 通知消费者");
}
4. 3种方法的总结

  • suspend/resume 对调用顺序有要求，也要开发自己注意锁的释放。这个被弃用的 API，容易死锁，也容易导致永久挂起。

  • wait/notify 要求在同步关键字里面使用，免去了死锁的困扰，但是一定要先调用 wait，再调用 notify，否则永久等待了。

  • park/unpark 没有顺序要求，但是 park 并不会释放，所以同步代码中使用要注意。

5. 伪唤醒

  • 警告！之前代码中用 if 语句来判断，是否进入等待状态，是错误的！

  • 官方建议应该在循环中判断等待条件，原因是处于等待状态的线程可能会收到错误警报和伪唤醒，如果不在循环中检查等待条件，程序就会在没有满足结束条件的情况下退出。

  • 伪唤醒是指线程并非因为 notify、notifyall、unpark 等 api 调用而唤醒，是更底层原因导致的。

  • 示例代码

    // 启动线程
Thread consumerThread = new Thread(() -> {
    while (baozidian == null) {
        synchronized (this) {
            System.out.println("1. 进入等待");
            LockSupport.park();
        }
    }
    System.out.println("2. 买到包子，回家");
});
consumerThread.start();

5. 线程封闭

1. 概念

  • 多线程访问共享可变数据时，涉及到线程间数据同步的问题。并不是所有时候，都要用到共享数据，所以线程封闭概念就提出来了。

  • 数据都被封闭在各自的线程中，就不需要同步，这种通过将数据封闭在线程中而避免使用同步的技术称为线程封闭。

  • 线程封闭具体的表现有：ThreadLocal、局部变量。

2. ThreadLocal

  • ThreadLocal 是 java 中一种特殊的变量。

  • 它是一个线程级别变量，每个线程都有一个 ThreadLocal，就是每个线程都拥有自己独立的一个变量，竞争条件被彻底消除了，在开发模式下是绝对安全的变量。

  • 用法：ThreadLocal<T> var = new ThreadLocal<T>();

  • 会自动在每个线程上创建一个 T 的副本，副本之间彼此独立，互不影响。

  • 可以用 ThreadLocal 存储一些参数，以便在线程中多个方法中使用，用来代替方法传参的做法。

package com.study.hc.thread.chapter1.thread;

/**
 * 线程封闭示例
 */
public class Demo8 {
    // ThreadLocal 变量，每个线程都有一个副本，互不干扰
    public static ThreadLocal<String> value = new ThreadLocal<>();

    public static void main(String[] args) throws InterruptedException {
        new Demo8().threadLocalTest();
    }

    /**
     * ThreadLocal 测试
     */
    public void threadLocalTest() throws InterruptedException {
        // ThreadLocal 线程封闭示例
        value.set("这是主线程设置的 123"); // 主线程设置值
        String v = value.get();
        System.out.println("线程 1 执行之前，主线程取到的值：" + v);

        new Thread(() -> {
            String v2 = value.get();
            System.out.println("线程 1 取到的值：" + v2);
            // 设置 ThreadLocal
            value.set("这是线程 1 设置的 456");

            v2 = value.get();
            System.out.println("重新设置之后，线程 1 取到的值：" + v2);
            System.out.println("线程 1 执行结束");
        }).start();

        Thread.sleep(5000); // 等待所有线程执行结束

        v = value.get();
        System.out.println("线程 1 执行之后，主线程取到的值：" + v);
    }

}
3. 栈封闭
  • 局部变量的固有属性之一就是封闭在线程中。
  • 它们位于执行线程的栈中，其他线程无法访问这个栈。
山海紫穹
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaSE笔记（六）多线程
qq_25928447的博客
10-25 1641
Java多线程 **注意：**本章节会涉及到 操作系统 相关知识。 在了解多线程之前，让我们回顾一下操作系统中提到的进程概念： 进程是程序执行的实体，每一个进程都是一个应用程序（比如我们运行QQ、浏览器、LOL、网易云音乐等软件），都有自己的内存空间，CPU一个核心同时只能处理一件事情，当出现多个进程需要同时运行时，CPU一般通过时间片轮转调度算法，来实现多个进程的同时运行。 在早期的计算机中，进程是拥有资源和独立运行的最小单位，也是程序执行的最小单位。但是，如果我希望两个任务同时进行，就必须运行两个进
Thread线程类基本使用(下)
qq_61797201的博客
07-28 1449
前一篇文章主要介绍了如何创建新线程和如何查看Java进程中的线程信息等知识，这篇文章接着介绍关于Thread的一些构造方法及方法，这篇文章会用到。
1.1.3 线程通讯
「南小鸟」的博客
08-27 175
1、通讯方式 要想实现多个线程之间的协同，如：线程执行的先后顺序、获取某条线程的执行结果等等。 涉及到线程之间的相互通讯，分为如下几类： 1) 文件共享 2) 网络共享 3) 共享变量 4) JDK提供的线程协调API 细分为：suspend()/resume()、wait()/notify(...
线程通信
qq_35382207的博客
06-30 115
线程通信的方式 要想实现线程之间的协同， 如： 线程先后执行顺序， 获取某个线程的执行结果等， 涉及线程之间的相互通信， 分为下面四类 文件共享 网络共享 变量共享 JDK提供的线程协调API 细分为： suspend/resume, wait/notify, park/unpark 文件共享 变量共享 线程协作 - JDK API 典型场景： 生产者 - 消费者模型 （线程阻塞, 线程唤醒）示例： 线程1区买包子 ， 没有包子， 则不执行。 线程2生产包子， 通知线程1继续执行 API -...
EventBus 事件驱动
akumalzw的专栏
10-24 1322
EventBus 领域驱动
eclipse.002.7z.rar
01-23
标题中的"eclipse.002.7z.rar"表明这是一...总的来说，"eclipse.002.7z.rar"这个文件可能包含了Eclipse IDE的重要组成部分或特定功能集，对于开发者来说，解压并使用这个文件可以极大地提升他们的开发效率和工作体验。
应用源码之MyAndorid002.zip
最新发布
04-21
在"MyAndorid002"项目中，你可以看到如何运用面向对象编程原则，创建类、接口和方法，以及如何进行异常处理、线程管理等。通过分析源码，我们可以理解到Java在Android应用中的实际运用，这对于提升代码质量和性能至...
南开大学《并行程序设计》21秋在线作业002.docx
07-08
本文总结了《并行程序设计》在线作业中的关键知识点，涵盖了 SSE intrinsics、SIMD 架构、OpenMP、数据依赖、向量计算、线程安全性、SPMD 等方面。 1. SSE intrinsics SSE intrinsics 是一组 Intel 指令集架构...
WangT002.zip
12-23
综上所述，"WangT002.zip"可能包含了一个使用SSM框架实现的抢单系统，其中运用了乐观锁来解决并发问题。这个系统的源码分析和学习将有助于我们深入理解SSM框架的实践应用，以及在并发环境下如何利用乐观锁保证数据...
南开大学《并行程序设计》21秋在线作业002.pdf
07-08
7. MPI（Message Passing Interface）是并行计算中的通信库，矩阵每行排序的问题更适合使用阻塞型编程模型，因为它通常涉及数据的全局交换和同步。 8. 当处理器数量和问题规模同时增大，部分算法如 embarassingly ...
【并发】Java并发线程池底层原理详解与源码分析（上）
金鳞踏雨
11-27 597
线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。Executors 返回的线程池对象的弊端：1） FixedThreadPool 和 SingleThreadPool：允许的请求队列长度为 MAX_VALUE，可能会堆积大量的请求，从而导致 OOM。2.CachedThreadPool：允许的创建线程数量为 MAX_VALUE，可能会创建大量建大量的线程，从而导致 OOM
Thread.Sleep(1000) 、Task.Delay(1000).Wait() 区别
热门推荐
wushang923的专栏
11-11 1万+
We can use both Thread.Sleep() and Task.Delay() to suspend the execution of a program for some given time. But are we actually suspending the execution? What is the difference between these two? How
Thread->sleep、wait、join使用
朱利源的博客
05-04 3435
Thread sleep、wait、join使用这里先介绍join,然后把两个有关联的sleep和wait一起介绍.join()这个方法比较好理解,当前线程等待指定线程终止后在执行,将两个交替执行的线程合并为顺序执行的线程.比如在B线程中调用A线程的join()方法,直到A线程执行完毕,B线程才会继续执行.api有两个 void join()当前线程等待调用这个方法的线程终止后再执行. void j
小议 Thread.sleep(0) 造成 CPU占用率高的问题
lqg1122
08-28 1万+
首先，我们要清楚相关概念： 1.CPU使用率其实就是你运行的程序占用的CPU资源，表示你的机器在某个时间点的运行程序的情况。使用率越 高，说明你的机器在这个时间上运行了很多程序，反之较少。使用率的高低与你的CPU强弱有直接关系。现代分时 多任务操作系统对 CPU 都是分时间片使用的：比如A进程占用10ms，然后B进程占用30ms，然后空闲60ms，再又 是A进程占10ms，B进程占30ms
SpringBoot实现多线程定时任务，超简单
王京伟的博客
05-29 672
1.创建SpringBoot项目 1.1项目结构 1.2导入基本依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dep...
有关 Thread.Sleep（2000）
鸟不拉诗
12-23 1万+
学习source，看到了下面一段代码 try {             Thread.sleep(2000);         } catch (InterruptedException e) { } 首先这段代码的作用是使当前进程沉睡2S，展现给用户的结果就是画面维持两秒，有个“正在启动”的感觉而已。 其实，之前还有看到过sleep(0)的时候，这又是什么作用呢
java多线程汽车租赁
08-15
在这个程序中，我们使用了Java的同步机制来保证多个线程对共享资源（汽车）的访问是互斥的。当一个线程想要租赁一辆汽车时，它必须等待直到有一辆可用的汽车为止。当一个线程归还一辆汽车时，它会通知其他线程有一辆...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值