活跃性问题
死锁
所谓死锁，是指多个进程在运行过程中因争夺资源而造成的一种僵局，当进程处于这种僵持状态时，若无外力作用，它们都将无法再向前推进。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
public class ThreadDeadLock {
public static void main(String[] args) {
String lockA = "lockA";
String lockB = "lockB";
new Thread(new HoldThread(lockA, lockB), "threadA").start();
new Thread(new HoldThread(lockB, lockA), "threadB").start();
}
}
class HoldThread implements Runnable {
private final String source1;
private final String source2;
public HoldThread(String source1, String source2) {
this.source1 = source1;
this.source2 = source2;
}
@Override
public void run() {
synchronized (source1) {
System.out.println(Thread.currentThread().getName() + "\t 持有锁" + source1 + "尝试获得" + source2);
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (source2) {
System.out.println(Thread.currentThread().getName() + "\t 持有锁" + source2 + "尝试获得" + source1);
}
}
}
}
//输出结果：控制台会一挂着，因为发生死锁，无法正常结束
threadA 持有锁lockA尝试获得lockB
threadB 持有锁lockB尝试获得lockA
|
死锁的定位：1、jps命令定位进程编号 2、jstack找到死锁查看
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
E:\Java\projects\java-concurrent-programing>jps
15108 Jps
2932
728 ThreadDeadLock
6364 RemoteMavenServer36
9708 Launcher
E:\Java\projects\java-concurrent-programing>jstack 728
2020-06-02 10:08:10
Full thread dump Java HotSpot(TM) 64-Bit Server VM (25.131-b11 mixed mode):
Found one Java-level deadlock:
=============================
"threadB":
waiting to lock monitor 0x000000001cea0c88 (object 0x000000076b699a98, a java.lang.String),
which is held by "threadA"
"threadA":
waiting to lock monitor 0x000000001cea3308 (object 0x000000076b699ad0, a java.lang.String),
which is held by "threadB"
Java stack information for the threads listed above:
===================================================
"threadB":
at com.msr.study.concurrent.deadlock.HoldThread.run(ThreadDeadLock.java:42)
- waiting to lock <0x000000076b699a98> (a java.lang.String)
- locked <0x000000076b699ad0> (a java.lang.String)
at java.lang.Thread.run(Thread.java:748)
"threadA":
at com.msr.study.concurrent.deadlock.HoldThread.run(ThreadDeadLock.java:42)
- waiting to lock <0x000000076b699ad0> (a java.lang.String)
- locked <0x000000076b699a98> (a java.lang.String)
at java.lang.Thread.run(Thread.java:748)
Found 1 deadlock.
|
jstack之后得到程序的栈信息，有很多内容。很明显可以看到Found one Java-level deadlock:发现一个死锁。
threadB：
- waiting to lock <0x000000076b699a98> (a java.lang.String)
- locked <0x000000076b699ad0> (a java.lang.String)
threadA：
-waiting to lock <0x000000076b699ad0> (a java.lang.String)
- locked <0x000000076b699a98> (a java.lang.String)
饥饿
如果线程优先级“不均”，并且CPU繁忙的情况下，优先级低的线程得到执行的机会很小，就可能发生线程“饥饿”；持有锁的线程，如果执行的时间过长，也可能导致“饥饿”问题。饥饿嘛，线程一直得不到CPU时间，一直被饿着。
所以在使用多线程的时候，要合理设置优先级。使用公平锁来取代synchronized，因为synchronized是非公平锁。
活锁
活锁指的是任务或者执行者没有被阻塞，由于某些条件没有满足，导致一直重复尝试—失败—尝试—失败的过程。处于活锁的实体是在不断的改变状态，活锁有可能自行解开。
活锁一般是由于对死锁的不正确处理引起的。由于处于死锁中的多个线程同时采取了行动。 而避免的方法也是只让一个线程释放资源。
性能问题
- 消耗时间：线程的创建和销毁都需要时间，当有大量的线程创建和销毁时，那么这些时间的消耗则比较明显，将导致性能上的缺失
- 消耗CPU和内存：如果发生大量的线程被创建、执行和销毁，这可是非常耗CPU和内存的，这样将直接影响系统的吞吐量，导致性能急剧下降，如果内存资源占用的比较多，还很可能造成OOM
- 容易导致GC频繁的执行：大量的线程的创建和销毁很容易导致GC频繁的执行，从而发生内存抖动现象，而发生了内存抖动，对于移动端来说，最大的影响就是造成界面卡顿
- 线程的上下文切换：在线程调度过程中需要访问由操作系统和JVM共享的数据结构。应用程序、操作系统以及JVM都使用一组相同的CPU，在JVM和操作系统的代码中消耗越多的CPU时钟周期，应用程序的可用CPU时钟周期就越来越少。当一个新的线程被切换进来时，它所需要的数据可能不在当前处理器的本地缓存中，因此上下文切换将导致一些缓存缺失，因而线程在首次调度运行时会更加缓慢。
线程安全性问题
线程安全问题可能是我们开发人员关注最多的点。那就以现在说一下的买票的例子吧！
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
package com.msr.study.concurrent.threadsafe;
import java.util.concurrent.TimeUnit;
public class ThreadUnsafe {
public static void main(String[] args) {
Ticket ticket = new Ticket();
for (int i = 0; i < 10; i++) {
Thread thread = new Thread(ticket);
thread.start();
}
}
}
class Ticket implements Runnable {
private static int ticketNum = 50;
@Override
public void run() {
while (true) {
if (ticketNum > 0) {
try {
TimeUnit.MILLISECONDS.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " sale a ticket,current:" + ticketNum--);
}else {
break;
}
}
}
}
//输出结果：其中多个线程出现了卖出同一场票，同时剩余28
Thread-9 sale a ticket,current:28
Thread-8 sale a ticket,current:28
Thread-1 sale a ticket,current:28
Thread-2 sale a ticket,current:29
Thread-4 sale a ticket,current:28
|
从字节码的角度看：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
|
Compiled from "ThreadUnsafe.java"
class com.msr.study.concurrent.threadsafe.Ticket implements java.lang.Runnable {
com.msr.study.concurrent.threadsafe.Ticket();
Code:
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return
public void run();
Code:
0: getstatic #2 // Field ticketNum:I
3: ifle 68
6: getstatic #3 // Field java/util/concurrent/TimeUnit.MILLISECONDS:Ljava/util/concurrent/TimeUnit;
9: ldc2_w #4 // long 100l
12: invokevirtual #6 // Method java/util/concurrent/TimeUnit.sleep:(J)V
15: goto 23
18: astore_1
19: aload_1
20: invokevirtual #8 // Method java/lang/InterruptedException.printStackTrace:()V
23: getstatic #9 // Field java/lang/System.out:Ljava/io/PrintStream;
26: new #10 // class java/lang/StringBuilder
29: dup
30: invokespecial #11 // Method java/lang/StringBuilder."<init>":()V
33: invokestatic #12 // Method java/lang/Thread.currentThread:()Ljava/lang/Thread;
36: invokevirtual #13 // Method java/lang/Thread.getName:()Ljava/lang/String;
39: invokevirtual #14 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
42: ldc #15 // String sale a ticket,current:
44: invokevirtual #14 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
47: getstatic #2 // Field ticketNum:I
50: dup
51: iconst_1
52: isub
53: putstatic #2 // Field ticketNum:I
56: invokevirtual #16 // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
59: invokevirtual #17 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
62: invokevirtual #18 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
65: goto 0
68: return
Exception table:
from to target type
6 15 18 Class java/lang/InterruptedException
static {};
Code:
0: bipush 50
2: putstatic #2 // Field ticketNum:I
5: return
}
|
内容虽然很多但是其中可以只关注下面两行：isub:ticketNum进行减一操作，putstatic:把减一之后的值重新赋值给ticketNum。这两个操作时ticketNum--产生，说明ticketNum--不是原子操作，原子不可再分。tickNum--是可以分为：减一，赋值两个操作，所以这种i–或i++这些都是非原子操作。
1
2
3
4
5
|
47: getstatic #2 // Field ticketNum:I
50: dup
51: iconst_1
52: isub
53: putstatic #2
|
既然时非原子操作，那么在多线程中又如何产生线程安全问题，如下图所示。有点稍微涉及了一下JMM，在后面讲到volatile会详细讲解。其解决方案，最简单的就是synchronized去解决。线程安全的问题会在后面详细讲解
总结
多线程的使用会带来一系列的问题，如果盲目使用多线程而不注意这些问题，可能会带来严重的生产事故。
