list
- synchronized
- volatile
- ReentrantLock/ReentrantReadWriteLock
- CountdownLatch
- CyclicBarrier
- Semaphore
synchronized
系统关键字,可以修饰方法,也可以对Object使用。
public synchronized void fun(){}
public synchronized void fun(){
Object lock = new Object();
synchronized (lock) {
// do something
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
在同步代码块中可以使用wait/notify/notifyAll,但是必须使用与synchronized相同的对象。
volatile
关键字,修饰变量,作用:
- 保证修改对所有线程可见
- 禁止进行指令重排序,写操作 happens-before 读操作
实现原理:
借助于内存屏障(也成内存栅栏)
- 它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置,也不会把前面的指令排到内存屏障的后面;即在执行到内存屏障这句指令时,在它前面的操作已经全部完成;
- 它会强制将对缓存的修改操作立即写入主存;
- 如果是写操作,它会导致其他CPU中对应的缓存行无效。
ReentrantLock/ReentrantReadWriteLock
Lock相比synchronized提供了更丰富的操作,可以提供多个Condition。
以下内容摘自:https://blog.csdn.net/u011479540/article/details/52013187
public interface Lock {
void lock();//加锁
void lockInterruptibly() throws InterruptedException;//加可中断锁
boolean tryLock();//加锁成功返回true,失败返回false
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;//加锁成功返回true,失败等待一段时间后若仍无法加锁则返回false,可响应中断
void unlock();//解锁
Condition newCondition(); //返回一个Condition,利用它可以如和Synchronizd配合使用的wait()和notify()一样对线程阻塞和唤醒,不同的是一个lock可以有多个condition.
}
public interface Condition {
void await() throws InterruptedException;//类似于wait(),可以响应中断
void awaitUninterruptibly();//不响应中断的等待
long awaitNanos(long nanosTimeout) throws InterruptedException;//等待指定时间(单位是纳秒),在接到信号、被中断或到达指定等待时间之前一直处于等待状态。方法返回被唤醒后的剩余等待时间,若返回值小于等于0则代表此次等待超时。
boolean await(long time, TimeUnit unit) throws InterruptedException;//指定时间到达前结束等待返回true,否则返回false
boolean awaitUntil(Date deadline) throws InterruptedException;//指定日期到达前被唤醒返回true,否则返回false
void signal();//唤醒一个等待中的线程,类似于notify()
void signalAll();//唤醒所有等待中的线程,类似于notifyAll()
}
ReentrantLock 和 ReentrantWriteReadLock 是 Lock的两个实现,在竞争剧烈的时候ReentrantLock表现更好。
ReentrantWriteReadLock提供了读锁和写锁。
- 读锁可以有多把,但是和写锁互斥
- 写锁和其他所有锁互斥
CountDownLatch
CountDownLatch、CyclicBarrier和 Semaphore 摘自:
https://www.cnblogs.com/dolphin0520/p/3920397.html
利用它可以实现类似计数器的功能
public CountDownLatch(int count) { }; //参数count为计数值
public void await() throws InterruptedException { }; //调用await()方法的线程会被挂起,它会等待直到count值为0才继续执行
public boolean await(long timeout, TimeUnit unit) throws InterruptedException { }; //和await()类似,只不过等待一定的时间后count值还没变为0的话就会继续执行
public void countDown() { }; //将count值减1
CyclicBarrier
通过它可以实现让一组线程等待至某个状态之后再全部同时执行。
public CyclicBarrier(int parties, Runnable barrierAction) {}
public CyclicBarrier(int parties) {}
public int await() throws InterruptedException, BrokenBarrierException { };
public int await(long timeout, TimeUnit unit)throws InterruptedException,BrokenBarrierException,TimeoutException { };
初始化parties之后,直接调用await处于栅栏,开始等待,到parties个线程处于栅栏,或者超时,才可以继续下面的操作。barrierAction会在等待的线程中选择一个执行。
Semaphore
Semaphore可以控同时访问的线程个数,通过 acquire() 获取一个许可,如果没有就等待,而 release() 释放一个许可。
public Semaphore(int permits) { //参数permits表示许可数目,即同时可以允许多少线程进行访问
sync = new NonfairSync(permits);
}
public Semaphore(int permits, boolean fair) { //这个多了一个参数fair表示是否是公平的,即等待时间越久的越先获取许可
sync = (fair)? new FairSync(permits) : new NonfairSync(permits);
}
public void acquire() throws InterruptedException { } //获取一个许可
public void acquire(int permits) throws InterruptedException { } //获取permits个许可
public void release() { } //释放一个许可
public void release(int permits) { } //释放permits个许可
public boolean tryAcquire() { }; //尝试获取一个许可,若获取成功,则立即返回true,若获取失败,则立即返回false
public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException { }; //尝试获取一个许可,若在指定的时间内获取成功,则立即返回true,否则则立即返回false
public boolean tryAcquire(int permits) { }; //尝试获取permits个许可,若获取成功,则立即返回true,若获取失败,则立即返回false
public boolean tryAcquire(int permits, long timeout, TimeUnit unit) throws InterruptedException { }; //尝试获取permits个许可,若在指定的时间内获取成功,则立即返回true,否则则立即返回false
下面对上面说的三个辅助类进行一个总结:
1)CountDownLatch和CyclicBarrier都能够实现线程之间的等待,只不过它们侧重点不同:
CountDownLatch一般用于某个线程A等待若干个其他线程执行完任务之后,它才执行;
而CyclicBarrier一般用于一组线程互相等待至某个状态,然后这一组线程再同时执行;
另外,CountDownLatch是不能够重用的,而CyclicBarrier是可以重用的。
2)Semaphore其实和锁有点类似,它一般用于控制对某组资源的访问权限。