ARTS第十一周
ARTS是什么？
Algorithm：每周至少做一个leetcode的算法题；
Review：阅读并点评至少一篇英文技术文章；
Tip/Techni：学习至少一个技术技巧；
Share：分享一篇有观点和思考的技术文章。
Algorithm
题目：232. Implement Queue using Stacks
解题思路
题目要求用栈实现队列的功能。对比栈和队列的特性差异：栈的特性是先进后出，队列是先进先出。我们要用先进后出的容器实现先进先出的效果，考虑使用两个先进后出的容器来实现这种效果，相当于负负得正的效果。
代码
class MyQueue {
//输入栈
Stack<Integer> input;
//输出栈
Stack<Integer> output;
/** Initialize your data structure here. */
public MyQueue() {
input = new Stack();
output = new Stack();
}
/** Push element x to the back of queue. */
public void push(int x) {
input.push(x);
}
/** Removes the element from in front of queue and returns that element. */
public int pop() {
if (output.empty()) {
while (!input.empty()) {
output.push(input.pop());
}
}
return output.pop();
}
/** Get the front element. */
public int peek() {
if (output.empty()) {
while (!input.empty()) {
output.push(input.pop());
}
}
return output.peek();
}
/** Returns whether the queue is empty. */
public boolean empty() {
return input.empty() && output.empty();
}
}
Review
信号量Semaphore
计数信号量，概念上讲，一个信号量保持了一组许可。每个acquire方法都会阻塞直到拿到一个许可。每个release方法增加一个许可，可能会释放一个阻塞的acquirer.然而，没有实际的许可对象，Semaphore只是保持一个可用的计数并采取相应的行为。
信号量经常被用来限制线程数，而不是访问某些资源。比如下面的类，用了一个信号量控制访问池.
class Pool {
private static final int MAX_AVAILABLE = 100;
private final Semaphore available = new Semaphore(MAX_AVAILABLE, true);
public Object getItem() throws InterruptedException {
available.acquire();
return getNextAvailableItem();
}
public void putItem(Object x) {
if (markAsUnused(x))
available.release();
}
// Not a particularly efficient data structure; just for demo
protected Object[] items = ... whatever kinds of items being managed
protected boolean[] used = new boolean[MAX_AVAILABLE];
protected synchronized Object getNextAvailableItem() {
for (int i = 0; i < MAX_AVAILABLE; ++i) {
if (!used[i]) {
used[i] = true;
return items[i];
}
}
return null; // not reached
}
protected synchronized boolean markAsUnused(Object item) {
for (int i = 0; i < MAX_AVAILABLE; ++i) {
if (item == items[i]) {
if (used[i]) {
used[i] = false;
return true;
} else
return false;
}
}
return false;
}
}
在获取一项信号量之前每个线程必须从信号量获得许可，保证有一项可用的信号量。当线程用完这项信号量，许可将返回给信号量，允许另一个线程去获得这项信号量。注意，调用acquire方法的时候不会保持同步锁定，因为这会阻止信号量返回池中。信号量封装了限制访问池所需的同步，与维护池本身一致性所需的任何同步分开。
信号量初始化为1，并且使用它至多只有一个许可，能被用来做互斥锁。这通常被称为二进制信号量，因为它只有两种状态：1个可用的许可；0个可用的许可。当用这种方式，这个二进制信号量有一个属性：锁能被非拥有者释放，这能被用在一些特殊场景，比如死锁恢复。
这个类的构造函数可用接受一个fairness参数。当设置为false的时候，此类不保证线程获得许可的顺序。事实上，允许barging意味着，调用acquire方法的线程能先于已经在等待的线程被分配到一个许可，逻辑上，这个新线程排到等待线程队列的开头。当fairness设置成true，信号量保证调用acquire方法的线程按照他们的调用顺序获得许可。注意，FIFO顺序一定适用于这些方法的特定内部执行点。所以，一个线程可以在另一个线程之前调用acquire方法，但是在另一个线程之后到达排序点，并且从方法返回时类似。另外注意，不定时的tryAcquire方法不遵守公平性设置，但会接受任何可用的许可。
一般来说，信号量用来控制资源访问的时候应该被初始化为fair，为了确保访问某个资源的时候没有线程会饿死。当信号量用于其他类型的并发控制，非公平锁的吞吐量优势往往超过公平考量。
Tip/Techni
volatile关键字
作用：在多线程环境下，保证了共享变量的“可见性”。
原理：
1.将当前处理器缓存行数据写回到系统内存。
2.使其他cpu缓存了该内存地址的数据失效。
synchronized
作用：为修饰的对象加上锁，实现同步效果。
修饰对象：
1.普通同步方法：锁的是当前实例对象。
2.静态同步方法：锁的是当前类的class对象。
3.同步方法块：锁的是Synchronized括号里配置的对象。
原理：基于进入和退出monitor对象来实现方法同步和代码块同步。
Share
最近一周主要在学习java高并发，也找了一堆资料，在此分享关于一篇java高并发学习路线的文章Java并发编程学习路线，作者根据自己学习java高并发的经历总结了一条学习路线，我看完之后感觉学习体验和我类似，文中提到的基本书都是学习java高并发比较经典的，推荐阅读，还有更重要的是，阅读的时候一定要把握书的脉络，这个个人感觉非常重要，否则学到的都是一个个的点，不成体系，很容易遗忘。另一点就是光看书是不够的，还要配合实践才能理解的深，目前我也还在学习这块知识中，共勉。