什么是共享资源?共享资源指的是多个线程同时对同一份资源进行访问,被多个线程访问的资源就称为共享资源,如何保证多个线程访问到的数据时一致的,则被称为数据同步或者资源同步。
4.1 数据同步
4.1.1 数据不一致引入的问题
public class MyThread extends Thread{
int count = 5;
public void run() {
while(count>0) {
System.out.println(Thread.currentThread().getName()+":"+count--);
}
}
}
...................
public class Test {
public static void main(String[] args) throws InterruptedException {
MyThread thread = new MyThread();
Thread t = new Thread(thread);
Thread t2 = new Thread(thread);
Thread t3 = new Thread(thread);
Thread t4 = new Thread(thread);
t.start();
t2.start();
t3.start();
t4.start();
}
}
......................
运行结果:
Thread-2:5
Thread-2:4
Thread-2:3
Thread-2:2
Thread-2:1
Thread-1:0
------------
Thread-1:10
Thread-1:9
Thread-1:8
Thread-1:6
Thread-4:7
Thread-2:10
Thread-2:2
Thread-1:4
Thread-3:5
Thread-2:1
Thread-4:3
出现上述为题的原因是,可能几个线程都执行到了这一句,
System.out.println(Thread.currentThread().getName()+":"+count--);
线程2让出了CPU执行权,线程1获取了CPU执行权,继续执行,导致count为0.
如果在这句代码之前有什么东西控制一下就好了,让每个线程进入这样的临界代码之前都检查一下,并且只能一个个进。
解决上述问题,需要用到synchronized关键字
4.2 初识synchronized关键字
4.2.1 什么是synchronized关键字
synchronized关键字可以实现一个简单的策略来防止线程干扰和内存一致性错误,如果一个对象对多个线程是可见的,那么该对象的所有读或者写都将通过同步的方式来进行,具体表现如下:
1.synchronized关键字提供了一种锁的机制,能够确保共享变量的互斥访问,从而防止数据不一致问题的出现
2.synchronized关键字包括monitor enter和monitor exit两个JVM指令,他能够保证在任何时候任何线程执行到monitor enter成功之前都必须从主存中获取数据,而不是缓存中,在monitor exit运行成功之后,共享变量被更新后的值必须刷人主内存。
3.synchronized的指令严格遵守java happens-before规则,一个monitor exit指令之前必定要有一个monitor enter
4.2.2 synchronized关键字的用法
synchronized可以用于对代码块或方法进行修饰,而不能够用于对class以及变量进行修饰。
1.同步方法
public synchronized …(){
}
2.同步代码块
public …(){
synchronized(对象){
}
}
4.3 深入synchronized关键字
4.3.1 线程堆栈分析
synchronized关键字提供了一种互斥机制,也就是说在同一时刻,只能有一个线程访问同步资源,很多资料、书籍将synchronized(mutex)称为锁,其实这个说法不严谨,准确的讲应该是某线程获取了与mutex关联的monitor锁。
4.3.2 JVM指令分析
public class MyThread extends Thread{
private final Object obj = new Object();
int count = 10;
public void run() {
synchronized(obj) {
while(count>0) {
System.out.println(Thread.currentThread().getName()+":"+count--);
}
}
}
}
反汇编:
public void run();
Code:
0: aload_0
1: getfield #17 // Field obj:Ljava/lang/Object;
4: dup
5: astore_1
6: monitorenter
7: goto 54
10: getstatic #26 // Field java/lang/System.out:Ljava/io/PrintStream;
13: new #32 // class java/lang/StringBuilder
16: dup
17: invokestatic #34 // Method java/lang/Thread.currentThread:()Ljava/lang/Thread;
20: invokevirtual #38 // Method java/lang/Thread.getName:()Ljava/lang/String;
23: invokestatic #42 // Method java/lang/String.valueOf:(Ljava/lang/Object;)Ljava/lang/String;
26: invokespecial #48 // Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
29: ldc #51 // String :
31: invokevirtual #53 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
34: aload_0
35: dup
36: getfield #19 // Field count:I
39: dup_x1
40: iconst_1
41: isub
42: putfield #19 // Field count:I
45: invokevirtual #57 // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
48: invokevirtual #60 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
51: invokevirtual #63 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
54: aload_0
55: getfield #19 // Field count:I
58: ifgt 10
61: aload_1
62: monitorexit
63: goto 69
66: aload_1
67: monitorexit
68: athrow
69: return
...........................
(1)Monitorenter
每个对象都与一个monitor相关联,一个monitor的lock的锁只能被一个线程在同一时间获得,在一个线程尝试获得与对象关联monitor的所有权时会发生如下的几件事情。
1.如果monitor的计数器为0则意味着该monitor的lock还没有被获得,某个线程获得之后将立即对该计数器加一,从此该线程就是这个monitor的所有者了。
2.如果已经拥有该monitor所有权的线程重入,则会导致monitor计数器再次累加
3.如果monitor已经被其他线程拥有,则其他线程尝试获取该monitor的所有权时,会被陷入阻塞状态直到monitor计数器变为0,才能再次尝试获取对monitor的所有权。
(2)Monitorexit
释放对monitor的所有权,想要释放某个对象关联的monitor的所有权的前提是,你曾经获得了所有权。释放monitor所有权的过程比较简单,就是将monitor的计数器减1,如果计数器的值为0,意味着,该线程不再拥有对象monitor的所有权,通俗的讲就是解锁。与此同时被该monitor block的线程将再次尝试获得对该monitor的所有权。
4.3.3 使用synchronized需要注意的问题
1.与monitor关联的对象不能为空
2.synchronized作用域太大
由于synchronized关键字存在排他性,也就是说所有的线程必须串行地经过synchronized保护的共享区域,如果synchronized作用域越大,则代表着其效率越低,甚至会丧失并发的优势。
3.不同的monitor企图锁相同的方法
public class Test implements Runnable{
private final Object mutex = new Object();
public void run() {
synchronized(mutex) {
}
}
public static void main(String[] args) throws InterruptedException {
for(int i = 0;i<5;i++) {
new Thread(Test::new).start();
}
}
}
上面的代码构造了五个线程,同时也构造了五个Runnable实例,Runnable作为线程逻辑执行单元传递给Thread,然后你将发现,synchronized根本互斥不了与之对应的作用域,线程之间进行monitor lock的争抢只能发生在于monitor关联的同一个引用上,上面的代码每一个线程争抢的monitor关联引用都是彼此独立的,因此不可能起到互斥的作用。
4.多个锁的交叉导致死锁
4.5 程序死锁
1.交叉锁可导致程序出现死锁
2.内存不足
3.一问一答式的数据交换
4.数据库锁
5.文件锁
6.死循环引起的死锁