服务器就是为了响应每一个客户端请求，根据不能命令，返回不同的内容，并且每一个工作流独立，不会因为其中一个客户端请求而阻塞了其它客户端，服务器应对的办法无外乎 多线程 和多协程（多进程现在已经很少才用了 ，因为创建进程资源消耗太大），我们先来看看golang的多协程并发。

代码（golang）： 

package main
import (
 "fmt"
 "math/rand"
)
var codeArray =[4]string{"首页","西瓜视频","小视频","我的"} //申明一个全局变量 模型为：今日头发App低部导航栏请求code
func main() {
 for i:=0;i<100 ;i++ {
 cadeArrayIndex:=rand.Intn(len(codeArray)); //模拟错综复杂前端请求命令，随机获得code一个指针
 go workerChannel(cadeArrayIndex); //创建一个协程
 }
}
func workerChannel(codeArrayIndex int) (workerState bool,err string) { //根据不同命令，服务器返回响应信息 
 if(codeArrayIndex==0){
 fmt.Println("收到一个'首页'命令请求，返回:hello,world!")
 workerState=true;
 }else if codeArrayIndex==1{
 fmt.Println("收到一个'西瓜视频'命令请求，返回:西瓜在此")
 workerState=true;
 }else if codeArrayIndex==2{
 fmt.Println("收到一个'小视频'命令请求，返回:小视频还在拍摄中")
 workerState=true;
 }else if codeArrayIndex==3{
 fmt.Println("收到一个'我的'命令请求，返回:程序桃子")
 workerState=true;
 }else {
 workerState=false;
 err="未能失败命令"
 }
 return workerState,err
}

代码说明：golang语言可以同时返回多个值， java 可以通过返回数组或对象，达到同样的效果。

服务器在同时相应前端请求时候，需要对一些资源进行锁定，防止出现错误。比如，服务器分苹果案例，一个只有10个苹果，一个客户端领取一个就减少一个，当苹果发完之后，服务器在接到前端请求就返回错误。

代码（java）： 

public class testThreadWorker {
 public volatile static Integer sum=5; //苹果数量
 public volatile static ReentrantLock  lock eObject=new ReentrantLock();
 public static void main(String args[]) {
 ArrayList<Thread> ThreadArray = new ArrayList<Thread>(); //用于存放 线程 对象
 for (int i = 0; i < 10; i++) {
 Thread clientWorker1 = new TestWorkerClientThread_1(i); //创建一个线程
 ThreadArray.add(clientWorker1);
 }
 for (Thread oneWorker : ThreadArray) {
 oneWorker.start(); //启动线程
 }
 }
}
class TestWorkerClientThread_1 extends Thread{
 private int unid;
 public TestWorkerClientThread_1(int unid){
 this.unid=unid;
 }
 public void run() {
 //第一中方法：采用 synchronized 来锁定
 synchronized (testThreadWorker.sum) { //对象进行锁定
 System.out.println("获得对象锁");
 if(testThreadWorker.sum>0){
 testThreadWorker.sum--; //减少一个苹果
 System.out.println("线程["+this.unid+"]：享获得一个苹果");
 }else {
 System.out.println("线程["+this.unid+"]：遗憾，苹果没有了");
 }
 }
 //对象锁另外一种方法，通过使用ReentrantLock类来实现
 /*
 testThreadWorker.lockeObject.lock();
 System.out.println("获得对象锁");
 try {
 if (testThreadWorker.sum > 0) {
 testThreadWorker.sum--; //减少一个苹果
 System.out.println("线程[" + this.unid + "]：享获得一个苹果");
 } else {
 System.out.println("线程[" + this.unid + "]：遗憾，苹果没有了");
 }
 }finally {
 testThreadWorker.lockeObject.unlock();
 }
 */ }
}

这里采用java多线程处理，在线程中采用两种对象锁的方法来实现来保证数据安全性，至于用哪种方式因人而异，习惯就好。总之，服务器编号过程中，时时保持高度警惕：保持数据正确性和并发力。

感谢java和golang。