CAS复习
是一种乐观锁,使用CPU的原语实现
cas(期望值,更新值)
例子:
m = 0;
m++;
expected = read m;
cas(0,1){
for(;;)如果当前值==0 则m=1
}
AtomicXX类
package character02;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
/**
* 解决同样问题的更高效的方法,使用AtomXX类
* AtomXX类本身方法都是原子性的,但不能保证多个方法连续调用是原子性
* @author laimouren
*/
public class CAS01 {
AtomicInteger count = new AtomicInteger(0);
void m(){
for (int i = 0; i < 10000; i++) {
count.incrementAndGet(); //count++
}
}
public static void main(String[] args) {
CAS01 c = new CAS01();
List<Thread> threads = new ArrayList<>();
for (int i = 0; i < 10; i++) {
threads.add(new Thread(c::m,"thread-"+i));
}
threads.forEach((o)->o.start());
threads.forEach((o)->{
try{
o.join();
}catch (InterruptedException e){
e.printStackTrace();
}
});
System.out.println(c.count);
}
}
性能比较
测试代码
package character03;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.LongAdder;
/**
* @Author laimouren
* @Date 2021/12/21 8:56
*/
public class AtomicVsSyncVsLongAdder {
static long count2 = 0L;
static AtomicLong count1 = new AtomicLong(0L);
static LongAdder count3 = new LongAdder();
public static void main(String[] args) throws Exception {
Thread[] threads = new Thread[10000];
for (int i = 0; i < threads.length; i++) {
threads[i] = new Thread(()->{
for (int k = 0;k < 10000;k++){
count1.incrementAndGet();
}
});
}
long start = System.currentTimeMillis();
for (Thread t:threads) {
t.start();
}
for (Thread t:threads) {
t.join();
}
long end = System.currentTimeMillis();
System.out.println("Atomic:"+count1.get()+"time"+(end - start));
//-------------
Object lock = new Object();
for (int i = 0; i < threads.length; i++) {
threads[i] = new Thread(()->{
for (int k = 0;k < 10000;k++){
synchronized (lock){
count2++;
}
}
});
}
start = System.currentTimeMillis();
for (Thread t:threads) {
t.start();
}
for (Thread t:threads) {
t.join();
}
end = System.currentTimeMillis();
System.out.println("synchronized:"+count2+"time"+(end - start));
//-------------------------
for (int i = 0; i < threads.length; i++) {
threads[i] = new Thread(()->{
for (int k = 0;k < 10000;k++){
count3.increment();
}
});
}
start = System.currentTimeMillis();
for (Thread t:threads) {
t.start();
}
for (Thread t:threads) {
t.join();
}
end = System.currentTimeMillis();
System.out.println("LongAdder:"+count3.longValue()+"time"+(end - start));
}
}
使用JDK8进行测试
执行时间:LongAdder比其他两个快非常多 Atomic 比 Synchronzied慢
LongAdder类
java为解决频繁修改一个变量的业务需求而产生的一个类
底层使用了分段锁(也是CAS操作)
ReentrantLock (可重入锁)
底层是CAS+AQS队列
必须最后unlock()
synchronized必须是可重入锁(比如父类持有这把锁,子类也必须可以访问),可自动解锁
ReentrantLock可以替代Synchronized
package character03;
import java.util.concurrent.TimeUnit;
/**
* @author laimouren
*/
public class ReentrantLock01 {
synchronized void m1(){
for (int i = 0; i < 10; i++) {
try{
TimeUnit.SECONDS.sleep(1);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println(i);
if(i == 2){
m2();
}
}
}
synchronized void m2(){
System.out.println("m2...");
}
public static void main(String[] args) {
ReentrantLock01 r = new ReentrantLock01();
new Thread(r::m1).start();
try{
TimeUnit.SECONDS.sleep(1);
}catch (InterruptedException e){
e.printStackTrace();
}
//new Thread(r::m2).start();
}
}
使用reentrantlock替代synchronized
synchronized是自动解锁的,而ReetrantLock是需要手动解锁的(在finally块里执行)
package character03;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* @author laimouren
*/
public class ReentrantLock02 {
Lock lock = new ReentrantLock();
void m1(){
try{
lock.lock(); //synchronized(this)
for (int i = 0; i < 10; i++) {
TimeUnit.SECONDS.sleep(1);
System.out.println(i);
}
}
catch (InterruptedException e){
e.printStackTrace();
}finally {
//手动解锁
lock.unlock();
}
}
void m2(){
try{
lock.lock();
System.out.println("m2...");
}finally {
lock.unlock();
}
}
public static void main(String[] args) {
ReentrantLock02 r = new ReentrantLock02();
new Thread(r::m1).start();
try{
TimeUnit.SECONDS.sleep(1);
}catch (InterruptedException e){
e.printStackTrace();
}
new Thread(r::m2).start();
}
}
比synchronized强大之处
- 可以使用tryLock尝试锁定,不管锁定与否,方法都继续执行
- 可以根据tryLock的返回值来判定是否锁定
- 可以指定tryLock的时间,由于tryLock(time)抛出异常,所以要注意unLock的异常处理
- 可以使用lockInterruptibly(),对interrupt()方法做出相应操作,比如搭配interrupt()方法进行唤醒线程
lockInterruptibly使用:
package character03;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* @author laimouren
*/
public class ReentrantLock03 {
public static void main(String[] args) {
Lock lock = new ReentrantLock();
Thread t1 = new Thread(()->{
try{
lock.lock();
System.out.println("t1 start");
TimeUnit.SECONDS.sleep(Integer.MAX_VALUE);
System.out.println("t1 end");
}catch (InterruptedException e){
e.printStackTrace();
}finally {
lock.unlock();
}
});
t1.start();
Thread t2 = new Thread(()->{
try{
//lock.lock()
lock.lockInterruptibly();//可以对interrupt()做出响应
System.out.println("t2 start");
TimeUnit.SECONDS.sleep(5);
System.out.println("t2 end");
}catch (InterruptedException e){
e.printStackTrace();
}finally {
lock.unlock();
}
});
t2.start();
try{
TimeUnit.SECONDS.sleep(1);
}catch (InterruptedException e){
e.printStackTrace();
}
t2.interrupt();//打断线程2的等待
}
}
ReentrantLock可以是公平锁,默认是非公平
线程处于一个等待队列中,后进来的线程先检查等待队列是否有线程,有就排队等待使用锁,不一定是循环输出
synchronized只能是非公平锁
package character03;
import java.util.concurrent.locks.ReentrantLock;
/**
* @author laimouren
*/
public class ReentrantLock04 extends Thread{
//参数为true表示是公平锁,对比输出结果,先来先执行
private static ReentrantLock lock = new ReentrantLock(true);
@Override
public void run(){
for (int i = 0; i < 100; i++) {
lock.lock();
try{
System.out.println(Thread.currentThread().getName()+"获得锁");
}finally {
lock.unlock();
}
}
}
public static void main(String[] args) {
ReentrantLock04 r = new ReentrantLock04();
Thread t1 = new Thread(r);
Thread t2 = new Thread(r);
t1.start();
t2.start();
}
}
CountDownLatch
CAS锁
可以简单理解为:倒数时间,时间到门栓就打开了,也就是锁释放了
利用它可以实现类似计数器的功能。比如有一个任务A,它要等待其他4个任务执行完毕之后才能执行,此时就可以利用CountDownLatch来实现这种功能了
可以在一个线程多次countdown
基本使用
package character03;
import java.util.concurrent.CountDownLatch;
/**
* @author laimouren
*/
public class CountDownLatch01 {
public static void main(String[] args) {
usingCountDownLatch();
usingJoin();
}
private static void usingCountDownLatch(){
Thread[] threads = new Thread[100];
//参数是代表从多少数字开始倒数
CountDownLatch latch = new CountDownLatch(threads.length);
for (int i = 0; i < threads.length; i++) {
threads[i] = new Thread(()->{
int result = 0;
for (int j = 0; j < 10000; j++) {
result+=j;
}
//不停地倒数,倒数到0,则await()方法结束
//原子操作,不需要用sync
//可以在同一个线程多次执行countDown();
latch.countDown();
});
}
for (int i = 0; i < threads.length; i++) {
threads[i].start();
}
try{
//简单理解该方法是上门栓,等倒数到0时,门栓打开
latch.await();
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println("end latch");
}
public static void usingJoin(){
Thread[] threads = new Thread[100];
for (int i = 0; i < threads.length; i++) {
threads[i] = new Thread(()->{
int result = 0;
for (int j = 0; j < 10000; j++) {
result += j;
}
});
}
for (int i = 0; i < threads.length; i++) {
threads[i].start();
}
for (int i = 0; i < threads.length; i++) {
try {
threads[i].join();
}
catch (InterruptedException e){
e.printStackTrace();
}
}
}
}
CyclicBarrier
循环屏障
可以简单理解为一个栅栏,当多个线程同时访问时会推倒这个栅栏
也可以理解为满人了就发车,周而复始
通过它可以实现让一组线程等待至某个状态之后再全部同时执行
比如:每个写入线程执行完写数据操作之后,就在等待其他线程写入操作完毕。
当所有线程线程写入操作完毕之后,所有线程就继续进行后续的操作了。
作用:限流(入口特别多,但是出口特别少,从而达到限制流量的作用)
实际开发用到的应该是Guava RateLimiter(谷歌做的限流类)
基本操作
package character03;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
/**
* @author laimouren
*/
public class CyclicBarrier01 {
public static void main(String[] args) {
//和下面操作一个意思
CyclicBarrier barrier1 = new CyclicBarrier(20,()-> System.out.println("满人,发车"));
//第一个参数表示集满多少个线程开始执行第二个参数的runnable操作
CyclicBarrier barrier = new CyclicBarrier(20, new Runnable() {
@Override
public void run() {
System.out.println("满人,发车");
}
});
for (int i = 0; i < 100; i++) {
new Thread(()->{
try{
barrier.await();
}catch (InterruptedException e){
e.printStackTrace();
}catch (BrokenBarrierException e){
e.printStackTrace();
}
}).start();
}
}
}
Phaser
读音:feise,翻译:阶段器
java多线程技术提供了Phaser工具类,Phaser表示“阶段器”,用来解决控制多个线程分阶段共同完成任务的情景问题。其作用相比CountDownLatch和CyclicBarrier更加灵活,例如有这样的一个题目:5个学生一起参加考试,一共有三道题,要求所有学生到齐才能开始考试,全部同学都做完第一题,学生才能继续做第二题,全部学生做完了第二题,才能做第三题,所有学生都做完的第三题,考试才结束。分析这个题目:这是一个多线程(5个学生)分阶段问题(考试考试、第一题做完、第二题做完、第三题做完),所以很适合用Phaser解决这个问题。
参考博客
遗传算法用到,其他时候基本不用
按照不同阶段对线程进行执行
ReadWriteLock(重点)
读锁(共享锁)、写锁(排它锁)
线程读内容时,只允许其他线程读,不能写
线程写内容时,其他线程不允许操作
读情况特别多,写情况特别少的时候特别推荐
基本操作
package character03;
import java.util.Random;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* @author laimouren
*/
public class ReadWriteLock01 {
static Lock lock = new ReentrantLock();
private static int value;
static ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
static Lock readLock = readWriteLock.readLock();
static Lock writeLock = readWriteLock.writeLock();
public static void read(Lock lock){
try{
lock.lock();
Thread.sleep(1000);
System.out.println("read over");
}catch (InterruptedException e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
public static void write(Lock lock,int v){
try{
lock.lock();
Thread.sleep(1000);
value = v;
System.out.println("write over");
}catch (InterruptedException e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
public static void main(String[] args){
// Runnable readR = ()->read(lock);
Runnable readR = ()->read(readLock);
//Runnable writeR = ()->write(lock,new Random().nextInt());
Runnable writeR = ()->write(writeLock,new Random().nextInt());
for (int i = 0; i < 18; i++) {
new Thread(readR).start();
}
for (int i = 0; i < 2; i++) {
new Thread(writeR).start();
}
}
}
相对单一排它锁(如ReentrantLock),效率大大提高
Semaphore
信号量:是一种计数器,用来保护一个或者多个共享资源的访问。如果线程要访问一个资源就必须先获得信号量。如果信号量内部计数器大于0,信号量减1,然后允许共享这个资源;否则,如果信号量的计数器等于0,信号量将会把线程置入休眠直至计数器大于0.当信号量使用完时,必须释放。
作用:限流(可以结合车辆车道和收费站来理解)
操作
package character03;
import java.util.concurrent.Semaphore;
/**
* @author laimouren
*/
public class Semaphore01 {
public static void main(String[] args) {
//允许一个线程同时执行
Semaphore s = new Semaphore(1);
//第二个参数是指定是否公平
Semaphore s1 = new Semaphore(1,true);
new Thread(()->{
try{
//获得锁许可,即信号量减一
s.acquire();
System.out.println("T1 running..");
Thread.sleep(200);
System.out.println("T1 running...");
}catch (InterruptedException e){
e.printStackTrace();
}finally {
//释放锁,即信号量加一
s.release();
}
}).start();
new Thread(()->{
try{
s.acquire();
System.out.println("T2 running..");
Thread.sleep(200);
System.out.println("T2 running...");
s.release();
}catch (InterruptedException e){
e.printStackTrace();
}
}).start();
}
}
Exchanger
了解一下
作用:线程间交换数据
第一个线程执行exchange()时,阻塞;
第二个线程执行exchange()时,交换两个线程的消息;
然后都继续向下执行。