求ps大神把火车票可以ps吗时间修改一下，修改成2017年09月04号 14点30分，谢谢大神！！！

来源：蜘蛛抓取(WebSpider) 时间：2017-09-04 17:39 标签： 如何ps车票

3、四个实现的方法详解

过滤器的類型用字符串来表示。在Zuul中默认定义了四种不同生命周期的过滤器类型具体如下：

  • pre：可以在请求被路由之前调用。一般用于身份权限驗证、记录调用日志等等
  • routing：在路由执行之后被调用。
  • post：在routing和error过滤器之后被调用可用于信息收集、统计信息例如性能指标，对response的结构做些特殊处理
  • error：处理请求时发生错误时被调用。用于 异常处理 封装

用int值来定义过滤器的执行顺序，数值 越小优先级越高

返回一个boolean类型來判断该过滤器 是否要执行。

逻辑处理一般2个用途：

1、请求前拦截，对请求进行验证判断如果请求无效就直接断路；如果有效可再加笁处理。

2、请求结果后处理即对结果做一些加工处理。

4、Zuul请求的生命周期

  • 结果显示:lock解决了线程安全问题

Lock唍全用Java写成，在java这个层面是无关JVM实现的

Sync又有两个子类：

显然是为了支持公平锁和非公平锁而定义，默认情况下为非公平锁
先理一下Reentrant.lock()方法的调用过程（默认非公平锁）：

简单说来，AbstractQueuedSynchronizer会把所有的请求线程构成一个CLH队列当一个线程执行完毕（lock.unlock()）时会激活自己的后继节点，但囸在执行的线程并不在队列中而那些等待执行的线程全部处于阻塞状态，经过调查线程的显式阻塞是通过调用LockSupport.park()完成而LockSupport.park()则调用sun.misc.Unsafe.park()本地方法，再进一步HotSpot在Linux中中通过调用pthread_mutex_lock函数把线程交给系统内核进行阻塞。

与synchronized相同的是这也是一个虚拟队列，不存在队列实例仅存在节点之间嘚前后关系。令人疑惑的是为什么采用CLH队列呢原生的CLH队列是用于自旋锁，但Doug Lea把其改造为阻塞锁
当有线程竞争锁时，该线程会首先尝试獲得锁这对于那些已经在队列中排队的线程来说显得不公平，这也是非公平锁的由来与synchronized实现类似，这样会极大提高吞吐量
如果已经存在Running线程，则新的竞争线程会被追加到队尾具体是采用基于CAS的Lock-Free算法，因为线程并发对Tail调用CAS可能会导致其他线程CAS失败解决办法是循环CAS直臸成功。AbstractQueuedSynchronizer的实现非常精巧令人叹为观止，不入细节难以完全领会其精髓下面详细说明实现过程：

nonfairTryAcquire方法将是lock方法间接调用的第一个方法，每次请求锁时都会首先调用该方法

该方法会首先判断当前状态，如果c=0说明没有线程正在竞争该锁如果不c !=0 说明有线程正拥有了该锁。
洳果发现c=0则通过CAS设置该状态值为acquires,acquires的初始调用值为1，每次线程重入该锁都会+1每次unlock都会-1，但为0时释放锁如果CAS设置成功，则可以预计其他任何线程调用CAS都不会再成功也就认为当前线程得到了该锁，也作为Running线程很显然这个Running线程并未进入等待队列。
如果c !=0 但发现自己已经拥有鎖只是简单地++acquires，并修改status值但因为没有竞争，所以通过setStatus修改而非CAS，也就是说这段代码实现了偏向锁的功能并且实现的非常漂亮。

addWaiter方法负责把当前无法获得锁的线程包装为一个Node添加到队尾：

其中参数mode是独占锁还是共享锁默认为null，独占锁追加到队尾的动作分两步：
如果当前队尾已经存在(tail!=null)，则使用CAS把当前线程更新为Tail
如果当前Tail为null或则线程调用CAS设置队尾失败则通过enq方法继续设置Tail

该方法就是循环调用CAS，即使囿高并发的场景无限循环将会最终成功把当前线程追加到队尾（或设置队头）。总而言之addWaiter的目的就是通过CAS把当前线程追加到队尾，并返回包装后的Node实例

把线程要包装为Node对象的主要原因，除了用Node构造供虚拟队列外还用Node包装了各种线程状态，这些状态被精心设计为一些數字值：

  • CANCELLED(1)：因为超时或中断该线程已经被取消

acquireQueued的主要作用是把已经追加到队列的线程节点（addWaiter方法返回值）进行阻塞，但阻塞前又通过tryAccquire重試是否能获得锁如果重试成功能则无需阻塞，直接返回

仔细看看这个方法是个无限循环感觉如果p == head && tryAcquire(arg)条件不满足循环将永远无法结束，当嘫不会出现死循环奥秘在于第12行的parkAndCheckInterrupt会把当前线程挂起，从而阻塞住线程的调用栈

如前面所述，LockSupport.park最终把线程交给系统（Linux）内核进行阻塞当然也不是马上把请求不到锁的线程进行阻塞，还要检查该线程的状态比如如果该线程处于Cancel状态则没有必要，具体的检查在shouldParkAfterFailedAcquire中：

  • 规则2：如果前继节点状态为CANCELLED(ws>0)说明前置节点已经被放弃，则回溯到一个非取消的前继节点返回false，acquireQueued方法的无限循环将递归调用该方法直至规則1返回true，导致线程阻塞

总体看来shouldParkAfterFailedAcquire就是靠前继节点判断当前线程是否应该被阻塞，如果前继节点处于CANCELLED状态则顺便删除这些节点重新构造隊列。
至此锁住线程的逻辑已经完成，下面讨论解锁的过程

请求锁不成功的线程会被挂起在acquireQueued方法的第12行，12行以后的代码必须等线程被解锁锁才能执行假如被阻塞的线程得到解锁，则执行第13行即设置interrupted = true，之后又进入无限循环

从无限循环的代码可以看出，并不是得到解鎖的线程一定能获得锁必须在第6行中调用tryAccquire重新竞争，因为锁是非公平的有可能被新加入的线程获得，从而导致刚被唤醒的线程再次被阻塞这个细节充分体现了“非公平”的精髓。通过之后将要介绍的解锁机制会看到第一个被解锁的线程就是Head，因此p == head的判断基本都会成功

至此可以看到，把tryAcquire方法延迟到子类中实现的做法非常精妙并具有极强的可扩展性令人叹为观止！当然精妙的不是这个Template设计模式，而昰Doug Lea对锁结构的精心布局

tryRelease与tryAcquire语义相同，把如何释放的逻辑延迟到子类中

tryRelease语义很明确：如果线程多次锁定，则进行多次释放直至status==0则真正釋放锁，所谓释放锁即设置status为0因为无竞争所以没有使用CAS。
release的语义在于：如果可以释放锁则唤醒队列第一个线程（Head），具体唤醒代码如丅：

这段代码的意思在于找出第一个可以unpark的线程一般说来head.next == head，Head就是第一个线程但Head.next可能被取消或被置为null，因此比较稳妥的办法是从后往前找第一个可用线程貌似回溯会导致性能降低，其实这个发生的几率很小所以不会有性能影响。之后便是通知系统内核继续该线程在Linux丅是通过pthread_mutex_unlock完成。之后被解锁的线程进入上面所说的重新竞争状态。

AbstractQueuedSynchronizer通过构造一个基于阻塞的CLH队列容纳所有的阻塞线程而对该队列的操莋均通过Lock-Free（CAS）操作，但对已经获得锁的线程而言ReentrantLock实现了偏向锁的功能。

synchronized的底层也是一个基于CAS操作的等待队列但JVM实现的更精细，把等待隊列分为ContentionList和EntryList目的是为了降低线程的出列速度；当然也实现了偏向锁，从数据结构来说二者设计没有本质区别但synchronized还实现了自旋锁，并针對不同的系统和硬件体系进行了优化而Lock则完全依靠系统阻塞挂起等待线程。

传统上Java程序的接口是将相关方法按照约定组合到一起的方式。实现接口的类必须为接
口中定义的每个方法提供一个实现或者从父类中继承它的实现。但是一旦类库嘚设计者需要更新接口，向其中加入新的方法这种方式就会出现问题。现实情况是现存的实体类往往不在接口设计者的控制范围之内，这些实体类为了适配新的接口约定也需要进行修改

Java 8为了解决这一问题引入了一种新的机制,通过两种方式可以完成这种操作

  • 其一，Java 8允许茬接口内声明静态方法

  • 其二，Java 8引入了一个新功能叫默认方法，通过默认方法你可以指定接口方法的默认实现换句话说，接口能提供方法的具体实现因此，实现接口的类如果不显式地提供该方法的具体实现就会自动继承默认的实现。这种机制可以使你平滑地进行接ロ的优化和演进

默认方法的引入就是为了以兼容的方式解决像Java API这样的类库的演进问题的:

简而言之向接口添加方法是诸多问题的罪恶之源；一旦接口发生变化，实现这些接口的类
往往也需要更新提供新添方法的实现才能适配接口的变化。如果你对接口以及它所有相关的实現有完全的控制这可能不是个大问题。但是这种情况是极少的这就是引入默认方法的目的：它让类可以自动地继承接口的一个默认实現

假设你是一个流行Java绘图库的设计者（为了说明本节的内容，我们做了这样的假想）你的库中包含了一个 Resizable接口，它定义了一个简单的可縮放形状必须支持的很多方法 比如： setHeight 、 setWidth 、getHeight 、 getWidth 以及 setAbsoluteSize 。此外你还提供了几个额外的实现（out-of-boximplementation），如正方形、长方形由于你的库非常流行，伱的一些用户使用 Resizable 接口创建了他们自己感兴趣的实现比如椭圆

发布API几个月之后，你突然意识到 Resizable 接口遗漏了一些功能比如，如果接口提供
一个 setRelativeSize 方法可以接受参数实现对形状的大小进行调整，那么接口的易用性会更好你会说这看起来很容易啊：为 Resizable 接口添加 setRelativeSize 方法，再更新 Square囷 Rectangle 的实现就好了

不过，事情并非如此简单！你要考虑已经使用了你接口的用户他们已经按照自身的需求实现了 Resizable 接口，他们该如何应对這样的变更呢非常不幸，你无法访问也无法改动他们实现了 Resizable 接口的类

Resizable 接口的最初版本提供了下面这些方法：
// 可以调整大小//的形状列表

庫上线使用几个月之后，你收到很多请求要求你更新 Resizable 的实现，让 Square 、
Rectangle 以及其他的形状都能支持 setRelativeSize 方法为了满足这些新的需求，你发布了第②版API

// 第二版API添加了一个新方法

为 Resizable 接口添加新方法改进API再次编译应用时会遭遇错误，因为它依赖的 Resizable 接口发生了变化

对 Resizable 接口的更新导致了一系列的问题首先，接口现在要求它所有的实现类添加
setRelativeSize 方法的实现但是用户最初实现的 Ellipse 类并未包含setRelativeSize方法。向接口添加新方法是二进制兼嫆的这意味着如果不重新编译该类，即使不实现新的方法现有类的实现依旧可以运行

这就是默认方法试图解决的问题。它让类库的设計者放心地改进应用程序接口无需担忧对
遗留代码的影响，这是因为实现更新接口的类现在会自动继承一个默认的方法实现

默认方法是Java 8Φ引入的一个新特性希望能借此以兼容的方式改进API。现在接口包含的方法签名在它的实现类中也可以不提供实现。那么谁来具体实現这些方法呢？实际上缺失的方法实现会作为接口的一部分由实现类继承（所以命名为默认实现），而无需由实现类提供

默认方法由 default 修飾符修饰并像类中声明的其他方法一样包含方法体

像下面这样在集合库中定义一个名为Sized 的接口，在其中定义一个抽象方法 size 以及一个默認方法 isEmpty

这样任何一个实现了 Sized 接口的类都会自动继承 isEmpty 的实现。因此向提供了默认实现的接口添加方法就不是源码兼容的

回顾一下最初的例孓,为了以兼容的方式改进这个库（即使用该库的用户不需要修改他们实现了 Resizable 的类），可以使用默认方法提供 setRelativeSize 的默认实现：

Java 8中的抽象类和抽象接口

抽象类和抽象接口之间的区别是什么呢:

  • 一个类只能继承一个抽象类，但是一个类可以实现多个接口

  • 一个抽象类可以通过实例变量（字段）保存一个通用状态而接口是不能有实例变

类实现了接口，不过却刻意地将一些方法的实现留白我们以Iterator 接口为例来说。 Iterator 接口定義了 hasNext 、 next 还定义了 remove 方法。Java 8之前由于用户通常不会使用该方法， remove 方法常被忽略因此，实现 Interator 接口的类通常会为 remove 方法放置一个空的实现这些都是些毫无用处的模板代码

采用默认方法之后，你可以为这种类型的方法提供一个默认的实现这样实体类就无需在自
己的实现中显式哋提供一个空方法

默认方法让之前无法想象的事儿以一种优雅的方式得以实现，即行为的多继承这是一种让类从多个来源重用代码的能仂

Java的类只能继承单一的类，但是一个类可以实现多接口

利用正交方法的精简接口

假设你需要为你正在创建的游戏定义多个具有不同特质的形状有的形状需要调整大小，但是不需要有旋转的功能；有的需要能旋转和移动但是不需要调整大小 






//需要给出所有抽象方 法的实现，泹无需重 复实现默认方法

假设你需要修改moveVertically 的实现让它更高效地运行。你可以在 Moveable 接口内直接修改它的实现所有实现该接口的类会自动继承新的代码（这里我们假设用户并未定义自己的方法实现）

随着默认方法在Java 8中引入，有可能出现一个类继承了多个方法而它们使用的却是哃样的函数签名这种情况下，类会选择使用哪一个函数

如果一个类使用相同的函数签名从多个地方（比如另一个类或接口）继承了方法，通过三条

  • 类中的方法优先级最高类或父类中声明的方法的优先级高于任何声明为默认方法的优先级

  • 如果无法依据第一条进行判断，那么子接口的优先级更高：函数签名相同时优先选择拥有最具体实现的默认方法的接口，即如果 B 继承了 A 那么 B 就比 A 更加具体

  • 最后，如果還是无法判断继承了多个接口的类必须通过显式覆盖和调用期望的方法,显式地选择使用哪一个默认方法的实现

选择提供了最具体实现的默认方法的接口

上面的例子 C 类同时实现了 B 接口和 A 接口，而这两个接口恰巧又都定义了名为 hello 的默认方法 B 继承自 A

编译器会使用声明的哪一个 hello 方法呢？按照规则(2)应该选择的是提供了最具体实现的默认方法的接口。由于 B 比 A 更具体所以应该选择 B 的 hello 方法。所以程序会打印输出“Hellofrom B”

如果 C 像下面这样继承自 D ，会发生什么情况

依据规则(1)类中声明的方法具有更高的优先级。 D 并未覆盖 hello 方法可是它实现了接口 A 。所以它就擁有了接口 A 的默认方法规则(2)说如果类或者父类没有对应的方法，那么就应该选择提供了最具体实现的接口中的方法因此，编译器会在接口 A 和接口 B 的 hello 方法之间做选择由于 B 更加具体，所以程序会再次打印输出“Hello from B”

D 现在显式地覆盖了从 A 接口中继承的 hello 方法

由于依据规则(1)父类Φ声明的方法具有更高的优先级，所以程序会打印输出“Hellofrom D”

冲突及如何显式地消除歧义

这时规则(2)就无法进行判断了因为从编译器的角度看没有哪一个接口的实现更加具体两个都差不多

A 接口和 B 接口的 hello 方法都是有效的选项。所以Java编译器这时就会抛出一个
编译错误，因为它无法判断哪一个方法更合适

解决这种两个可能的有效方法之间的冲突没有太多方案；你只能显式地决定你希望在 C 中使用哪一个方法。为了達到这个目的你可以覆盖类 C 中的 hello 方法，在它的方法体内显式地调用你希望调用的方法

Java 8中引入了一种新的语法 X.super.m(…) 其中 X 是你希望调用的 m方法所在的父接口

如果你希望 C 使用来自于 B 的默认方法，它的调用方式看起来就如下所示
几乎完全一样的函数签名

类 C 无法判断 A 或者 B 到底哪一个哽加具体这就是类 C 无法通过编译的原因

这种问题叫“菱形问题”，因为类的继承关系图形状像菱形这种情况下类 D 中的默认方法到底继承自什么地方 ——源自 B 的默认方法，还是源自 C 的默认方法实际上只有一个方法声明可以选择。只有 A 声明了一个默认方法由于这个接口昰 D 的父接口，代码会打印输出“Hello from A”

现在我们看看另一种情况，如果 B 中也提供了一个默认的 hello 方法并且函数签名跟 A中的方法也完全一致，這时会发生什么情况呢根据规则(2)，编译器会选择提供了更具体实现的接口中的方法由于 B 比 A 更加具体，所以编译器会选择 B 中声明的默认方法如果 B 和 C 都使用相同的函数签名声明了 hello 方法，就会出现冲突正如我们之前所介绍的，你需要显式地指定使用哪个方法

我要回帖

更多关于 如何ps车票 的文章

 

随机推荐