Reentranlock
关于可重入锁,可以参考这一篇专门讲述的博文:聊聊关于Reentrantlock
ReadWriteLock
实际情况中,对于数据往往百分之80都是在进行读的操作,那么如果还使用互斥锁,即每个线程在执行的时候,其他线程只能等待,这样效率会非常低下,因此产生了ReadWriteLock(读写锁)。其中读锁是共享锁,写锁时排它锁(互斥锁),读写锁的本质是提高了读的效率。
如下代码:
public class ReadAndWrite {
public static void main(String[] args) {
ReentrantLock reentrantLock = new ReentrantLock();
ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();
for(int i = 0; i < 10; i++) {
new Thread(() -> {
try {
//reentrantLock.lock();
readLock.lock();
TimeUnit.SECONDS.sleep(1);
System.out.println("read over!");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
//reentrantLock.unlock();
readLock.unlock();
}
}).start();
}
for (int i = 0; i < 2; i++) {
new Thread(() -> {
try {
//reentrantLock.lock();
writeLock.lock();
TimeUnit.SECONDS.sleep(1);
System.out.println("write over~~~");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
//reentrantLock.unlock();
writeLock.unlock();
}
}).start();
}
}
}
在使用普通锁时,十个读线程和两个写线程会依次执行,耗时12秒。当使用读写锁时,十个读线程几乎同时完成,然后两个写线程依次执行,耗时2秒。
CountDownLatch
CountDownLatch是一个同步工具类,它允许一个或者多个线程一直等待,直到其他线程执行完再执行
原理是通过一个计数器实现的,计数器的初始化值为线程的数量,每当一个线程完成来了自己的任务之后,计数器的值就相应减一。当计数器到达0时,表示所有线程都已完成任务,然后在闭锁上等待的线程就可以恢复执行任务。构造方法需要传一个count(int类型)参数,是用等待线程数量来进行初始化
计数器count是闭锁需要等待的线程数量,只能被设置一次,且CountDownLatch没有提供任何机制去重新设置计数器count,与CountDownLatch的第一次交互是主线程等待其他线程。主线程必须在其他线程启动后立即调用CountDownLatch.wait(),这样主线程的操作就会在这个方法上阻塞,直到其他线程完成各自的任务。其他线程必须引用CountDownLatch闭锁对象,因为它们需要通知CountDownLatch对象。这种通知机制是通过CountDownLatch.countDown()来完成的,每调用一次,count的值减一,因此其它线程都调用这个方法,直到count为0,主线程就可以通过await()恢复自己的任务
代码示例:
public class CountDownTest {
static CountDownLatch latch = new CountDownLatch(5);
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
new Thread(() -> {
System.out.println(Thread.currentThread().getName());
latch.countDown();
}).start();
}
try {
latch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("main");
}
}
给CountDownLatch传参5,然后5个线程每次执行进行countDown(),然后在主线程中await(),直至countDown后的结果为0,主线程才输出。
实际应用:比如10个玩家进行王者荣耀时,为了保证游戏的公平性,就需要等待10个玩家都加载好以后才能进入游戏,那么可以用主线程来进行控制等待,十个玩家(十个线程)都进行了countDown()之后,主线程恢复运行,即可以开始游戏。
代码实现:
public class CountDownTest2 {
public static void main(String[] args) throws InterruptedException {
//十个玩家,所以是十个计数
CountDownLatch latch = new CountDownLatch(10);
System.out.println("玩家准备");
String[] str = new String[10];
Random random = new Random();
for(int i = 0; i <10; i++) {
//因为匿名内部类只能调用外部被final修饰的常量,所以将i赋值给x
final int x = i;
//共创建十个线程
new Thread(() -> {
for(int j = 0; j <= 100; j++) {
try {
//睡眠时间使用随机数,实现游戏加载的不确定性
Thread.sleep(random.nextInt(100));
} catch (InterruptedException e) {
e.printStackTrace();
}
//锁住数组对象
synchronized (str) {
str[x] = (j + "%");
System.out.print("\r" + Arrays.toString(str)); //使用\r,跳到表头
}
}
//计数减一
latch.countDown();
}).start();
}
latch.await();
System.out.println("\n进入游戏");
}
}
执行结果:
CyclicBarrier
CyclicBarrier,用于控制线程的数量,如车满多少人才能发车,如拼夕夕满多少人才能拼团成功
可以在创建CyclicBarrier对象时,传入int类型的参数,表示用于限制的数量,也可以传入两个参数,分别是数量和一个线程,在达到数量时,在线程中进行操作,代码如下:
public class CyclicBarrierTest {
public static void main(String[] args) {
CyclicBarrier barrier = new CyclicBarrier(4, ()-> System.out.println("发车啦!"));
for (int i = 0; i < 20; i++) {
new Thread(() -> {
try {
barrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}).start();
}
}
}
执行结果:
Semaphore
这个的作用其实相当于“限流”,即最多同时允许多少个线程进行。例如买景点门票,一共有5个窗口,那么就同时最多允许5个人在同时买票。但是需要注意:Semaphore默认是非公平的。如果想要公平,需要在构造方法传参为true。
Semahore中,一般会使用acquire(),意思为线程想要运行需要先得到许可,当许可为0时,线程就必须等待 ,当线程运行完,需要调用release(),将锁释放,这样,其他线程继续进行acquire()。
进行一个测试,一共有5个线程,但是同时可以进行的只能有2个,那么就会两个线程通知争取,释放后继续两两争取。代码如下:
public class SemaphoreTest {
static Semaphore semaphore = new Semaphore(2/*, true*/); //有true参数为公平锁
public static void main(String[] args) {
for(int i = 0; i <5; i++) {
new Thread(() -> {
try {
semaphore.acquire();
TimeUnit.SECONDS.sleep(1);
System.out.println(Thread.currentThread().getName() + "获取锁");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
semaphore.release();
}
}).start();
}
}
}
Exchanger
不怎么会用到的一个并发类,用于交换两个线程的同一个类型名称的数据值,当然,也仅仅适用于两个线程
示例:两个线程中都有字符串s,调用其exchange(),然后输出,会发现值已交换,代码如下:
public class ExchangeTest {
public static void main(String[] args) {
Exchanger<String> exchanger = new Exchanger<>();
new Thread(() -> {
String s = "T1";
try {
exchanger.exchange(s);
System.out.println(Thread.currentThread().getName() + " : " + s);
} catch (InterruptedException e) {
e.printStackTrace();
}
}, "t1").start();
new Thread(() -> {
String s = "T2";
try {
exchanger.exchange(s);
System.out.println(Thread.currentThread().getName() + " : " + s);
} catch (InterruptedException e) {
e.printStackTrace();
}
}, "t2").start();
}
}
执行结果:
LockSupport
用于支持线程的一个类,但是我们可以直接拿来用~
里面有这样的两个方法,park():将当前线程阻塞住,unpark():将阻塞的线程又解封了
试一下~我们在一个线程中每隔0.5秒打印一次数字,当数字值为5时阻塞住,然后经过4秒解封并给出提示,看看代码吧:
public class LockSupportTest {
public static void main(String[] args) {
Thread t = new Thread(() -> {
for(int i = 0; i <10; i++) {
System.out.println(i);
if(i == 5) {
LockSupport.park();
}
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t.start();
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("4秒过去了...");
LockSupport.unpark(t);
}
}
执行结果:
是不是很神奇呢,我们可以随意的控制线程的阻塞和恢复,并且不需要加锁就可以实现!那如果一般情况下该如何实现阻塞和恢复呢?一般都是使用wait()和notify(),并且并不能精确的唤醒某一个线程,而LockSupport可以精确的阻塞和唤醒线程