java并发编程
1.常用类介绍
Semaphore
Semaphore 类是一个计数信号量，必须由获取它的线程释放， 通常用于限制可以访问某些资源（物理或逻辑的）线程数目。
Semaphore包含三种操作
初始化
获取acquire()
释放 release()
当信号量大于0的时候semaphore会响应线程请求，释放资源，当信号量等于0时即阻塞线程。
Semaphore有两种模式，公平模式和非公平模式
公平模式遵循FIFO，按照acquire的顺序来分配资源，非公平则为抢占式的。
Semaphore的类图如下，使用内部类Sync继承AbstractQueuedSynchronizer实现
Serializable <|-- Semaphore : implements
Semaphore *-- Sync
AbstractQueuedSynchronizer <|-- Sync
Sync <|-- NonfairSync
Sync <|-- FairSync
class Semaphore{
Semaphore : -Sync sync
Semaphore: +Semaphore(int permits)
Semaphore: +Semaphore(int permits, boolean fair)
Semaphore: +acquire()
Semaphore: +acquire(int permits)
Semaphore: +release()
Semaphore: +release(int permits)
}
class Sync{
...
}
class NonfairSync{
...
}
class FairSync{
...
}
2.名词解释
2.1 线程安全
如果一个进程中有多个线程在同时运行同一段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
2.2 可重入锁和不可重入锁
可重入锁，指的是以线程为单位，当一个线程获取对象锁之后，这个线程可以再次获取本对象上的锁，而其他的线程是不可以的。意义之一在于防止死锁*。
实现原理：每个锁关联一个请求计数器和占有他的线程，当计数为0时，锁未被占用，当线程请求占用锁时，jvm标记锁的占有者，且将请求计数器置为1。同一线程再次请求锁，计数器递增。每当占用线程退出同步块，计数器递减，知道计数器为0，锁被释放。
*：此处的防止死锁实例
public class demo {
public synchronized void methodA(){
methodB();
}
public synchronized void methodB(){
//todo do something
}
}
当一个线程调用demo类对象的methodA同步方法，如果demo类对象锁未被占有，该线程占有锁，此时调用methodA会触发methodB的调用，此时需要再获取一次锁，只有可重入可以实现。
如下，子类覆写了父类的synchonized方法，然后调用父类中的方法，此时如果没有可重入的锁，那么这段代码将产生死锁
public class Demo {
int i = 10;
public synchronized void parent() {
i--;
System.out.println("parent:" + i);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
static class Demo2 extends Demo {
@Override
public synchronized void parent() {
try {
while (i > 1) {
i--;
System.out.println("child:" + i);
Thread.sleep(100);
super.parent();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
Demo2 demo2 = new Demo2();
demo2.parent();
}
});
thread.start();
}
}
synchronized和ReentrantLock都是可重入锁