操作系统和并发的爱恨纠葛

别再只调包了!深入理解机器学习虚拟筛选中的分子指纹(ECFP/Morgan) 本文深入探讨了ECFP/Morgan分子指纹在机器学习虚拟筛选中的应用与优化策略。通过解析半径参数与比特长度的化学意义,揭示了如何通过参数调优提升模型性能20%以上,特别适用于药物发现领域的高通量筛选。文章还提供了工程实践中的参数优化策略和多指纹融合技术,为开发者提供从理论到实践的全面指导。 阅读详情

我一直没有急于写并发的原因是我参不透操作系统,如今,我已经把操作系统刷了一遍,这次试着写一些并发,看看能不能写清楚,卑微小编在线求鼓励...... 我打算采取操作系统和并发同时结合讲起来的方式。

并发历史

在计算机最早期的时候,没有操作系统,执行程序只需要一个过程,那就是从头到尾依次执行。任何资源都会为这个程序服务,这必然就会存在 浪费资源 的情况。

这里说的浪费资源指的是资源空闲,没有充分使用的情况。

操作系统为我们的程序带来了 并发性,操作系统使我们的程序同时运行多个程序,一个程序就是一个进程,也就相当于同时运行了多个进程。

操作系统是一个并发系统,并发性是操作系统非常重要的特征,操作系统具有同时处理和调度多个程序的能力,比如多个 I/O 设备同时在输入输出;设备 I/O 和 CPU 计算同时进行;内存中同时有多个系统和用户程序被启动交替、穿插地执行。操作系统在协调和分配进程的同时,操作系统也会为不同进程分配不同的资源。

操作系统实现多个程序同时运行解决了单个程序无法做到的问题,主要有下面三点

  • 资源利用率,我们上面说到,单个进程存在资源浪费的情况,举个例子,当你在为某个文件夹赋予权限的时候,输入程序无法接受外部的输入字符,只能等到权限赋予完毕后才能接受外部输入。综合来讲,就是在等待程序时无法执行其他工作。如果在等待程序的同时可以运行另一个程序,那么将会大大提高资源的利用率。(资源并不会觉得累)因为它不会划水~
  • 公平性,不同的用户和程序对于计算机上的资源有着同样的使用权。一种高效的运行方式是为不同的程序划分时间片使用资源,但是有一点需要注意,操作系统可以决定不同进程的优先级,虽然每个进程都有能够公平享有资源的权利,但是每次前一个进程释放资源后的同时有一个优先级更高的进程抢夺资源,就会造成优先级低的进程无法获得资源,久而久之会导致进程饥饿。
  • 便利性,单个进程是无法通信的,通信这一点我认为其实是一种避雷针策略,通信的本质就是信息交换,及时进行信息交换能够避免信息孤岛,做重复性的工作;任何并发能做的事情,顺序编程也能够实现,只不过这种方式效率很低,它是一种 阻塞式 的。

但是,顺序编程(也称为串行编程)也不是一无是处的,串行编程的优势在于其直观性和简单性,客观来讲,串行编程更适合我们人脑的思考方式,但是我们并不会满足于顺序编程,we want it more!!! 。资源利用率、公平性和便利性促使着进程出现的同时也促使着线程的出现。

如果你还不是很理解进程和线程的区别的话,那么我就以我多年操作系统的经验(吹牛逼,实则半年)来为你解释一下:进程是一个应用程序,而线程是应用程序中的一条顺序流。

 

 

 

 

 

或者阮一峰老师也给出了你通俗易懂的解释

 

 

 

线程会共享进程范围内的资源,例如内存和文件句柄,但是每个线程也有自己私有的内容,比如程序计数器、栈以及局部变量。下面汇总了进程和线程共享资源的区别

 

线程被描述为一种轻量级的进程,轻量级体现在线程的创建和销毁要比进程的开销小很多。

注意:任何比较都是相对的。

在大多数现代操作系统中,都以线程为基本的调度单位,所以我们的视角着重放在对线程的探究。

线程

优势和劣势

合理使用线程是一门艺术,合理编写一道准确无误的多线程程序更是一门艺术,如果线程使用得当,能够有效的降低程序的开发和维护成本。

在 GUI 中,线程可以提高用户界面的响应灵敏度,在服务器应用程序中,并发可以提高资源利用率以及系统吞吐率。

Java 很好的在用户空间实现了开发工具包,并在内核空间提供系统调用来支持多线程编程,Java 支持了丰富的类库 java.util.concurrent 和跨平台的内存模型,同时也提高了开发人员的门槛,并发一直以来是一个高阶的主题,但是现在,并发也成为了主流开发人员的必备素质。

虽然线程带来的好处很多,但是编写正确的多线程(并发)程序是一件极困难的事情,并发程序的 Bug 往往会诡异地出现又诡异的消失,在当你认为没有问题的时候它就出现了,难以定位 是并发程序的一个特征,所以在此基础上你需要有扎实的并发基本功。那么,并发为什么会出现呢?

为什么是并发

计算机世界的快速发展离不开 CPU、内存和 I/O 设备的高速发展,但是这三者一直存在速度差异性问题,我们可以从存储器的层次结构可以看出

 

CPU 内部是寄存器的构造,寄存器的访问速度要高于高速缓存,高速缓存的访问速度要高于内存,最慢的是磁盘访问。

程序是在内存中执行的,程序里大部分语句都要访问内存,有些还需要访问 I/O 设备,根据漏桶理论来说,程序整体的性能取决于最慢的操作也就是磁盘访问速度。

因为 CPU 速度太快了,所以为了发挥 CPU 的速度优势,平衡这三者的速度差异,计算机体系机构、操作系统、编译程序都做出了贡献,主要体现为:

  • CPU 使用缓存来中和和内存的访问速度差异
  • 操作系统提供进程和线程调度,让 CPU 在执行指令的同时分时复用线程,让内存和磁盘不断交互,不同的 CPU 时间片 能够执行不同的任务,从而均衡这三者的差异
  • 编译程序提供优化指令的执行顺序,让缓存能够合理的使用

我们在享受这些便利的同时,多线程也为我们带来了挑战,下面我们就来探讨一下并发问题为什么会出现以及多线程的源头是什么

线程带来的安全性问题

线程安全性是非常复杂的,在没有采用同步机制的情况下,多个线程中的执行操作往往是不可预测的,这也是多线程带来的挑战之一,下面我们给出一段代码,来看看安全性问题体现在哪

public class TSynchronized implements Runnable{

    static int i = 0;

    public void increase(){
        i++;
    }


    @Override
    public void run() {
        for(int i = 0;i < 1000;i++) {
            increase();
        }
    }

    public static void main(String[] args) throws InterruptedException {

        TSynchronized tSynchronized = new TSynchronized();
        Thread aThread = new Thread(tSynchronized);
        Thread bThread = new Thread(tSynchronized);
        aThread.start();
        bThread.start();
        System.out.println("i = " + i);
    }
}
复制代码

这段程序输出后会发现,i 的值每次都不一样,这不符合我们的预测,那么为什么会出现这种情况呢?我们先来分析一下程序的运行过程。

TSynchronized 实现了 Runnable 接口,并定义了一个静态变量 i,然后在 increase 方法中每次都增加 i 的值,在其实现的 run 方法中进行循环调用,共执行 1000 次。

可见性问题

在单核 CPU 时代,所有的线程共用一个 CPU,CPU 缓存和内存的一致性问题容易解决,CPU 和 内存之间

如果用图来表示的话我想会是下面这样

 

在多核时代,因为有多核的存在,每个核都能够独立的运行一个线程,每颗 CPU 都有自己的缓存,这时 CPU 缓存与内存的数据一致性就没那么容易解决了,当多个线程在不同的 CPU 上执行时,这些线程操作的是不同的 CPU 缓存

 

 

因为 i 是静态变量,没有经过任何线程安全措施的保护,多个线程会并发修改 i 的值,所以我们认为 i 不是线程安全的,导致这种结果的出现是由于 aThread 和 bThread 中读取的 i 值彼此不可见,所以这是由于 可见性 导致的线程安全问题。

####原子性问题

看起来很普通的一段程序却因为两个线程 aThread 和 bThread 交替执行产生了不同的结果。但是根源不是因为创建了两个线程导致的,多线程只是产生线程安全性的必要条件,最终的根源出现在 i++ 这个操作上。

这个操作怎么了?这不就是一个给 i 递增的操作吗?也就是 i++ => i = i + 1,这怎么就会产生问题了?

因为 i++ 不是一个 原子性 操作,仔细想一下,i++ 其实有三个步骤,读取 i 的值,执行 i + 1 操作,然后把 i + 1 得出的值重新赋给 i(将结果写入内存)。

当两个线程开始运行后,每个线程都会把 i 的值读入到 CPU 缓存中,然后执行 + 1 操作,再把 + 1 之后的值写入内存。因为线程间都有各自的虚拟机栈和程序计数器,他们彼此之间没有数据交换,所以当 aThread 执行 + 1 操作后,会把数据写入到内存,同时 bThread 执行 + 1 操作后,也会把数据写入到内存,因为 CPU 时间片的执行周期是不确定的,所以会出现当 aThread 还没有把数据写入内存时,bThread 就会读取内存中的数据,然后执行 + 1操作,再写回内存,从而覆盖 i 的值,导致 aThread 所做的努力白费。

 

为什么上面的线程切换会出现问题呢?

我们先来考虑一下正常情况下(即不会出现线程安全性问题的情况下)两条线程的执行顺序

 

可以看到,当 aThread 在执行完整个 i++ 的操作后,操作系统对线程进行切换,由 aThread -> bThread,这是最理想的操作,一旦操作系统在任意 读取/增加/写入 阶段产生线程切换,都会产生线程安全问题。例如如下图所示

 

 

最开始的时候,内存中 i = 0,aThread 读取内存中的值并把它读取到自己的寄存器中,执行 +1 操作,此时发生线程切换,bThread 开始执行,读取内存中的值并把它读取到自己的寄存器中,此时发生线程切换,线程切换至 aThread 开始运行,aThread 把自己寄存器的值写回到内存中,此时又发生线程切换,由 aThread -> bThread,线程 bThread 把自己寄存器的值 +1 然后写回内存,写完后内存中的值不是 2 ,而是 1, 内存中的 i 值被覆盖了。

我们上面提到 原子性 这个概念,那么什么是原子性呢?

并发编程的原子性操作是完全独立于任何其他进程运行的操作,原子操作多用于现代操作系统和并行处理系统中。

原子操作通常在内核中使用,因为内核是操作系统的主要组件。但是,大多数计算机硬件,编译器和库也提供原子性操作。

在加载和存储中,计算机硬件对存储器字进行读取和写入。为了对值进行匹配、增加或者减小操作,一般通过原子操作进行。在原子操作期间,处理器可以在同一数据传输期间完成读取和写入。 这样,其他输入/输出机制或处理器无法执行存储器读取或写入任务,直到原子操作完成为止。

简单来讲,就是原子操作要么全部执行,要么全部不执行。数据库事务的原子性也是基于这个概念演进的。

有序性问题

在并发编程中还有带来让人非常头疼的 有序性 问题,有序性顾名思义就是顺序性,在计算机中指的就是指令的先后执行顺序。一个非常显而易见的例子就是 JVM 中的类加载

 

 

 

这是一个 JVM 加载类的过程图,也称为类的生命周期,类从加载到 JVM 到卸载一共会经历五个阶段 加载、连接、初始化、使用、卸载。这五个过程的执行顺序是一定的,但是在连接阶段,也会分为三个过程,即 验证、准备、解析 阶段,这三个阶段的执行顺序不是确定的,通常交叉进行,在一个阶段的执行过程中会激活另一个阶段。

有序性问题一般是编译器带来的,编译器有的时候确实是 好心办坏事,它为了优化系统性能,往往更换指令的执行顺序。

活跃性问题

多线程还会带来活跃性问题,如何定义活跃性问题呢?活跃性问题关注的是 某件事情是否会发生。

如果一组线程中的每个线程都在等待一个事件,而这个事件只能由该组中的另一个线程触发,这种情况会导致死锁。

简单一点来表述一下,就是每个线程都在等待其他线程释放资源,而其他资源也在等待每个线程释放资源,这样没有线程抢先释放自己的资源,这种情况会产生死锁,所有线程都会无限的等待下去。

换句话说,死锁线程集合中的每个线程都在等待另一个死锁线程占有的资源。但是由于所有线程都不能运行,它们之中任何一个资源都无法释放资源,所以没有一个线程可以被唤醒。

如果说死锁很痴情的话,那么活锁用一则成语来表示就是 弄巧成拙。

某些情况下,当线程意识到它不能获取所需要的下一个锁时,就会尝试礼貌的释放已经获得的锁,然后等待非常短的时间再次尝试获取。可以想像一下这个场景:当两个人在狭路相逢的时候,都想给对方让路,相同的步调会导致双方都无法前进。

现在假想有一对并行的线程用到了两个资源。它们分别尝试获取另一个锁失败后,两个线程都会释放自己持有的锁,再次进行尝试,这个过程会一直进行重复。很明显,这个过程中没有线程阻塞,但是线程仍然不会向下执行,这种状况我们称之为 活锁(livelock)。

如果我们期望的事情一直不会发生,就会产生活跃性问题,比如单线程中的无限循环

while(true){...}

for(;;){}
复制代码

在多线程中,比如 aThread 和 bThread 都需要某种资源,aThread 一直占用资源不释放,bThread 一直得不到执行,就会造成活跃性问题,bThread 线程会产生饥饿,我们后面会说。

性能问题

与活跃性问题密切相关的是 性能 问题,如果说活跃性问题关注的是最终的结果,那么性能问题关注的就是造成结果的过程,性能问题有很多方面:比如服务时间过长,吞吐率过低,资源消耗过高,在多线程中这样的问题同样存在。

在多线程中,有一个非常重要的性能因素那就是我们上面提到的 线程切换,也称为 上下文切换(Context Switch),这种操作开销很大。

在计算机世界中,老外都喜欢用 context 上下文这个词,这个词涵盖的内容很多,包括上下文切换的资源,寄存器的状态、程序计数器等。context switch 一般指的就是这些上下文切换的资源、寄存器状态、程序计数器的变化等。

在上下文切换中,会保存和恢复上下文,丢失局部性,把大量的时间消耗在线程切换上而不是线程运行上。

为什么线程切换会开销如此之大呢?线程间的切换会涉及到以下几个步骤

 

 

将 CPU 从一个线程切换到另一线程涉及挂起当前线程,保存其状态,例如寄存器,然后恢复到要切换的线程的状态,加载新的程序计数器,此时线程切换实际上就已经完成了;此时,CPU 不在执行线程切换代码,进而执行新的和线程关联的代码。

引起线程切换的几种方式

线程间的切换一般是操作系统层面需要考虑的问题,那么引起线程上下文切换有哪几种方式呢?或者说线程切换有哪几种诱因呢?主要有下面几种引起上下文切换的方式

  • 当前正在执行的任务完成,系统的 CPU 正常调度下一个需要运行的线程
  • 当前正在执行的任务遇到 I/O 等阻塞操作,线程调度器挂起此任务,继续调度下一个任务。
  • 多个任务并发抢占锁资源,当前任务没有获得锁资源,被线程调度器挂起,继续调度下一个任务。
  • 用户的代码挂起当前任务,比如线程执行 sleep 方法,让出CPU。
  • 使用硬件中断的方式引起上下文切换

线程安全性

在 Java 中,要实现线程安全性,必须要正确的使用线程和锁,但是这些只是满足线程安全的一种方式,要编写正确无误的线程安全的代码,其核心就是对状态访问操作进行管理。最重要的就是最 共享(Shared)的 和 可变(Mutable)的状态。只有共享和可变的变量才会出现问题,私有变量不会出现问题,参考程序计数器。

对象的状态可以理解为存储在实例变量或者静态变量中的数据,共享意味着某个变量可以被多个线程同时访问、可变意味着变量在生命周期内会发生变化。一个变量是否是线程安全的,取决于它是否被多个线程访问。要使变量能够被安全访问,必须通过同步机制来对变量进行修饰。

如果不采用同步机制的话,那么就要避免多线程对共享变量的访问,主要有下面两种方式

  • 不要在多线程之间共享变量
  • 将共享变量置为不可变的

我们说了这么多次线程安全性,那么什么是线程安全性呢?

什么是线程安全性

根据上面的探讨,我们可以得出一个简单的定义:当多个线程访问某个类时,这个类始终都能表现出正确的行为,那么就称这个类是线程安全的。

单线程就是一个线程数量为 1 的多线程,单线程一定是线程安全的。读取某个变量的值不会产生安全性问题,因为不管读取多少次,这个变量的值都不会被修改。

原子性

我们上面提到了原子性的概念,你可以把原子性操作想象成为一个不可分割 的整体,它的结果只有两种,要么全部执行,要么全部回滚。你可以把原子性认为是 婚姻关系 的一种,男人和女人只会产生两种结果,好好的 和 说散就散,一般男人的一生都可以把他看成是原子性的一种,当然我们不排除时间管理(线程切换)的个例,我们知道线程切换必然会伴随着安全性问题,男人要出去浪也会造成两种结果,这两种结果分别对应安全性的两个结果:线程安全(好好的)和线程不安全(说散就散)。

竞态条件

有了上面的线程切换的功底,那么竞态条件也就好定义了,它指的就是两个或多个线程同时对一共享数据进行修改,从而影响程序运行的正确性时,这种就被称为竞态条件(race condition) ,线程切换是导致竞态条件出现的诱导因素,我们通过一个示例来说明,来看一段代码

public class RaceCondition {
  
  private Signleton single = null;
  public Signleton newSingleton(){
    if(single == null){
      single = new Signleton();
    }
    return single;
  }
  
}
复制代码

在上面的代码中,涉及到一个竞态条件,那就是判断 single 的时候,如果 single 判断为空,此时发生了线程切换,另外一个线程执行,判断 single 的时候,也是空,执行 new 操作,然后线程切换回之前的线程,再执行 new 操作,那么内存中就会有两个 Singleton 对象。

加锁机制

在 Java 中,有很多种方式来对共享和可变的资源进行加锁和保护。Java 提供一种内置的机制对资源进行保护:synchronized 关键字,它有三种保护机制

  • 对方法进行加锁,确保多个线程中只有一个线程执行方法;
  • 对某个对象实例(在我们上面的探讨中,变量可以使用对象来替换)进行加锁,确保多个线程中只有一个线程对对象实例进行访问;
  • 对类对象进行加锁,确保多个线程只有一个线程能够访问类中的资源。

synchronized 关键字对资源进行保护的代码块俗称 同步代码块(Synchronized Block),例如

synchronized(lock){
  // 线程安全的代码
}
复制代码

每个 Java 对象都可以用做一个实现同步的锁,这些锁被称为 内置锁(Instrinsic Lock)或者 监视器锁(Monitor Lock)。线程在进入同步代码之前会自动获得锁,并且在退出同步代码时自动释放锁,而无论是通过正常执行路径退出还是通过异常路径退出,获得内置锁的唯一途径就是进入这个由锁保护的同步代码块或方法。

synchronized 的另一种隐含的语义就是 互斥,互斥意味着独占,最多只有一个线程持有锁,当线程 A 尝试获得一个由线程 B 持有的锁时,线程 A 必须等待或者阻塞,直到线程 B 释放这个锁,如果线程 B 不释放锁的话,那么线程 A 将会一直等待下去。

线程 A 获得线程 B 持有的锁时,线程 A 必须等待或者阻塞,但是获取锁的线程 B 可以重入,重入的意思可以用一段代码表示

public class Retreent {
  
  public synchronized void doSomething(){
    doSomethingElse();
    System.out.println("doSomething......");
  }
  
  public synchronized void doSomethingElse(){
    System.out.println("doSomethingElse......");
}
复制代码

获取 doSomething() 方法锁的线程可以执行 doSomethingElse() 方法,执行完毕后可以重新执行 doSomething() 方法中的内容。锁重入也支持子类和父类之间的重入,具体的我们后面会进行介绍。

volatile 是一种轻量级的 synchronized,也就是一种轻量级的加锁方式,volatile 通过保证共享变量的可见性来从侧面对对象进行加锁。可见性的意思就是当一个线程修改一个共享变量时,另外一个线程能够 看见 这个修改的值。volatile 的执行成本要比 synchronized 低很多,因为 volatile 不会引起线程的上下文切换。

 

 

 

关于 volatile 的具体实现,我们后面会说。

我们还可以使用原子类 来保证线程安全,原子类其实就是 rt.jar 下面以 atomic 开头的类

 

 

 

除此之外,我们还可以使用 java.util.concurrent 工具包下的线程安全的集合类来确保线程安全,具体的实现类和其原理我们后面会说哟。

 

【异常】Claude Code CLI工具 模型加载异常 /init报错排查与完整解决方案 There‘s an issue with the selected model (glm-5). It 此类跨厂商模型配置报错,核心诱因是API生态的兼容性不匹配。优先使用工具原生支持的模型体系,可快速解决90%以上的同类报错;若需跨厂商使用目标模型,需完成API端点、鉴权密钥、模型ID的全链路适配,确保全流程配置合规,即可完成异常修复。 阅读详情

相关推荐

C语言入门—初识C语言

一、C语言概述 1、什么是C语言 语言是用来交流沟通的,有一方说,有一方听。必须要两方参与。(自言自语的除外) 语言是人与人交流,而C语言是人与机器交流 语言有独特的语法规则和定义,双方必须遵循这些规则和定义才能实现真正的交流。 接下来首先了解下计算机的组成: 2、计算机介绍 2.1、计算机结构组成 2.2、计算机系统组成 2.3、程序的指令 指令是对计算机进行程序控制的最小单元 计算机的指令系统是指所有指令的集合 程序是指为完成某一项特定任务而用某种言语编写的一组指令序列 3、C语言发展历程 3.

jun319817的博客 1041

操作系统-线程和进程的区别

进程与线程区别: 类型 进程 线程 根本区别 进程是操作系统资源分配的基本单位 线程是CPU调度和分派的基本单位 开销方面 每个进程都有独立的代码和数据空间(程序上下文),进程之间切换开销大 线程可以看做轻量级的进程,同一类线程共享代码和数据空间,每个线程都有自己独立的运行栈和程序计数器(PC),线程之间切换的开销小 所处环境 在操作系统中能同时运行多个进程(程序)...

算法攻城狮 527

【Aseprite】制作Unity2D瓦片地图素材(平台游戏)

本文章用于记录用Aseprite软件制作2D平台游戏的瓦片地图的方法。

凡心所向,素履以往 5552

无限循环测试线程

类别 「网站分类」C++ /************************************************** * 程序名:test1.cpp * 编辑者:鸿灬嗳 * 注:验证全局变量的改变。 ***************************************************/ #include"iostream" using nam...

weixin_30500663的博客 148

探索LLM世界:新手小白的学习路线图

通过系统的学习和实践,新手小白也能逐步掌握LLM的核心技术。掌握LLM不仅能提升个人技术水平,还能为职业发展带来广阔的前景。未来,随着技术的不断进步,LLM将在更多领域发挥重要作用,成为推动科技进步的重要力量。学习LLM是一条充满挑战但也充满机遇的道路。只要你坚持不懈、不断学习和实践,就一定能够在LLM领域取得突破。希望本文提供的学习路线图能为你指明方向,助你早日掌握LLM,开启AI学习的新篇章!

m0_62110645的博客 2360

ESP32-CAM入门教程

ArduinoESP32-CAM下载模块(接上USB就能用,很方便,如果没有买就只有资金用USB-TTL了)如下图两个合在一起如下图。

qq_48778364的博客 3万+

linux内核原子操作的实现

所谓原子操作,就是“不可中断的一个或一系列操作”。硬件级的原子操作:在单处理器系统(UniProcessor)中,能够在单条指令中完成的操作都可以认为是“原子操作”,因为中断只发生在指令边缘。在多处理器结构中(Symmetric Multi-Processor)就不同了,由于系统

vivi的技术博客 2万+

Win11下Wezterm配置Powershell默认终端全攻略(含主题同步技巧)

本文详细介绍了在Windows 11系统中,如何安装和配置Wezterm终端模拟器,并将其设置为PowerShell的默认终端。内容涵盖使用Winget或手动安装Wezterm,通过修改.lua配置文件切换默认Shell,并同步Campbell主题配色以还原熟悉的PowerShell视觉体验,旨在帮助开发者打造高效、个性化的命令行工作环境。

weixin_28363123的博客 1246

操作系统的基本概念(并发与并行区别)

操作系统的基本概念(并发与并行区别)

m0_51323460的博客 2650

【Unity实战100例】Unity循环UI界面切换卡片功能

功能包括:可以设置半径,高度,速度,元素数量用户可以根据自己的实际需求接入 制作思路:创建每个元素对应的虚拟点,通过旋转管理这些虚拟点,然后把旋转信息和位置信息同步给实际的元素

纯技术流日常开发商业开发记录总结等 7720

一次请求穿过的六道关卡:微服务基础组件的通信与IO、事件驱动、负载均衡、服务路由、API网关与配置协调

微服务的稳定性往往取决于看不见的基础组件。本文跟随一次下单请求,依次穿过API网关、服务路由、负载均衡与服务通信,再沿事件分支扇出,并从控制面审视配置中心。通信层剖析握手成本、连接复用、epoll与主从Reactor、心跳判活、退避抖动、截止时间与重试预算;事件层讲解编舞与编排、事务发件箱和幂等消费;均衡与路由对比静态与动态算法、路由链、全链路灰度与同区保底;网关讨论过滤器链与限流算法;配置部分给出四类配置、长轮询与共识协调,最后归纳五道防线。文中关键数据均来自可在Java8运行的演示程序。

曾经“等你生日那天”都遥远得像未来,如今却可欢愉的挥手说“下个十年见” 172万+

操作系统和并发的爱恨纠葛(转载)

我一直没有急于写并发的原因是我参不透操作系统,如今,我已经把操作系统刷了一遍,这次试着写一些并发,看看能不能写清楚,卑微小编在线求鼓励… 我打算采取操作系统和并发同时结合讲起来的方式。 并发历史 在计算机最早期的时候,没有操作系统,执行程序只需要一个过程,那就是从头到尾依次执行。任何资源都会为这个程序服务,这必然就会存在 浪费资源 的情况。 这里说的浪费资源指的是资源空闲,没有充分使用的情况。 操作系统为我们的程序带来了 并发性,操作系统使我们的程序同时运行多个程序,一个程序就是一个进程,也就相当于同时运行

zhongqill的博客 196

韩版传奇 2 源码分析与 Unity 重制(一)服务端 TCP 状态管理

该专题将会分析 LOMCN 基于韩版传奇 2,使用 .NET 重写的传奇源码(服务端 + 客户端),分析数据交互、状态管理和客户端渲染等技术,此外笔者还会分享将客户端部分移植到 Unity 和服务端用现代编程语言重写的全过程。本文重点介绍了服务端的启动链路、网络初始化和连接处理这三个过程,并简要分析的游戏循环的实现与数据包处理,在下一篇文章中,我们会从客户端角度分析从游戏启动、登录、游戏开始和基础游戏交互的全流程。

东方猫的博客 2501

我与PHP和ASP的“爱恨纠葛”

它们各自都有着独特的优点和优势,比如PHP的开源性和丰富的社区资源,ASP与Windows平台的完美融合等。记得刚开始踏入互联网开发的圈子时,我满心期待地选择了两种流行的服务器端脚本语言——PHP和ASP,希望能够借此打开新世界的大门。这种情况下,可以说是,随着对这两种语言的深入学习和实践,我逐渐发现了它们各自的一些“小瑕疵”。虽然我与PHP和ASP的“爱恨纠葛”还没有结束,但我已经学会了如何与它们和平共处,如何在它们的缺点中寻找到解决问题的方法。我相信,在未来的日子里,我会与它们一起成长,一起进步。

2401_85777843的博客 474

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

Linux 系统进程、线程之间的爱恨纠葛...

当一个程序开始执行后,在开始执行到执行完毕退出这段时间内,它在内存中的部分就叫称作一个进程。 Linux 是一个多任务的操作系统,也就是说,在同一时间内,可以有多个进程同时执行。我们大家常用的单CPU计算机实际上在一个时间片段内只能执行一条指令。 那么Linux是如何实现多进程的同时执行的呢? 原来Linux使用了一种称为” 进程调度 “的手段: 首先,为每个进程指派一定的运行时间,这个时间通常很短,短到以毫秒为单位,然后依照某种规则,从众多的进程中挑选一个投入运行,其他进程暂时等待,当正在运行的

HUYA69的博客 250

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

轻松一下,说说进程,线程,协程之间的爱恨纠葛

1.进程:      通俗理解一个运行起来的程序或者软件叫做进程。      进程是操作系统资源分配的基本单位。      默认情况下一个进程会提供一个线程(主线程),线程依附在进程里,一个进程可创建多个线程。 2.进程和线程的对比:      进程是操作系统资源分配的基本单位,线程是cpu调度的基本单位。      线程依附于进程存在,没有进程就没有线程,进程索要资源,然后让线程执行相应...

sunchaoyiA的博客 786

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

linux时间片长度_Linux系统进程、线程之间的爱恨纠葛...

当一个程序开始执行后,在开始执行到执行完毕退出这段时间内,它在内存中的部分就叫称作一个进程。Linux 是一个多任务的操作系统,也就是说,在同一时间内,可以有多个进程同时执行。我们大家常用的单CPU计算机实际上在一个时间片段内只能执行一条指令。那么Linux是如何实现多进程的同时执行的呢?原来Linux使用了一种称为” 进程调度 “的手段,首先,为每个进程指派一定的运行时间,这个时间通常很短,短到...

weixin_39906521的博客 248

深度揭秘:微软内部爱恨纠葛

http://hainan.ifeng.com/finance/shanghui/detail_2014_10/11/2999842_0.shtml 腾讯科技讯 过去10年,身为科技史上实力最强的一股力量,微软虽然依然利润丰厚,但却逐步被市场边缘化。有人将此归咎于微软创始人比尔·盖茨(BillGates),但大多数人还是认为错在他的继任者史蒂夫·鲍尔默(Steve Ballmer)。《名

yingyi_cn的专栏 1579

从一次‘Fsync Bug’争议说起:聊聊PostgreSQL Heap表写入与Linux内核IO的那些‘爱恨纠葛’

本文深入探讨了PostgreSQL Heap表写入机制与Linux内核IO子系统的复杂互动,特别是围绕2018年‘Fsync Bug’争议展开分析。文章详细解析了Heap表的物理结构、写入流程,以及Linux内核Page Cache与数据库持久化保证之间的冲突,为高可靠存储系统设计提供了宝贵经验。

weixin_30631587的博客 143

Linux 系统进程、线程之间的爱恨纠葛

转自:https://www.toutiao.com/a6584384954765935112/?tt_from=mobile_qq&amp;utm_campaign=client_share&amp;timestamp=1533083488&amp;app=news_article&amp;utm_source=mobile_qq&amp;iid=39055545733&amp;utm_medi...

xiaoxianerqq的专栏 199

mfc保护进程不被结束_Linux系统进程、线程之间的爱恨纠葛...

当一个程序开始执行后,在开始执行到执行完毕退出这段时间内,它在内存中的部分就叫称作一个进程。Linux 是一个多任务的操作系统,也就是说,在同一时间内,可以有多个进程同时执行。我们大家常用的单CPU计算机实际上在一个时间片段内只能执行一条指令。那么Linux是如何实现多进程的同时执行的呢?原来Linux使用了一种称为” 进程调度 “的手段,首先,为每个进程指派一定的运行时间,这个时间通常很短,短到...

weixin_39825045的博客 220

linux判断改行符_Linux 系统进程、线程之间的爱恨纠葛...

当一个程序开始执行后,在开始执行到执行完毕退出这段时间内,它在内存中的部分就叫称作一个进程。Linux 是一个多任务的操作系统,也就是说,在同一时间内,可以有多个进程同时执行。我们大家常用的单CPU计算机实际上在一个时间片段内只能执行一条指令。那么Linux是如何实现多进程的同时执行的呢?原来Linux使用了一种称为” 进程调度 “的手段:首先,为每个进程指派一定的运行时间,这个时间通常很短,短到...

weixin_34742806的博客 100
上一篇: HDFS-Tiering 数据分层存储
下一篇: Netty之旅:你想要的NIO知识点,这里都有!
java架构师小芷
博客等级 码龄6年 216粉丝 519原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值