JUC常见的锁，java技术面试总结评语

thread.start();

}

for (Thread thread : threads) {

thread.join();

}

long end = System.currentTimeMillis();

System.out.println("AtomicLong: " + count1.get() + " time: " + (end - start));

//long

Object o = new Object();

for (int i = 0; i < threads.length; i++) {

threads[i] = new Thread(() -> {

for (int j = 0; j < 100000; j++) {

synchronized (o) {

count2++;

}

}

});

}

start = System.currentTimeMillis();

for (Thread thread : threads) {

thread.start();

}

for (Thread thread : threads) {

thread.join();

}

end = System.currentTimeMillis();

System.out.println("Long: " + count2 + " time: " + (end - start));

//LongAdder

for (int i = 0; i < threads.length; i++) {

threads[i] = new Thread(() -> {

for (int j = 0; j < 100000; j++) {

count3.increment();

}

});

}

start = System.currentTimeMillis();

for (Thread thread : threads) {

thread.start();

}

for (Thread thread : threads) {

thread.join();

}

end = System.currentTimeMillis();

System.out.println("LongAdder: " + count3.longValue() + " time: " + (end - start));

}

}

复制代码

LongAdder内部用的是分段锁（内部也是CAS实现）。它会把值放到一个数组里，比如数组大小为4，则每一个数组里锁250个线程，每一个数组都做运算，最后再把所有的数组结果求和。所以LongAdder在超高并发时，优势特别明显。

二、ReentrantLock

===============

1、reentrantlock可以代替synchronized，使用reentrantlock可以完成和synchronized同样的功能，但是必须得手动释放锁。使用synchronized锁定如果遇到异常，jvm会自动释放锁，但是ReentrantLock必须手动释放锁，因此经常在finally中释放锁。

2、使用reentrantlock可以进行尝试锁定（tryLock），这样无法锁定或者在指定时间内无法锁定，线程可以决定是否继续等待。

3、reentrantlock可以指定为公平锁。ReentrantLock lock=new ReentrantLock(true);表示new一个公平锁。默认是非公平锁。

1、公平锁与非公平锁

---

公平锁：如果一个新来的线程，首先去判断锁的等待队列有无正在等待的线程，有则进入等待队列，等前面的先运行，无则直接去抢锁，这样的锁是公平锁。先来后到。

非公平锁：如果一个新来的线程，直接就去抢锁，而不去判断等待队列是否有线程在等待，这就是非公平锁。synchronized都是非公平锁。

新来的线程检不检查队列是公平锁与非公平锁的关键。

2、reentrantlock VS synchronized

---

1、reentrantlock可以代替synchronized

2、reentrantlock必须手动关闭锁，synchronized执行结束或异常时JVM会自动释放锁

3、reentrantlock是通过CAS实现的，synchronized本质是锁升级

4、reentrantlock可以通过tryLock来进行尝试锁定

5、reentrantlock可以在公平锁与非公平锁之间切换，synchronized都是非公平锁

三、CountDownLatch（倒数 门闩）

=======================

/**

• @author Java和算法学习：周一

*/

public class TestCountDownLatch {

public static void usingCountDownLatch() {

Thread[] threads = new Thread[10];

CountDownLatch countDownLatch = new CountDownLatch(threads.length);

for (int i = 0; i < threads.length; i++) {

threads[i] = new Thread(() -> {

int count = 0;

for (int j = 0; j < 10000; j++) {

count++;

}

System.out.println(count);

countDownLatch.countDown();

});

}

for (Thread thread : threads) {

thread.start();

}

try {

countDownLatch.await();

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(“CountDownLatch end…”);

}

public static void main(String[] args) {

usingCountDownLatch();

}

}

复制代码

countDownLatch初始大小定义为10，每增加一个线程门闩值减1（countDownLatch.countDown()）， 一直等待着（countDownLatch.await()），直到门闩值为0才执行。

四、CyclicBarrier （循环 栅栏）

=======================

/**

• @author Java和算法学习：周一

*/

public class TestCyclicBarrier {

public static void main(String[] args) {

CyclicBarrier barrier = new CyclicBarrier(20, ()->{

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();

}

}

}

复制代码

CyclicBarrier大小定义为20，达到20个线程时才执行一次，否则一直等待着（barrier.await()）。即以上程序会输出5次 满人，发车。

五、Phaser

========

/**

• @author Java和算法学习：周一

*/

public class TestPhaser {

private static MarriagePhaser marriagePhaser = new MarriagePhaser();

public static void sleep() {

try {

TimeUnit.MILLISECONDS.sleep(new Random().nextInt(1000));

} catch (InterruptedException e) {

e.printStackTrace();

}

}

static class MarriagePhaser extends Phaser {

@Override

protected boolean onAdvance(int phase, int registeredParties) {

switch (phase) {

case 0:

System.out.println("所有人到齐 " + registeredParties);

System.out.println();

return false;

case 1:

System.out.println("所有人吃完 " + registeredParties);

System.out.println();

return false;

case 2:

System.out.println("所有人离开 " + registeredParties);

System.out.println();

return false;

case 3:

System.out.println("新郎新娘抱抱 " + registeredParties);

return true;

default:

return true;

}

}

}

static class Person implements Runnable {

String name;

public Person(String name) {

this.name = name;

}

private void arrive() {

sleep();

System.out.println(name + " 到达现场");

marriagePhaser.arriveAndAwaitAdvance();

}

private void eat() {

sleep();

System.out.println(name + " 吃");

marriagePhaser.arriveAndAwaitAdvance();

}

private void leave() {

sleep();

System.out.println(name + " 离开");

marriagePhaser.arriveAndAwaitAdvance();

}

private void hug() {

if (“新郎”.equals(name) || “新娘”.equals(name)) {

sleep();

System.out.println(name + " 拥抱");

marriagePhaser.arriveAndAwaitAdvance();

} else {

marriagePhaser.arriveAndDeregister();

}

}

@Override

public void run() {

arrive();

eat();

leave();

hug();

}

}

public static void main(String[] args) {

marriagePhaser.bulkRegister(7);

for (int i = 0; i < 5; i++) {

new Thread(new Person(“person” + i)).start();

}

new Thread(new Person(“新郎”)).start();

new Thread(new Person(“新娘”)).start();

}

}

复制代码

类似于栅栏组，分阶段的栅栏 。所有的线程都到了某个栅栏的时候，才会执行下一步的操作。

六、ReadWriteLock

===============

Read的时候是共享锁

小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Java工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频

如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Java）

会执行下一步的操作。

六、ReadWriteLock

===============

Read的时候是共享锁

小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Java工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-YagGTKAQ-1710883851450)]
[外链图片转存中…(img-mCOx7t6w-1710883851451)]
[外链图片转存中…(img-9tmxrUIc-1710883851452)]

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频

如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Java）
[外链图片转存中…(img-Tv5bqYlt-1710883851452)]