0: ldc #2 // class com/lanshifu/opengldemo/test/SynchronizedTest
2: dup
3: astore_1
4: monitorenter
5: getstatic #3 // Field java/lang/System.out:Ljava/io/PrintStream;
8: ldc #4 // String 123
10: invokevirtual #5 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
13: aload_1
14: monitorexit
15: goto 23
18: astore_2
19: aload_1
20: monitorexit
21: aload_2
22: athrow
23: invokestatic #6 // Method method:()V
26: return
可以看到 4: monitorenter
和 14: monitorexit
,中间是打印的语句。
执行同步代码块,首先会执行monitorenter
指令,然后执行同步代码块中的代码,退出同步代码块的时候会执行monitorexit
指令 。
使用Synchronized进行同步,其关键就是必须要对对象的监视器monitor进行获取,当线程获取monitor后才能继续往下执行,否则就进入同步队列,线程状态变成BLOCK,同一时刻只有一个线程能够获取到monitor,当监听到monitorexit被调用,队列里就有一个线程出队,获取monitor。详情参考:www.jianshu.com/p/d53bf830f…
每个对象拥有一个计数器,当线程获取该对象锁后,计数器就会加一,释放锁后就会将计数器减一,所以只要这个锁的计数器大于0,其它线程访问就只能等待。
2.3 Synchronized 锁的升级
大家对Synchronized的理解可能就是重量级锁,但是Java1.6对 Synchronized 进行了各种优化之后,有些情况下它就并不那么重,Java1.6 中为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁。
偏向锁: 大多数情况下,锁不仅不存在多线程竞争,而且总是由同一线程多次获得,为了让线程获得锁的代价更低而引入了偏向锁。
当一个线程A访问加了同步锁的代码块时,会在对象头中存 储当前线程的id,后续这个线程进入和退出这段加了同步锁的代码块时,不需要再次加锁和释放锁。
轻量级锁: 在偏向锁情况下,如果线程B也访问了同步代码块,比较对象头的线程id不一样,会升级为轻量级锁,并且通过自旋的方式来获取轻量级锁。
重量级锁: 如果线程A和线程B同时访问同步代码块,则轻量级锁会升级为重量级锁,线程A获取到重量级锁的情况下,线程B只能入队等待,进入BLOCK状态。
2.4 Synchronized 缺点
- 不能设置锁超时时间
- 不能通过代码释放锁
- 容易造成死锁
三、ReentrantLock
上面说到Synchronized
的缺点,不能设置锁超时时间和不能通过代码释放锁,ReentranLock
就可以解决这个问题。
在多个条件变量和高度竞争锁的地方,用ReentrantLock更合适,ReentrantLock还提供了Condition
,对线程的等待和唤醒等操作更加灵活,一个ReentrantLock可以有多个Condition实例,所以更有扩展性。
3.1 ReentrantLock 的使用
lock 和 unlock
ReentrantLock reentrantLock = new ReentrantLock();
System.out.println(“reentrantLock->lock”);
reentrantLock.lock();
try {
System.out.println(“睡眠2秒…”);
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
reentrantLock.unlock();
System.out.println(“reentrantLock->unlock”);
}
实现可定时的锁请求:tryLock
public static void main(String[] args) {
ReentrantLock reentrantLock = new ReentrantLock();
Thread thread1 = new Thread_tryLock(reentrantLock);
thread1.setName(“thread1”);
thread1.start();
Thread thread2 = new Thread_tryLock(reentrantLock);
thread2.setName(“thread2”);
thread2.start();
}
static class Thread_tryLock extends Thread {
ReentrantLock reentrantLock;
public Thread_tryLock(ReentrantLock reentrantLock) {
this.reentrantLock = reentrantLock;
}
@Override
public void run() {
try {
System.out.println(“try lock:” + Thread.currentThread().getName());
boolean tryLock = reentrantLock.tryLock(3, TimeUnit.SECONDS);
if (tryLock) {
System.out.println(“try lock success :” + Thread.currentThread().getName());
System.out.println(“睡眠一下:” + Thread.currentThread().getName());
Thread.sleep(5000);
System.out.println(“醒了:” + Thread.currentThread().getName());
} else {
System.out.println(“try lock 超时 :” + Thread.currentThread().getName());
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
System.out.println(“unlock:” + Thread.currentThread().getName());
reentrantLock.unlock();
}
}
}
打印的日志:
try lock:thread1
try lock:thread2
try lock success :thread2
睡眠一下:thread2
try lock 超时 :thread1
unlock:thread1
Exception in thread “thread1” java.lang.IllegalMonitorStateException
at java.util.concurrent.locks.ReentrantLock
S
y
n
c
.
t
r
y
R
e
l
e
a
s
e
(
R
e
e
n
t
r
a
n
t
L
o
c
k
.
j
a
v
a
:
151
)
a
t
j
a
v
a
.
u
t
i
l
.
c
o
n
c
u
r
r
e
n
t
.
l
o
c
k
s
.
A
b
s
t
r
a
c
t
Q
u
e
u
e
d
S
y
n
c
h
r
o
n
i
z
e
r
.
r
e
l
e
a
s
e
(
A
b
s
t
r
a
c
t
Q
u
e
u
e
d
S
y
n
c
h
r
o
n
i
z
e
r
.
j
a
v
a
:
1261
)
a
t
j
a
v
a
.
u
t
i
l
.
c
o
n
c
u
r
r
e
n
t
.
l
o
c
k
s
.
R
e
e
n
t
r
a
n
t
L
o
c
k
.
u
n
l
o
c
k
(
R
e
e
n
t
r
a
n
t
L
o
c
k
.
j
a
v
a
:
457
)
a
t
c
o
m
.
l
a
n
s
h
i
f
u
.
d
e
m
o
m
o
d
u
l
e
.
t
e
s
t
.
l
o
c
k
.
R
e
e
n
t
r
a
n
L
o
c
k
T
e
s
t
Sync.tryRelease(ReentrantLock.java:151) at java.util.concurrent.locks.AbstractQueuedSynchronizer.release(AbstractQueuedSynchronizer.java:1261) at java.util.concurrent.locks.ReentrantLock.unlock(ReentrantLock.java:457) at com.lanshifu.demo_module.test.lock.ReentranLockTest
Sync.tryRelease(ReentrantLock.java:151)atjava.util.concurrent.locks.AbstractQueuedSynchronizer.release(AbstractQueuedSynchronizer.java:1261)atjava.util.concurrent.locks.ReentrantLock.unlock(ReentrantLock.java:457)atcom.lanshifu.demomodule.test.lock.ReentranLockTestThread_tryLock.run(ReentranLockTest.java:60)
醒了:thread2
unlock:thread2
上面演示了trtLock
的使用,trtLock
设置获取锁的等待时间,超过3秒直接返回失败,可以从日志中看到结果。 有异常是因为thread1获取锁失败,不应该调用unlock。
3.2 Condition 条件
public static void main(String[] args) {
Thread_Condition thread_condition = new Thread_Condition();
thread_condition.setName(“测试Condition的线程”);
thread_condition.start();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
thread_condition.singal();
}
static class Thread_Condition extends Thread {
@Override
public void run() {
await();
}
private ReentrantLock lock = new ReentrantLock();
public Condition condition = lock.newCondition();
public void await() {
try {
System.out.println(“lock”);
lock.lock();
System.out.println(Thread.currentThread().getName() + “:我在等待通知的到来…”);
condition.await();//await 和 signal 对应
//condition.await(2, TimeUnit.SECONDS); //设置等待超时时间
System.out.println(Thread.currentThread().getName() + “:等到通知了,我继续执行>>>”);
} catch (Exception e) {
e.printStackTrace();
} finally {
System.out.println(“unlock”);
lock.unlock();
}
}
public void singal() {
try {
System.out.println(“lock”);
lock.lock();
System.out.println(“我要通知在等待的线程,condition.signal()”);
condition.signal();//await 和 signal 对应
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
System.out.println(“unlock”);
lock.unlock();
}
}
}
运行打印日志
lock
测试Condition的线程:我在等待通知的到来…
lock
我要通知在等待的线程,condition.signal()
unlock
测试Condition的线程:等到通知了,我继续执行>>>
unlock
上面演示了Condition的 await 和 signal
使用,前提要先lock。
3.3 公平锁与非公平锁
ReentrantLock 构造函数传true表示公平锁。
公平锁表示线程获取锁的顺序是按照线程加锁的顺序来分配的,即先来先得的顺序。而非公平锁就是一种锁的抢占机制,是随机获得锁的,可能会导致某些线程一致拿不到锁,所以是不公平的。
3.4 ReentrantLock 注意点
- ReentrantLock使用lock和unlock来获得锁和释放锁
- unlock要放在finally中,这样正常运行或者异常都会释放锁
- 使用condition的await和signal方法之前,必须调用lock方法获得对象监视器
四、并发包
通过上面分析,并发严重的情况下,使用锁显然效率低下,因为同一时刻只能有一个线程可以获得锁,其它线程只能乖乖等待。
Java提供了并发包解决这个问题,接下来介绍并发包里一些常用的数据结构。
4.1 ConcurrentHashMap
我们都知道HashMap是线程不安全的数据结构,HashTable则在HashMap基础上,get方法和put方法加上Synchronized修饰变成线程安全,不过在高并发情况下效率底下,最终被ConcurrentHashMap
替代。
ConcurrentHashMap 采用分段锁,内部默认有16个桶,get和put操作,首先将key计算hashcode,然后跟16取余,落到16个桶中的一个,然后每个桶中都加了锁(ReentrantLock),桶中是HashMap结构(数组加链表,链表过长转红黑树)。
所以理论上最多支持16个线程同时访问。
4.2 LinkBlockingQueue
链表结构的阻塞队列,内部使用多个ReentrantLock
/** Lock held by take, poll, etc */
private final ReentrantLock takeLock = new ReentrantLock();
/** Wait queue for waiting takes */
private final Condition notEmpty = takeLock.newCondition();
/** Lock held by put, offer, etc */
private final ReentrantLock putLock = new ReentrantLock();
/** Wait queue for waiting puts */
private final Condition notFull = putLock.newCondition();
private void signalNotEmpty() {
final ReentrantLock takeLock = this.takeLock;
takeLock.lock();
try {
notEmpty.signal();
} finally {
takeLock.unlock();
}
}
/**
- Signals a waiting put. Called only from take/poll.
*/
private void signalNotFull() {
final ReentrantLock putLock = this.putLock;
putLock.lock();
try {
notFull.signal();
} finally {
putLock.unlock();
}
}
源码不贴太多,简单说一下LinkBlockingQueue
的逻辑:
- 从队列获取数据,如果队列中没有数据,会调用
notEmpty.await();
进入等待。- 在放数据进去队列的时候会调用
notEmpty.signal();
,通知消费者,1中的等待结束,唤醒继续执行。- 从队列里取到数据的时候会调用
notFull.signal();
,通知生产者继续生产。- 在put数据进入队列的时候,如果判断队列中的数据达到最大值,那么会调用
notFull.await();
,等待消费者消费掉,也就是等待3去取数据并且发出notFull.signal();
,这时候生产者才能继续生产。
LinkBlockingQueue
是典型的生产者消费者模式,源码细节就不多说。
4.3 原子操作类:AtomicInteger
内部采用CAS(compare and swap)保证原子性
举一个int自增的例子
AtomicInteger atomicInteger = new AtomicInteger(0);
atomicInteger.incrementAndGet();//自增
源码看一下
/**
- Atomically increments by one the current value.
- @return the updated value
*/
public final int incrementAndGet() {
return U.getAndAddInt(this, VALUE, 1) + 1;
}
U 是 Unsafe,看下 Unsafe#getAndAddInt
public final int getAndAddInt(Object var1, long var2, int var4) {
int var5;
do {
var5 = this.getIntVolatile(var1, var2);
} while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
return var5;
}
通过compareAndSwapInt
保证原子性。
最后
下面是有几位Android行业大佬对应上方技术点整理的一些进阶资料。希望能够帮助到大家提升技术
高级UI,自定义View
UI这块知识是现今使用者最多的。当年火爆一时的Android入门培训,学会这小块知识就能随便找到不错的工作了。
不过很显然现在远远不够了,拒绝无休止的CV,亲自去项目实战,读源码,研究原理吧!
《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》,点击传送门,即可获取!
佬对应上方技术点整理的一些进阶资料。希望能够帮助到大家提升技术
[外链图片转存中…(img-ogHwLzgj-1715429774772)]
高级UI,自定义View
UI这块知识是现今使用者最多的。当年火爆一时的Android入门培训,学会这小块知识就能随便找到不错的工作了。
不过很显然现在远远不够了,拒绝无休止的CV,亲自去项目实战,读源码,研究原理吧!
[外链图片转存中…(img-WkMBQirZ-1715429774773)]
《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》,点击传送门,即可获取!