java多线程基础知识

一、线程的状态

线程的所有状态都在Thread类中State枚举中
NEW，RUNNABLE，BLOCKED，WAITING，TIMED_WAITING，TERMINATED

• NEW：表示线程刚刚创建，还没有开始执行
• RUNNABLE：表示已经创建好的线程，调用start()方法后，并且线程所需要的资源都已准备好
• BLOCKED：表示正在执行的线程遇到synchronized同步快，就会进入BLOCKED状态，直到获得请求的锁
• WAITING，TIMED_WAITING：这两个状态都是表示等待区别是WAITING进入一个无时间限制的等待，TIMED_WAITING进入一个有时间限制的等待
• TERMINATED：表示线程执行完毕后，则进入此状态

二、线程的基本操作

1. 新建线程
新建线程有两种方法一个是继承Thread类，另一个是实现Runnable接口

 Thread thread = new Thread(){            @Override            public void run() {                // doSomthing            }        };        thread.start();
1
2
3
4
5
6
7
8
1
2
3
4
5
6
7
8

---

class A implements Runnable{    @Override    public void run() {        // doSomthing    }}
1
2
3
4
5
6
7
1
2
3
4
5
6
7

继承Thread类或者实现Runnable接口后，重写run方法，然后调用start()方法，如果直接调用run()方法，就是普通的方法调用并不是开始一个新线程。

2. 终止线程

一般情况下，线程在执行完毕后都会正常结束，无须手动终止线程。但是，凡事也都有例外。想要正常关闭一个线程，JDK提供了stop()方法，但是已经被标记为了废弃。原因就是因为，stop()方法太过于暴力，线程在执行到一半的时候强制关闭，可能就会导致数据不一致性。比如说，刚好这个线程在执行同步块的代码时，被强制关闭了，那么就会造成数据的不完整行。
怎么实现优雅的stop呢，其实可以自己加个boolean类型的变量，每次进入run方法时先判断是否为true，想要终止时，把boolean的值设置为false，这样可以保证不会在线程执行一半时，强制终止。

3. 线程中断

这里说的线程中断，并不是线程终止，严格的讲，线程中断并不会让线程立即退出，而是发一个通知，告知目标线程，有人希望你退出了，但是目标线程接到通知后如何处理，则是完全由目标线程决定，这点很重要，如果中断后线程立即无条件退出，那么跟stop()方法又会是相同的问题。

与线程中断相关的有三个方法，长的看起来差不对，容易混肴

 public void interrupt()                //中断线程 public boolean isInterrupted()         //判断是否被中断 public static boolean interrupted()    //判断是否被中断，并清除当前的中断状态
1
2
3
1
2
3

• interrupt()：通知目标线程中断，也就是设置中断位。中断标志位表示当前线程已经被中断。
• isInterrupted()：判断当前线程是否有被中断
• interrupted()：判断当前线程的中断状态，当同时会清除当前中断标志位状态。

4. 等待（wait）和通知（notify）

为了支持多线程之间的写作，JDK提供了两个非常重要的接口，等待wait()和通知notify()方法。这两个方法不再Thread而是在Object类，这意味着任何对象都可以调用这两个方法

public final void wait() throws InterruptedExceptionpublic final native void notify();
1
2
1
2

当在一个对象实例上调用Object.wait()方法后，当前线程就会在这个对象上等待，状态：RUNNABLE → WAITING，一直等到其他线程调用了Object.notify()方法为止，状态：WAITING → RUNNABLE
wait()和notify()的工作过程，如果一个线程调用了Object.wait()，那么该线程就会进入object对象的等待队列中。这个队列中可能会有多个线程，因为系统可能同时运行多个线程都在等待这个对象。当Object.notify()被调用时，他就会从这个队列中随机选择一个线程，并将其唤醒，这里是随机的，并不是先等待先被唤醒。
除了notify()方法外，Object还有一个notifyAll()方法，他和notify()方法的基本功能一致，但不同的是，他会唤醒在这个等待队列中所有的线程，而不是随机选择一个。
Object.wait()方法并不是想调用就能调用的，他必须在synchronized块中调用，例如：

synchronized (object) {   try {           object.wait();       } catch (InterruptedException e) {           e.printStackTrace();      }}
1
2
3
4
5
6
7
1
2
3
4
5
6
7

无论是wait()方法还是notify()方法，都需要首先获得一个目标对象的监视器，如图

T1和T2表示2个线程，T1在正确执行方法前，首先获得一个object监视器，而wait()方法执行后，会释放掉这个监视器。这样做的目的是使得其他等待object对象的线程不至于，因为T1休眠而全部无法正常运行。notify()方法也是一样的

Object.wait()和Thread.sleep()方法都可以让线程等待若干时间，除了wait()可以被唤醒外，另一个主要区别就是wait()方法会释放目标对象的锁，而Thread.sleep()方法不会释放人资源。

5. 挂起（suspend）和继续执行（resume）线程
线程挂起（suspend）和继续执行（resume）是一对相反的操作，被挂起的线程必须要等到resume()之后才能继续。在JDK中，这个方法跟Thread.stop()一样，被标记为了废弃，并不推荐使用。原因就是因为suspend()在导致线程暂停的同时，并不会释放任何资源锁，这样就导致，其他想要获取这个锁的线程，都要等着，直到这个线程被resume()释放掉。但是，如果resume()操作意外的在suspend()之前执行了，那么被挂起的线程可能很难有机会被继续执行，它所占用的锁也不会得到释放，造成死锁。而且被挂起的线程，从他的线程状态上来看还是Runnable。举个例子

package com.example.thread;/** * Created by mazhenhua on 2017/3/6. */public class BadSuspend {    public static Object obj = new Object();    static ChangObjectThread t1 = new ChangObjectThread("t1");    static ChangObjectThread t2 = new ChangObjectThread("t2");    public static class ChangObjectThread extends Thread{        public ChangObjectThread(String name) {            super.setName(name);        }        @Override        public void run() {            synchronized (obj){                System.out.println("in " + getName());                Thread.currentThread().suspend();            }        }    }    public static void main(String[] args) throws Exception {        t1.start();        Thread.sleep(100);        t2.start();        t1.resume();        t2.resume();        t1.join();        t2.join();    }}
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
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

执行结果：

你会发现t1，t1都被输出出来了，但是左侧红色按钮还是亮起的状态，说明程序还没有结束，正常结束应该一个绿色的三角，这说明t2在输出线程名字之后被挂起来了。那t1为什么没有挂起了，t1如果挂起来，就会把锁占用掉，就不会打印出t2了，你可以把Thread.sleep(100); 这一行注释掉，就只会打印t1。正是因为main线程中间休息了100毫秒，才让t1的线程先挂起，再释放。t2就没有这么幸运了，t2和main线程一起跑的中间没有停留，就导致t2.resume(); 跑在了t2线程挂起之前，所以线程就一直挂起没有释放。
怎么办呢，既然不让用，那我们就不用，自己写一个，利用wait()，和notify()，自己写个类似的功能，代码：

package com.example.thread;/** * Created by mazhenhua on 2017/3/6. */public class GoodSuspend {    public static Object object = new Object();    public static class ChangeObjectThread extends Thread {        volatile boolean suspendme = false;        public void suspendMe(){            suspendme = true;        }        public void resumeMe(){            suspendme = false;            synchronized (object){                object.notify();            }        }        @Override        public void run() {            while (true){                synchronized (object){                    while (suspendme){                        try {                            object.wait();                        } catch (InterruptedException e) {                            e.printStackTrace();                        }                    }                }                synchronized (object){                    System.out.println("in ChangeObjectThread");                }                Thread.yield();            }        }    }    public static void main(String[] args) throws InterruptedException {        ChangeObjectThread t1 = new ChangeObjectThread();        t1.start();        Thread.sleep(1000);        t1.suspendMe();        System.out.println("suspend t1 2 sec");        Thread.sleep(2000);        System.out.println("resume t1");        //t1.resumeMe();    }}
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
49
50
51
52
53
54
55
56
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
49
50
51
52
53
54
55
56

运行结果：

这里是把t1.resumeMe();注释掉的结果，不注释掉，被释放了，会是个死循环。
事实证明，问题总会被解决的，没有这条路不通，换条路走。

6. 等待线程结束（join）和谦让（yield）
很多情况下，线程之前的协作和人与人之前是类似的。比如流水线的工人，前一个人装上了主板，下一个人在装内存条。装内存条的说，我现在太忙了，你先装硬盘吧，装好硬盘，我再装内存条。
这个关系，对应到多线程应用中，很多时候，一个线程的输入依赖于另一个线程的输出，此时，这个线程就需要等到另一个线程结束，才能继续运行，JDK提供了join()方法来操作这个功能

public final void join() throws InterruptedExceptionpublic final synchronized void join(long millis)throws InterruptedException
1
2
1
2

不带参数的，会一直阻塞当前线程，直到目标线程结束。带参数的是给个最大等待时间，超过时间就不等了直接往下走。

public static native void yield();
1
1

这个静态方法，一旦执行，就会让当前线程退出cpu。但是，并不是说当前线程就不执行了，退出CPU后，还会再次加入CPU的资源争夺中，但是能否再次被分配到就不一定了。因此对于Thread.yield()的调用就好像是在说：我已经完成了前面重要的工作，我应该休息一下，可以给其他线程一些工作机会啦。
如果你觉得一个线程不是那么重要，或者优先级非常滴，但是又担心他占用太多CPU资源，可以在适当的时候，调用yield()，给予其他线程更多的机会。

7. volatile与Java内存模型（JMM）
JAVA内存模型都是围绕着原子性，有序性和可见性展开的。为了在适当的场合下，确保线程之间的有序性，可见性，原子性。java使用了一些特殊的操作或者关键字来申明，告诉虚拟机，在这个地方，要尤其注意不能随意变动优化目标的指令。关键字volatile就是其中之一。
volatile的英文翻译是“易变的，不稳定的”这正是使用volatile关键字的语义
当用volatile去声明一个变量时，就等于告诉了虚拟机，这个变量极有可能会被某些程序或线程修改，为了保证这个变量被修改后，应用程序范围内的所有线程多能看到这个改动，虚拟机就必须采用一些特殊的手段，保证这个变量的可见性，等特点。
volatile关键字只保证可见性，并不保证同步，想要保证同步还是要加synchronized，下面举个反例：

package com.example.thread;/** * Created by mazhenhua on 2017/3/6. */public class VolatileTest {    static volatile int  i = 0;    public static class PlusTask implements Runnable{        @Override        public void run() {            for (int k =0; k < 10000; k++){                    i ++;            }        }    }    public static void main(String[] args) throws InterruptedException {        Thread[] threads = new Thread[10];        for (int i = 0; i < 10; i++){            threads[i] = new Thread(new PlusTask());            threads[i].start();        }        for (int i = 0; i < 10; i++){            threads[i].join();        }        System.out.println(i);    }}
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
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

执行结果，总是一个低于10万的数字。

8. 线程组
在一个系统中，如果线程数量很多，而且分工比较明确，就可以将相同功能的线程放置在一个线程组中。打个比方，你有一个苹果你可以拿在手里，如果你有10个苹果，你就需要找个篮子装起来提着，线程组就是这个篮子。代码：

package com.example.thread;/** * Created by mazhenhua on 2017/3/7. */public class ThreadGroupTest implements Runnable {    @Override    public void run() {        String groupName = Thread.currentThread().getThreadGroup().getName() + "-"                + Thread.currentThread().getName();        while (true){            System.out.println("I am " + groupName);            try {                Thread.sleep(3000);            } catch (InterruptedException e){                e.printStackTrace();            }        }    }    public static void main(String[] args) {        ThreadGroup tg = new ThreadGroup("PrintGroup");        Thread t1 = new Thread(tg, new ThreadGroupTest(),  "T1");        Thread t2 = new Thread(tg, new ThreadGroupTest(),  "T2");        t1.start();        t2.start();        System.out.println(tg.activeCount());        System.out.println();        tg.list();    }}
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
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

• activeCount()方法可以获得，活动线程的总数，但是由于线程是动态的，所以这个值只是个估计值，
• tg.list() 可以打印线程组中，所有线程的信息，对调试代码有帮助
  线程组也提供了stop()方法用来停止线程组中所有的线程，但是也会遇到和Thread.stop()一样的问题，因此使用起来要格外谨慎。

对于编码习惯而言，强烈建议大家在创建线程和线程组的时候，起一个有意义的名字，对于计算机来所，起什么名字无所谓，但是在系统出问题的时候，你很有可能导出所有的线程，如果你拿到的是一连串的Thread-0，Thread-1，Thread-2.。。。。。我想你一定会抓狂的。如果你拿到的是HttpHandler或者FTPService这样的名字，你一定会心情倍爽，查问题的效率也会提高。

9. 驻守后台，守护线程（Deamon）

守护线程是一种特殊的线程，就和他的名字一样，是系统的守护者，在后台默默地完成一些系统性的服务，比如垃圾回收线程，JIT线程就可以理解为守护线程。与之相对应的是用户线程，用户线程可以认为是系统的工作线程，他会完成这个程序应该完成的操作。如果一个java应用内，只有守护线程时，java虚拟机就会自然退出，因为已经没有需要守护的东西了。代码：

package com.example.thread;/** * Created by mazhenhua on 2017/3/7. */public class Deamon {    public static class DeamonT extends Thread {        @Override        public void run() {            while (true){                System.out.println("I am alive");                try {                    Thread.sleep(1000);                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        }    }    public static void main(String[] args) throws InterruptedException {        Thread t = new DeamonT();        t.setDaemon(true);        t.start();        Thread.sleep(2000);    }}
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
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

t.setDaemon(true); 即把线程，设置为守护线程，一定要在start线程之前设置为守护线程。这里只有一个main线程，所以在守护了2秒之后，main线程结束，接着守护线程结束。

10. 线程优先级

java中的线程可以有自己的优先级。优先级高的线程在竞争资源时会更有优势，更可能抢占资源，当然，这只是一个概率问题。线程的优先级调度和底层操作系统有关系，在各个平台表现不一样，而且这种资源抢占的结果也不好预测，可能会导致，优先级低的始终抢不到资源。因此，在要求严格的场合，还是需要自己在应用层解决线程调度问题。看个例子：

package com.example.thread;/** * Created by mazhenhua on 2017/3/7. */public class PriorityDemo {    public static final  int MIN_PRIORITY = 1;    public static final  int NORM_PRIORITY = 5;    public static final  int MAX_PRIORITY = 10;    public static class HightPriority extends  Thread {        static int count = 0;        @Override        public void run() {            while (true){                synchronized (PriorityDemo.class){                    count ++;                    if (count > 10000000) {                        System.out.println("HightPriority is complete");                        break;                    }                }            }        }    }    public static class LowPriority extends Thread {        static int count = 0;        @Override        public void run() {            while (true){                synchronized (PriorityDemo.class){                    count ++ ;                    if (count > 10000000) {                        System.out.println("LowPriority is complete");                        break;                    }                }            }        }    }    public static void main(String[] args) throws InterruptedException {        Thread high = new HightPriority();        LowPriority low = new LowPriority();        high.setPriority(Thread.MAX_PRIORITY);        low.setPriority(Thread.MIN_PRIORITY);        low.start();        high.start();    }}
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
49
50
51
52
53
54
55
56
57
58
59
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
49
50
51
52
53
54
55
56
57
58
59

代码中，在每次count累加时，都加了个synchronized来获取一次竞争，经过几次尝试HightPriority总比LowPriority跑的快，但是不保证，在所有情况下，都会是这样。

11. 线程安全的概念与synchronized

并行程序开发的一大关注重点就是线程安全。一般来说，程序并行化，是为了获得更高的执行效率，但前提是，高效率不能以牺牲正确性为代价。如果程序并行化后，连最基本的执行结果的正确性都无法保证，那么并行程序本身也就没有任何意义了。因此线程安全是并行程序的跟本。
下面的代码显示了一个计数器，两个线程同时对i进行累加操作，各执行10000000次，我们希望执行结果i的值是20000000，

package com.example.thread;/** * Created by mazhenhua on 2017/3/7. */public class Sync implements Runnable {    static Sync instance = new Sync();    static volatile int i = 0;    public static void increase(){        i ++;    }    @Override    public void run() {        for (int j = 0;  j<10000000; j ++){            increase();        }    }    public static void main(String[] args) throws InterruptedException {        Thread t1 = new Thread(instance);        Thread t2 = new Thread(instance);        t1.start();        t2.start();        t1.join();        t2.join();        System.out.println(i);    }}
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
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

但是事实上，结果总是小于我们的期望值，原因就是2个线程在同时对i进行累加的时候，会出现覆盖，的情况，比如两个线程同时拿到i的值为5，这是线程t1，累加得到结果为6，线程t2，累加得到结果6，然后同时又在赋值给i时，结果就是6，其实两个线程各累加了一次。应该是7才对。
要从根本上解决这个问题，我们就必须要保证，多个线程对i进行累加时时同步的，也就是在t1线程进行写入时，t2不能写也不能读，等t1写完成，t2线程再开始读并写。如果线程t2再t1写之前，就已经读取了，那就会出现上面的情况，读取一个已经过期的数据。java中，提供了一个重要的关键字synchronized来解决这个问题。

关键字synchronized的作用是实现线程之间的同步。他的工作室对同步代码加锁，使得每一次只有一个线程进入同步块，从而保证线程之间的安全性。
关键字synchronized有多种用法，这里做一个简单的整理
- 指定加锁对象：对给定的对象加锁，进入同步块之前获得对象锁。
- 直接作用于实例方法：相当于对当前实例加锁，进入同步代码块之前，要获得当前实例的锁
- 直接作用于静态方法：相当于对当前的类加锁，进入同步代码块之前要获得当前类的锁

改写一下上面的错误例子

    public static synchronized void increase(){        i ++;    }
1
2
3
4
1
2
3
4

在上面这个方法上，加上synchronized 关键字这样，每次只能一个线程处理完，另一个线程才能进入。
有个错误的示例：

package com.example.thread;/** * Created by mazhenhua on 2017/3/7. */public class Sync implements Runnable {   /* static Sync instance = new Sync();*/    static volatile int i = 0;    public  synchronized void increase(){        i ++;    }    @Override    public void run() {        for (int j = 0;  j<10000000; j ++){            increase();        }    }    public static void main(String[] args) throws InterruptedException {        Thread t1 = new Thread(new Sync());        Thread t2 = new Thread(new Sync());        t1.start();        t2.start();        t1.join();        t2.join();        System.out.println(i);    }}
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
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

问题就在与，加synchronized 关键字的方法不是static，也就不是作用在类上的，而且，他们俩跑的对象还不是一个，main方法中new出来了两个对象。

三、线程中的幽灵：隐蔽的错误

作为一名软件开发人员，修复程序bug应该说是基本的日常工作之一。最可怕的情况是，系统没有任何异常表现，没有日志，也没有任何错误，却给出了一个错误的结果，就想上面累加小于20000000的情况，这种情况，才真的会让人抓狂

1. 并发下的ArrayList

我们都知道ArrayList并不是一个线程安全的容器，如果在多线程中使用ArrayList，可能会导致程序出错，请看如下代码：

package com.example.thread;import java.util.ArrayList;/** * Created by mazhenhua on 2017/3/7. */public class ArrayListTest {    static ArrayList<Integer> al = new ArrayList<Integer>(10);    public static class AddThread implements Runnable{        @Override        public void run() {            for (int i = 0; i < 1000000; i++){                al.add(i);            }        }    }    public static void main(String[] args) throws InterruptedException {        Thread t1 = new Thread(new AddThread());        Thread t2 = new Thread(new AddThread());        t1.start();        t2.start();        t1.join();        t2.join();        System.out.println(al.size());    }}
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
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

下面是我执行的结果：

执行上面的代码实际上应该会出现三种情况(我跑了多次只出来这两种情况)
第一，程序正常结束，ArrayList的最终大小确实是2000000，这说明程序中有问题，但是并不是每次都能表现出来。
第二，程序抛异常，就想上面第一次的结果，这是因为ArrayList在扩容的过程中，内部一致性被破坏了，另一个线程访问到了不一致的内部状态，导致出现越界问题。
第三，出现了一个非常隐蔽的错误，就像上面的第二个结果，打印出来的值小于预期的值。

显然，这是由于多线程访问冲突，是的保存容器大小的变量，被多线程不正常的访问，同时，两个线程也同时对ArrayList中的同一个位置进行赋值，导致的。
改进方法很简单，使用线程安全的Vector代替ArrayList即可。

2. 并发下诡异的HashMap

HashMap同样不是线程安全的。当你使用多线程访问HashMap时，也可能会遇到想不到的错误。不过和ArrayList不同，HashMap的问题似乎更加诡异。以下代码可能会占用2个cpu，我的是四核电脑，CPU使用率在60%左右，

package com.example.thread;import java.util.HashMap;import java.util.Map;/** * Created by mazhenhua on 2017/3/7. */public class HashMapTest {    static Map<String, String> map = new HashMap<String, String>();    public static class AddThread implements Runnable{        int start = 0;        public AddThread(int start) {            this.start = start;        }        @Override        public void run() {            for (int i = start; i < 100000; i+=2){                map.put(Integer.toString(i),Integer.toBinaryString(i));            }        }    }    public static void main(String[] args) throws InterruptedException{        Thread t1 = new Thread(new AddThread(0));        Thread t2 = new Thread(new AddThread(1));        t1.start();        t2.start();        t1.join();        t2.join();        System.out.println(map.size());    }}
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
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

上述代码使用线程t1，t2两个线程同时对HashMap进行put操作。如果一切正常，我们期望，得到map.size()就是100000，但实际上，你可能会得到如下三种请看（注意是在JDK1.7的情况下，因为JDK1.8对HashMap内部做了很大的重构）
第一，程序正常结束，并且结果也符合预期，
第二，程序正常结束，不符合预期，而是一个小于100000的数字
第三，程序永远无法结束，就像上面的截图。

前两种情况都好解释，跟ArrayList一样，第三种情况是，多线程破坏了HashMap的内部结构，链表成了环，一直在迭代列表，就成死循环。最好的方法，就是在多线程的时候用ConcurrentHashMap替换掉。HashMap这个问题，在JDK1.8中已经被修改了。