什么是架构？

架构就相当于我们要盖一栋楼时的框架。系统架构就类似于工程的结构。



一、传统架构

 

用传统的架构，1000并发量需要2太服务器做tomca集群 

  

但是由于系统用的人越来越多，并发量越来越大待到并发量为10000时，需要20台服务器做tomcat集群。当tomcat集群中节点数量增加，服务器能量先增加后下降。所以集群中节点的数量不能太多，一般也就5个左右。难以实现高数据量的并发，5台服务器难以正常工作。 

什么是集群？ 

集群就是多个服务器做的是同一件事、运行同一个工程。也就是说同一个工程部署到多台服务器上。

二、分布式架构

能用硬件解决的问题就不用软件解决、硬件解决不了就用软件解决。 

如何用软件解决？ 

当并发数高时，需要按照功能吧系统拆分，拆分成独立的功能。单独为某一个节点添加服务器。需要系统之间配合才能完成整个业务逻辑，叫做分布式。 

分布式架构：把系统安装模块拆分成多个子系统，多个子系统相互协作才能完成业务流程，系统之间需要进行通信。 

  

分布式架构优点：


把模块拆分，使用接口通信，降低模块之间的耦合度。
把项目拆分成若干个子项目，不同的软对负责不同的子项目。
增加功能时，只需要增加一个子项目，调用其他系统的接口就可以。
可以灵活的进行分布式部署。


分布式的缺点：


系统之间交互需要使用远程通信，接口开发增加工作量。
各个模块有一些通用的业务逻辑无法使用。


三、基于SOA的架构

为了解决分布式的架构的缺点，我们可以使用基于SOA的架构。SOA：Service Oriented Architecture 面向服务架构。也就是把工程拆分成服务层、表现层两个工程。服务层中包含业务逻辑，只需要对外提供服务即可。表现层只需要处理和页面的交互，业务逻辑都是调用服务层的服务来实现。 

  



四、小编做的网上商城项目的系统架构如下：




dubbo实现系统之间的通信
用MyCat实现数据库集群
redis实现缓存
solr服务用于维护索引库
消息队列MQ用于实现系统之间解耦用的。

本篇帖子继续上篇。有兴趣可以点击链接进行查看以前写过的文章。

【系统架构设计师】第一章：操作系统（1.2.2）

参考教材：

《系统架构设计师考试全程指导（第二版）》

《系统架构设计师教程》

1.2.2 信号量与pv操作
pv操作指的是两个：p操作和v操作。
有时候我们的进程在工作的时候，需要同时配合来干多件事情。比如，我们规定一个进程用来写入数据，另一个进程用来读取数据。
很显然，这连个进程是不能互相干扰的，因此我们就需要提前对系统进行一下告知：使用这些资源的权力我先占用了，其他人不要进来。
系统得知以后，如果有其他进程要写入数据或者读取数据，就会被系统安排成等待态。

等我们的进程使用资源完成以后，在告知系统，其他进程可以使用这些资源。
告知系统不要让其他进程操作这片内存的操作，就是p操作。

告知系统此进程已使用内存完毕，就是v操作。
我们因此可以得出使用pv操作的目的：

为了解决不同进程的互斥（都需要共享独占性资源时）和同步（完成异步的两个进程的协作）问题，需要使用pv操作。
想想看，如果是你，你会怎么用代码的方式解决呢？
我这里用的是c语言的方式。
首先，我们要有一个变量s。

在pv操作中被称为信号量，表现形式是一个整数s和一个队列。你可以姑且认为这是个整形变量。

当s>=0，代表某个资源的可用数；

当s<0，其绝对值代表阻塞队列中等待该资源的进程数。
其次是p操作。

根据我们开始所说，p操作就是告知系统这片资源已经被使用，因此只要在本来的资源数上减1即可。不过我们要考虑一种情况，就是当可用资源为0或负数的时候，那么就要让程序进入等待。

所以我们可以得出：
if((s=s-1)<0){
	printf("执行p操作的进程进入等待");
}

最后是v操作。

这个同理，减一换成加一即可。
if((s=s+1)<=0){
	printf("从阻塞队列中唤醒一个其他处于阻塞态的进程");
}

互斥实例
说了这么多，先来个实例，比如，对两个进程进行互斥控制。

我这里给了两个程序。

这两个程序是同时运行的，并且变量s是共享的，且初值为1。为了省事，这里我就简写了，省去了main之类的格式。
我对p和v进行了一些小的修改，这样更符合c语言的标准。
p：
if((s=s-1)<0){
	printf("执行p操作的进程进入等待");
	return 0;
}
else{
	return 1;
}

v：
if((s=s+1)<=0){
	printf("从阻塞队列中唤醒一个其他处于阻塞态的进程");
	return 0;
}
else{
	return 1;
}

进程A
while(1){
	if(p(s)){
		printf("操作一下");
	}
	v(s)
}

进程B
while(1){
	if(p(s)){
		printf("操作二下");
	}
	v(s)
}

仔细分析。

我们这里先说明一个前提，即使我们的程序同时运行，由于某些特殊的原因，是不可能真正的同时启动的，稍微会有一些误差，比如某个进程会晚0.00000000001秒。我们这里就假设A进程是比较快的那个。
第一次循环时，A先执行了p，然后s自减，输出了“操作一下”。
此可我们的B启动，也执行了p，注意此可A还没有执行V，也就是说s还没有自增。由于我们的s已经从1自减到了0，再次执行，s=-1，if不成立，什么都不输出。
当A执行完成v操作以后，我们的B已经到了第二轮，此可if成立，所以输出了“操作二下”。
以此类推，你会发现，A和B永远都时一个执行，另一个就跳过。这样，我们就使用pv操作对进程的互斥。
同步实例
同步也是类似的操作。直接上例程。不过这次比较特殊，需要用到两个信号量，s1=1和s2=1。

p：
if((s=s-1)<0){
	printf("执行p操作的进程进入等待");
	return 0;
}
else{
	return 1;
}

v：
if((s=s+1)<=0){
	printf("从阻塞队列中唤醒一个其他处于阻塞态的进程");
	return 0;
}
else{
	return 1;
}

进程A
while(1){
	if(p(s1)){
		printf("操作一下");
	}
	v(s2)
}

进程B
while(1){
	if(p(s2)){
		printf("操作二下");
	}
	v(s1)
}

仔细分析。
这个其实A和B无论是否同时运行都行。
假设我们的A先运行，执行第一遍的时候没什么问题，正常输出“操作一下”。
但是当执行第二遍的时候，你会发现，A不会输出了，因为我们的s1从开始循环第二遍的0变成了-1，所以此刻if时不成立的。
而当我们运行B的时候，B执行v(s2)，最终将p增到1，A才会继续走。
这样，我们就完成了进程之间的同步。

本篇内容主要介绍的是pv操作的一些细节。

有兴趣的可以加我qq：1392969921

下一节已更新。

【系统架构设计师】第一章：操作系统（1.2.3）死锁问题

上节链接

【系统架构设计师】第一章：操作系统（1.2.3）死锁问题

这一节其实想水一章来着。。。

因为书上的东西实在是太少，管程就提到了一点，我也不好写太多。

不过细想一下，还是决定写点吧。

1.2.3 管程
书上给的东西太少，而且写的很难懂，所以这里我就先不引用书上的东西了，直接写一些自己的理解了。

本文参考链接：

https://blog.csdn.net/zy702432103/article/details/84259683

https://blog.csdn.net/qq_32534441/article/details/95231632

https://www.zhihu.com/question/30641734

http://c.biancheng.net/view/1234.html
概念引入
管程也是用于进程之中的，和信号量以及pv操作起到类似的作用。然而，我们之前提到过，pv操作需要成对出现，因为进程使用完资源以后需要告诉系统。

这种操作其实是不安全的，因为一旦我们的pv操作没有成对出现，系统就会出现问题。因此，为了解决这些问题，就产生了管程的概念。



我们可以很形象的将使用管程的进程这样想：

当一个进程使用管程的时候，那么，它会将一些用到的变量和操作进行封装，像管道一样。这样，我们就可以保证，整个操作是完整的，不会像pv操作中忘记p或v就会使系统产生问题。
由于使用管程的进程是被封装的，所以其他进程不能进行使用，必须等待管程使用完毕才能进行使用。

细节的一些东西
我们使用管程是为了更安全，而不是彻底的封闭，因此，在一些编程语言中提供了几个方法来控制管程中进程的状态。这个我就直接截图了，书上是没有详细讲这个的。



这几个方法实现了我们之前使用pv操作中挂起，同步等。由于管程的特殊性，所以引入了enter，leave等操作。

剩下的就没什么好介绍的了，本来书上说的也不深，就当我水了一贴。

操作系统五大功能之一的处理器管理的内容已经写完了。后面会继续写其他4个。

下章链接

【系统架构设计师】第一章：操作系统（1.2.4）文件管理

有兴趣加我QQ：1392969921

本篇帖子继续上篇。有兴趣可以点击链接进行查看以前写过的文章。

【系统架构设计师】第一章：操作系统（1.1.1—1.1.2）

参考教材：

《系统架构设计师考试全程指导（第二版）》

《系统架构设计师教程》

1.2 处理器管理
在单用户多任务的操作系统中，或者多用户多任务的操作系统中，系统同时运行多个程序，这些程序的并行运行势必形成对系统资源的竞争使用。因此，操作系统必须能够处理和管理这种并行运行的程序，使之对资源的使用按照良性的顺序进行。
1.2.1 进程的状态
1.定义及分类
首先我们要搞清楚三个东西的区别：程序，进程，线程。
先想想看，什么是程序？

我们常说的编程，这个“程”字指的就是我们的程序。很明显，你写的是代码，而不是手写的运行起来以后的那个程序。那个是经过编译你的代码而得到的东西。

因此，我们可以得出结论：程序就是我们的代码，是一个静态的概念。
其次就是进程。

当我们编译好程序以后，运行的那个软件就是我们的进程。这个也很好理解，对吧？

当然，进程也不仅仅有这些，同时还有比如告诉系统，应该分配多少内存之类的信息。

因此，我们的结论是：

从动态的角度看，进程就计算机状态的一个有序集合。
从静态的角度看，进程由程序，数据，进程控制块（PCB）组成。

最后要说的是线程。

这个东西是书上没有的，不过我突然想到了，就临时补充了上来。所谓线程，其实就是一个相对的概念。

比如我们在写一个下载的程序的时候，我们就需要用到线程，并且将下载放到后台来进行。不然的话，我们的程序就会一直在下载中，导致用户在使用的时候，一旦使用下载功能，就会卡死在主界面。

这个系统用来执行我们下载而分配的到后台去运行的资源，就是我们的线程。所以，我们可以这样说：

线程也是一个被用来处理任务的资源，但是由于是我们进程所创建的，因此就叫做线程。

我们甚至可以将我们的主程序理解成一个我们电脑所产生的线程。
行了，关于进程的介绍就先说这么多吧。剩下其实还有更深的概念，比如守护线程之类的东西就先不提了。
2.进程的状态模型与转换
1.三态模型

我们知道了进程的概念以后，接下来需要知道的是进程的每种状态该如何去描述。

拿c语言来举例吧。

比如，我们写好一个程序，这个程序会读取我们输入的数字加一然后显示出来。我们可以很明显的看到两个过程：

程序自动运行的过程，比如读取我们输入的数字然后加一并且显示出来。这些是没有经过我们人工干预的过程。
程序暂停，等待我们输入所需要的数字的过程。

1和2其实就分别对应了我们进程中的两个过程：运行，等待

另外还有一个我们看不到的过程，就是 就绪 这个过程。

这个也很好理解吧？有时候你后台跑个lol+赛博朋克，系统的资源不够用了，想跑你自己写的这个程序，就得等有空闲的资源的时候才会去跑。

然后这时候你把这两个游戏关了，那么你的程序就有资源了。此可，你的程序就叫做就绪态。
我们可以很容易的写出三种形态的转换。



2.五态模型
我们其实还需要考虑一些极端的情况：如果我们同时开了1000个lol和1000个赛博朋克，那么此可你写的程序处于什么状态？等待态还是就绪态？
很显然，都不是。因为如此大的系统开销，电脑为了防止cpu被耗尽，就必须将一些程序挂起，等到有资源的时候在去唤醒。
此刻你的程序正处于磁盘的镜像中，因此就不参与进程的调度了。你可以认为你的程序从“活”变成了“死”。

这里给出了进程挂起的原因，和书上写的不太一样，不过大体相似，但是建议还是去看一下书。



为了方便区分“活”的等待态以及就绪态，和“死”的状态，我们先将三态模型中的等待态和就绪态的名字改为活跃阻塞态和活跃就绪态。

此可，我们的三态模型变成了：

活跃阻塞态，活跃就绪态，运行态
那我们想想当进程被挂起以后会有怎样的状态呢？
我们就要看被挂起的时候是什么状态。比如我们在活跃阻塞态的时候将进程挂起，那么被挂起的进程就叫做静止阻塞态。

如果在被挂起的时候是活跃就绪态，那么被挂起的进程就叫做静止就绪态。
于是，现在就有了我们新的五态模型：

活跃就绪态，活跃等待态，运行态，静止阻塞态，静止就绪态
我们依旧可以将五种状态的变化列出来。懒得写了，直接看别人写好的吧。

https://www.orzzone.com/process-state-transition.html

这一小节写了进程的简介以及三态模型和五态模型。下一节会讲信号量与pv操作。

下一节已更新。

【系统架构设计师】第一章：操作系统（1.2.2） 信号量与pv操作（一）

有兴趣的可以加我qq：1392969921