# Java 多线程学习（吐血超详细总结）

写在前面的话：此文只能说是 java 多线程的一个入门，其实 Java 里头线程完全可以写一本书了，但是如果最基本的你都学掌握好，又怎么能更上一个台阶呢？如果你觉得此文很简单，那推荐你看看 Java 并发包的的线程池（Java 并发编程与技术内幕：线程池深入理解），或者看这个专栏：Java 并发编程与技术内幕。你将会对 Java 里头的高并发场景下的线程有更加深刻的理解。

目录 (?)[-]

1. 一扩展 javalangThread 类
2. 二实现 javalangRunnable 接口
3. 三 Thread 和 Runnable 的区别
4. 四线程状态转换
5. 五线程调度
6. 六常用函数说明
7. 1. 使用方式
   2. 为什么要用 join 方法
8. 七常见线程名词解释
9. 八线程同步
10. 九线程数据传递

​ 本文主要讲了 java 中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。在这之前，首先让我们来了解下在操作系统中进程和线程的区别：

进程：每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含 1–n 个线程。（进程是资源分配的最小单位）

线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器 (PC)，线程切换开销小。（线程是 cpu 调度的最小单位）

线程和进程一样分为五个阶段：创建、就绪、运行、阻塞、终止。

多进程是指操作系统能同时运行多个任务（程序）。

多线程是指在同一程序中有多个顺序流在执行。

在 java 中要想实现多线程，有两种手段，一种是继续 Thread 类，另外一种是实现 Runable 接口.(其实准确来讲，应该有三种，还有一种是实现 Callable 接口，并与 Future、线程池结合使用，此文这里不讲这个，有兴趣看这里 Java 并发编程与技术内幕：Callable、Future、FutureTask、CompletionService )

# 一、扩展 java.lang.Thread 类

这里继承 Thread 类的方法是比较常用的一种，如果说你只是想起一条线程。没有什么其它特殊的要求，那么可以使用 Thread.（笔者推荐使用 Runable，后头会说明为什么）。下面来看一个简单的实例

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

package com.multithread.learning;

class Thread1 extends Thread{

	private String name;

    public Thread1(String name) {

       this.name=name;

    }



	public void run() {



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



            System.out.println(name + "运行  :  " + i);



            try {



                sleep((int) Math.random() * 10);



            } catch (InterruptedException e) {



                e.printStackTrace();



            }



        }



       



	}



}



public class Main {



 



	public static void main(String[] args) {



		Thread1 mTh1=new Thread1("A");



		Thread1 mTh2=new Thread1("B");



		mTh1.start();



		mTh2.start();



 



	}



 



}

输出：

A 运行 : 0
B 运行 : 0
A 运行 : 1
A 运行 : 2
A 运行 : 3
A 运行 : 4
B 运行 : 1
B 运行 : 2
B 运行 : 3
B 运行 : 4

再运行一下：

A 运行 : 0
B 运行 : 0
B 运行 : 1
B 运行 : 2
B 运行 : 3
B 运行 : 4
A 运行 : 1
A 运行 : 2
A 运行 : 3
A 运行 : 4

说明：

程序启动运行 main 时候，java 虚拟机启动一个进程，主线程 main 在 main () 调用时候被创建。随着调用 MitiSay 的两个对象的 start 方法，另外两个线程也启动了，这样，整个应用就在多线程下运行。

注意：start () 方法的调用后并不是立即执行多线程代码，而是使得该线程变为可运行态（Runnable），什么时候运行是由操作系统决定的。

从程序运行的结果可以发现，多线程程序是乱序执行。因此，只有乱序执行的代码才有必要设计为多线程。

Thread.sleep () 方法调用目的是不让当前线程独自霸占该进程所获取的 CPU 资源，以留出一定时间给其他线程执行的机会。

实际上所有的多线程代码执行顺序都是不确定的，每次执行的结果都是随机的。

但是 start 方法重复调用的话，会出现 java.lang.IllegalThreadStateException 异常。

1
2
3
4
5
6
7
8
9
10
11
12
13

Thread1 mTh1=new Thread1("A");



Thread1 mTh2=mTh1;



mTh1.start();



mTh2.start();

输出：

Exception in thread “main” java.lang.IllegalThreadStateException
at java.lang.Thread.start(Unknown Source)
at com.multithread.learning.Main.main(Main.java:31)
A 运行 : 0
A 运行 : 1
A 运行 : 2
A 运行 : 3
A 运行 : 4

# 二、实现 java.lang.Runnable 接口

采用 Runnable 也是非常常见的一种，我们只需要重写 run 方法即可。下面也来看个实例。

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

/**



 *@functon 多线程学习



 *@author 林炳文



 *@time 2015.3.9



 */



package com.multithread.runnable;



class Thread2 implements Runnable{



	private String name;



 



	public Thread2(String name) {



		this.name=name;



	}



 



	@Override



	public void run() {



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



	            System.out.println(name + "运行  :  " + i);



	            try {



	            	Thread.sleep((int) Math.random() * 10);



	            } catch (InterruptedException e) {



	                e.printStackTrace();



	            }



	        }



		



	}



	



}



public class Main {



 



	public static void main(String[] args) {



		new Thread(new Thread2("C")).start();



		new Thread(new Thread2("D")).start();



	}



 



}

输出：

C 运行 : 0
D 运行 : 0
D 运行 : 1
C 运行 : 1
D 运行 : 2
C 运行 : 2
D 运行 : 3
C 运行 : 3
D 运行 : 4
C 运行 : 4

说明：

Thread2 类通过实现 Runnable 接口，使得该类有了多线程类的特征。run（）方法是多线程程序的一个约定。所有的多线程代码都在 run 方法里面。Thread 类实际上也是实现了 Runnable 接口的类。

在启动的多线程的时候，需要先通过 Thread 类的构造方法 Thread (Runnable target) 构造出对象，然后调用 Thread 对象的 start () 方法来运行多线程代码。

实际上所有的多线程代码都是通过运行 Thread 的 start () 方法来运行的。因此，不管是扩展 Thread 类还是实现 Runnable 接口来实现多线程，最终还是通过 Thread 的对象的 API 来控制线程的，熟悉 Thread 类的 API 是进行多线程编程的基础。

# 三、Thread 和 Runnable 的区别

如果一个类继承 Thread，则不适合资源共享。但是如果实现了 Runable 接口的话，则很容易的实现资源共享。

** 总结：
**

实现 Runnable 接口比继承 Thread 类所具有的优势：

1）：适合多个相同的程序代码的线程去处理同一个资源

2）：可以避免 java 中的单继承的限制

3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立

4）：线程池只能放入实现 Runable 或 callable 类线程，不能直接放入继承 Thread 的类

* 提醒一下大家：**main** 方法其实也是一个线程。在 **java** 中所以的线程都是同时启动的，至于什么时候，哪个先执行，完全看谁先得到 **CPU** 的资源。*

在 java 中，每次程序运行至少启动 2 个线程。一个是 main 线程，一个是垃圾收集线程。因为每当使用 java 命令执行一个类的时候，实际上都会启动一个ＪＶＭ，每一个ｊＶＭ实习在就是在操作系统中启动了一个进程。

# 四、线程状态转换

下面的这个图非常重要！你如果看懂了这个图，那么对于多线程的理解将会更加深刻！

1、新建状态（New）：新创建了一个线程对象。

2、就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的 start () 方法。该状态的线程位于可运行线程池中，变得可运行，等待获取 CPU 的使用权。

3、运行状态（Running）：就绪状态的线程获取了 CPU，执行程序代码。

4、阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃 CPU 使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：

（一）、等待阻塞：运行的线程执行 wait () 方法，JVM 会把该线程放入等待池中。(wait 会释放持有的锁)

（二）、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则 JVM 会把该线程放入锁池中。

（三）、其他阻塞：运行的线程执行 sleep () 或 join () 方法，或者发出了 I/O 请求时，JVM 会把该线程置为阻塞状态。当 sleep () 状态超时、join () 等待线程终止或者超时、或者 I/O 处理完毕时，线程重新转入就绪状态。（注意，sleep 是不会释放持有的锁）

5、死亡状态（Dead）：线程执行完了或者因异常退出了 run () 方法，该线程结束生命周期。

# 五、线程调度

线程的调度

1、调整线程优先级：Java 线程有优先级，优先级高的线程会获得较多的运行机会。

Java 线程的优先级用整数表示，取值范围是 1~10，Thread 类有以下三个静态常量：

1
2
3
4
5
6

static int MAX_PRIORITY
          线程可以具有的最高优先级，取值为10。
static int MIN_PRIORITY
          线程可以具有的最低优先级，取值为1。
static int NORM_PRIORITY
          分配给线程的默认优先级，取值为5。

Thread 类的 setPriority () 和 getPriority () 方法分别用来设置和获取线程的优先级。

每个线程都有默认的优先级。主线程的默认优先级为 Thread.NORM_PRIORITY。

线程的优先级有继承关系，比如 A 线程中创建了 B 线程，那么 B 将和 A 具有相同的优先级。

JVM 提供了 10 个线程优先级，但与常见的操作系统都不能很好的映射。如果希望程序能移植到各个操作系统中，应该仅仅使用 Thread 类有以下三个静态常量作为优先级，这样能保证同样的优先级采用了同样的调度方式。

2、线程睡眠：Thread.sleep (long millis) 方法，使线程转到阻塞状态。millis 参数设定睡眠的时间，以毫秒为单位。当睡眠结束后，就转为就绪（Runnable）状态。sleep () 平台移植性好。

3、线程等待：Object 类中的 wait () 方法，导致当前的线程等待，直到其他线程调用此对象的 notify () 方法或 notifyAll () 唤醒方法。这个两个唤醒方法也是 Object 类中的方法，行为等价于调用 wait (0) 一样。

4、线程让步：Thread.yield () 方法，暂停当前正在执行的线程对象，把执行机会让给相同或者更高优先级的线程。

5、线程加入：join () 方法，等待其他线程终止。在当前线程中调用另一个线程的 join () 方法，则当前线程转入阻塞状态，直到另一个进程运行结束，当前线程再由阻塞转为就绪状态。

6、线程唤醒：Object 类中的 notify () 方法，唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。线程通过调用其中一个 wait 方法，在对象的监视器上等待。 直到当前的线程放弃此对象上的锁定，才能继续执行被唤醒的线程。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争；例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。类似的方法还有一个 notifyAll ()，唤醒在此对象监视器上等待的所有线程。

注意：Thread 中 suspend () 和 resume () 两个方法在 JDK1.5 中已经废除，不再介绍。因为有死锁倾向。

# 六、常用函数说明

**①sleep (long millis): 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）

②join (): 指等待 t 线程终止。**

# 使用方式。

join 是 Thread 类的一个方法，启动线程后直接调用，即 join () 的作用是：“等待该线程终止”，这里需要理解的就是该线程是指的主线程等待子线程的终止。也就是在子线程调用了 join () 方法后面的代码，只有等到子线程结束了才能执行。

1

Thread t = new AThread(); t.start(); t.join();

# 为什么要用 join () 方法

在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到 join () 方法了。

不加 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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

/**



 *@functon 多线程学习,join



 *@author 林炳文



 *@time 2015.3.9



 */



package com.multithread.join;



class Thread1 extends Thread{



	private String name;



    public Thread1(String name) {



    	super(name);



       this.name=name;



    }



	public void run() {



		System.out.println(Thread.currentThread().getName() + " 线程运行开始!");



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



            System.out.println("子线程"+name + "运行 : " + i);



            try {



                sleep((int) Math.random() * 10);



            } catch (InterruptedException e) {



                e.printStackTrace();



            }



        }



        System.out.println(Thread.currentThread().getName() + " 线程运行结束!");



	}



}



 



public class Main {



 



	public static void main(String[] args) {



		System.out.println(Thread.currentThread().getName()+"主线程运行开始!");



		Thread1 mTh1=new Thread1("A");



		Thread1 mTh2=new Thread1("B");



		mTh1.start();



		mTh2.start();



		System.out.println(Thread.currentThread().getName()+ "主线程运行结束!");



 



	}



 



}



 



 



 

输出结果：
main 主线程运行开始！
main 主线程运行结束！
B 线程运行开始！
子线程 B 运行 : 0
A 线程运行开始！
子线程 A 运行 : 0
子线程 B 运行 : 1
子线程 A 运行 : 1
子线程 A 运行 : 2
子线程 A 运行 : 3
子线程 A 运行 : 4
A 线程运行结束！
子线程 B 运行 : 2
子线程 B 运行 : 3
子线程 B 运行 : 4
B 线程运行结束！
发现主线程比子线程早结束

加 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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

public class Main {



 



	public static void main(String[] args) {



		System.out.println(Thread.currentThread().getName()+"主线程运行开始!");



		Thread1 mTh1=new Thread1("A");



		Thread1 mTh2=new Thread1("B");



		mTh1.start();



		mTh2.start();



		try {



			mTh1.join();



		} catch (InterruptedException e) {



			e.printStackTrace();



		}



		try {



			mTh2.join();



		} catch (InterruptedException e) {



			e.printStackTrace();



		}



		System.out.println(Thread.currentThread().getName()+ "主线程运行结束!");



 



	}



 



}

运行结果：
main 主线程运行开始！
A 线程运行开始！
子线程 A 运行 : 0
B 线程运行开始！
子线程 B 运行 : 0
子线程 A 运行 : 1
子线程 B 运行 : 1
子线程 A 运行 : 2
子线程 B 运行 : 2
子线程 A 运行 : 3
子线程 B 运行 : 3
子线程 A 运行 : 4
子线程 B 运行 : 4
A 线程运行结束！
主线程一定会等子线程都结束了才结束

③yield (): 暂停当前正在执行的线程对象，并执行其他线程。

​ Thread.yield () 方法作用是：暂停当前正在执行的线程对象，并执行其他线程。

​ ****yield () 应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。**** 因此，使用 yield () 的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证 yield () 达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。

结论：yield () 从未导致线程转到等待 / 睡眠 / 阻塞状态。在大多数情况下，yield () 将导致线程从运行状态转到可运行状态，但有可能没有效果。可看上面的图。

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

/**



 *@functon 多线程学习 yield



 *@author 林炳文



 *@time 2015.3.9



 */



package com.multithread.yield;



class ThreadYield extends Thread{



    public ThreadYield(String name) {



        super(name);



    }



 



    @Override



    public void run() {



        for (int i = 1; i <= 50; i++) {



            System.out.println("" + this.getName() + "-----" + i);



            // 当i为30时，该线程就会把CPU时间让掉，让其他或者自己的线程执行（也就是谁先抢到谁执行）



            if (i ==30) {



                this.yield();



            }



        }



	



}



}



 



public class Main {



 



	public static void main(String[] args) {



		



		ThreadYield yt1 = new ThreadYield("张三");



    	ThreadYield yt2 = new ThreadYield("李四");



        yt1.start();



        yt2.start();



	}



 



}

运行结果：

第一种情况：李四（线程）当执行到 30 时会 CPU 时间让掉，这时张三（线程）抢到 CPU 时间并执行。

第二种情况：李四（线程）当执行到 30 时会 CPU 时间让掉，这时李四（线程）抢到 CPU 时间并执行。

sleep () 和 yield () 的区别
sleep () 和 yield () 的区别):sleep () 使当前线程进入停滞状态，所以执行 sleep () 的线程在指定的时间内肯定不会被执行；yield () 只是使当前线程重新回到可执行状态，所以执行 yield () 的线程有可能在进入到可执行状态后马上又被执行。
sleep 方法使当前运行中的线程睡眼一段时间，进入不可运行状态，这段时间的长短是由程序设定的，yield 方法使当前线程让出 CPU 占有权，但让出的时间是不可设定的。实际上，yield () 方法对应了如下操作：先检测当前是否有相同优先级的线程处于同可运行状态，如有，则把 CPU 的占有权交给此线程，否则，继续运行原来的线程。所以 yield () 方法称为 “退让”，它把运行机会让给了同等优先级的其他线程
另外，sleep 方法允许较低优先级的线程获得运行机会，但 yield () 方法执行时，当前线程仍处在可运行状态，所以，不可能让出较低优先级的线程些时获得 CPU 占有权。在一个运行系统中，如果较高优先级的线程没有调用 sleep 方法，又没有受到 I\O 阻塞，那么，较低优先级线程只能等待所有较高优先级的线程运行结束，才有机会运行。

④setPriority (): 更改线程的优先级。

MIN_PRIORITY = 1
　　 NORM_PRIORITY = 5
MAX_PRIORITY = 10

用法：

1
2
3
4

Thread4 t1 = new Thread4("t1");
Thread4 t2 = new Thread4("t2");
t1.setPriority(Thread.MAX_PRIORITY);
t2.setPriority(Thread.MIN_PRIORITY);

*⑤interrupt (): 不要以为它是中断某个线程！它只是线线程发送一个中断信号，让线程在无限等待时（如死锁时）能抛出抛出，从而结束线程，但是如果你吃掉了这个异常，那么 ** 这个线程还是不会中断的！*

⑥wait()

Obj.wait ()，与 Obj.notify () 必须要与 synchronized (Obj) 一起使用，也就是 wait, 与 notify 是针对已经获取了 Obj 锁进行操作，从语法角度来说就是 Obj.wait (),Obj.notify 必须在 synchronized (Obj){…} 语句块内。从功能上来说 wait 就是说线程在获取对象锁后，主动释放对象锁，同时本线程休眠。直到有其它线程调用对象的 notify () 唤醒该线程，才能继续获取对象锁，并继续执行。相应的 notify () 就是对对象锁的唤醒操作。但有一点需要注意的是 notify () 调用后，并不是马上就释放对象锁的，而是在相应的 synchronized (){} 语句块执行结束，自动释放锁后，JVM 会在 wait () 对象锁的线程中随机选取一线程，赋予其对象锁，唤醒线程，继续执行。这样就提供了在线程间同步、唤醒的操作。Thread.sleep () 与 Object.wait () 二者都可以暂停当前线程，释放 CPU 控制权，主要的区别在于 Object.wait () 在释放 CPU 同时，释放了对象锁的控制。

单单在概念上理解清楚了还不够，需要在实际的例子中进行测试才能更好的理解。对 Object.wait ()，Object.notify () 的应用最经典的例子，应该是三线程打印 ABC 的问题了吧，这是一道比较经典的面试题，题目要求如下：

建立三个线程，A 线程打印 10 次 A，B 线程打印 10 次 B,C 线程打印 10 次 C，要求线程同时运行，交替打印 10 次 ABC。这个问题用 Object 的 wait ()，notify () 就可以很方便的解决。代码如下：

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225

/**



 * wait用法



 * @author DreamSea 



 * @time 2015.3.9 



 */



package com.multithread.wait;



public class MyThreadPrinter2 implements Runnable {   



	  



    private String name;   



    private Object prev;   



    private Object self;   



  



    private MyThreadPrinter2(String name, Object prev, Object self) {   



        this.name = name;   



        this.prev = prev;   



        this.self = self;   



    }   



  



    @Override  



    public void run() {   



        int count = 10;   



        while (count > 0) {   



            synchronized (prev) {   



                synchronized (self) {   



                    System.out.print(name);   



                    count--;  



                    



                    self.notify();   



                }   



                try {   



                    prev.wait();   



                } catch (InterruptedException e) {   



                    e.printStackTrace();   



                }   



            }   



  



        }   



    }   



  



    public static void main(String[] args) throws Exception {   



        Object a = new Object();   



        Object b = new Object();   



        Object c = new Object();   



        MyThreadPrinter2 pa = new MyThreadPrinter2("A", c, a);   



        MyThreadPrinter2 pb = new MyThreadPrinter2("B", a, b);   



        MyThreadPrinter2 pc = new MyThreadPrinter2("C", b, c);   



           



           



        new Thread(pa).start();



        Thread.sleep(100);  //确保按顺序A、B、C执行



        new Thread(pb).start();



        Thread.sleep(100);  



        new Thread(pc).start();   



        Thread.sleep(100);  



        }   



}  



 

输出结果：

ABCABCABCABCABCABCABCABCABCABC

先来解释一下其整体思路，从大的方向上来讲，该问题为三线程间的同步唤醒操作，主要的目的就是 ThreadA->ThreadB->ThreadC->ThreadA 循环执行三个线程。为了控制线程执行的顺序，那么就必须要确定唤醒、等待的顺序，所以每一个线程必须同时持有两个对象锁，才能继续执行。一个对象锁是 prev，就是前一个线程所持有的对象锁。还有一个就是自身对象锁。主要的思想就是，为了控制执行的顺序，必须要先持有 prev 锁，也就前一个线程要释放自身对象锁，再去申请自身对象锁，两者兼备时打印，之后首先调用 self.notify () 释放自身对象锁，唤醒下一个等待线程，再调用 prev.wait () 释放 prev 对象锁，终止当前线程，等待循环结束后再次被唤醒。运行上述代码，可以发现三个线程循环打印 ABC，共 10 次。程序运行的主要过程就是 A 线程最先运行，持有 C,A 对象锁，后释放 A,C 锁，唤醒 B。线程 B 等待 A 锁，再申请 B 锁，后打印 B，再释放 B，A 锁，唤醒 C，线程 C 等待 B 锁，再申请 C 锁，后打印 C，再释放 C,B 锁，唤醒 A。看起来似乎没什么问题，但如果你仔细想一下，就会发现有问题，就是初始条件，三个线程按照 A,B,C 的顺序来启动，按照前面的思考，A 唤醒 B，B 唤醒 C，C 再唤醒 A。但是这种假设依赖于 JVM 中线程调度、执行的顺序。
wait 和 sleep 区别
共同点：
\1. 他们都是在多线程的环境下，都可以在程序的调用处阻塞指定的毫秒数，并返回。
\2. wait () 和 sleep () 都可以通过 interrupt () 方法 打断线程的暂停状态 ，从而使线程立刻抛出 InterruptedException。
如果线程 A 希望立即结束线程 B，则可以对线程 B 对应的 Thread 实例调用 interrupt 方法。如果此刻线程 B 正在 wait/sleep/join，则线程 B 会立刻抛出 InterruptedException，在 catch () {} 中直接 return 即可安全地结束线程。
需要注意的是，InterruptedException 是线程自己从内部抛出的，并不是 interrupt () 方法抛出的。对某一线程调用 interrupt () 时，如果该线程正在执行普通的代码，那么该线程根本就不会抛出 InterruptedException。但是，一旦该线程进入到 wait ()/sleep ()/join () 后，就会立刻抛出 InterruptedException 。
不同点：
\1. Thread 类的方法：sleep (),yield () 等
Object 的方法：wait () 和 notify () 等
\2. 每个对象都有一个锁来控制同步访问。Synchronized 关键字可以和对象的锁交互，来实现线程的同步。
sleep 方法没有释放锁，而 wait 方法释放了锁，使得其他线程可以使用同步控制块或者方法。
\3. wait，notify 和 notifyAll 只能在同步控制方法或者同步控制块里面使用，而 sleep 可以在任何地方使用
所以 sleep () 和 wait () 方法的最大区别是：
　　　　sleep () 睡眠时，保持对象锁，仍然占有该锁；
　　　　而 wait () 睡眠时，释放对象锁。
　　但是 wait () 和 sleep () 都可以通过 interrupt () 方法打断线程的暂停状态，从而使线程立刻抛出 InterruptedException（但不建议使用该方法）。
sleep（）方法
sleep () 使当前线程进入停滞状态（阻塞当前线程），让出 CUP 的使用、目的是不让当前线程独自霸占该进程所获的 CPU 资源，以留一定时间给其他线程执行的机会；
　　 sleep () 是 Thread 类的 Static (静态) 的方法；因此他不能改变对象的机锁，所以当在一个 Synchronized 块中调用 Sleep () 方法是，线程虽然休眠了，但是对象的机锁并木有被释放，其他线程无法访问这个对象（即使睡着也持有对象锁）。
　　在 sleep () 休眠时间期满后，该线程不一定会立即执行，这是因为其它线程可能正在运行而且没有被调度为放弃执行，除非此线程具有更高的优先级。
wait（）方法
wait () 方法是 Object 类里的方法；当一个线程执行到 wait () 方法时，它就进入到一个和该对象相关的等待池中，同时失去（释放）了对象的机锁（暂时失去机锁，wait (long timeout) 超时时间到后还需要返还对象锁）；其他线程可以访问；
　　wait () 使用 notify 或者 notifyAlll 或者指定睡眠时间来唤醒当前等待池中的线程。
　　wiat () 必须放在 synchronized block 中，否则会在 program runtime 时扔出”java.lang.IllegalMonitorStateException“异常。

# 七、常见线程名词解释

主线程：JVM 调用程序 main () 所产生的线程。

当前线程：这个是容易混淆的概念。一般指通过 Thread.currentThread () 来获取的进程。

后台线程：指为其他线程提供服务的线程，也称为守护线程。JVM 的垃圾回收线程就是一个后台线程。 用户线程和守护线程的区别在于，是否等待主线程依赖于主线程结束而结束

前台线程：是指接受后台线程服务的线程，其实前台后台线程是联系在一起，就像傀儡和幕后操纵者一样的关系。傀儡是前台线程、幕后操纵者是后台线程。由前台线程创建的线程默认也是前台线程。可以通过 isDaemon () 和 setDaemon () 方法来判断和设置一个线程是否为后台线程。

** 线程类的一些常用方法：

sleep (): 强迫一个线程睡眠Ｎ毫秒。
　　isAlive (): 判断一个线程是否存活。
　　join (): 等待线程终止。
　　activeCount (): 程序中活跃的线程数。
　　enumerate (): 枚举程序中的线程。
currentThread (): 得到当前线程。
　　isDaemon (): 一个线程是否为守护线程。
　　setDaemon (): 设置一个线程为守护线程。(用户线程和守护线程的区别在于，是否等待主线程依赖于主线程结束而结束)
　　setName (): 为线程设置一个名称。
　　wait (): 强迫一个线程等待。
　　notify (): 通知一个线程继续运行。
　　setPriority (): 设置一个线程的优先级。
**

# 八、线程同步

1、synchronized 关键字的作用域有二种：
1）是某个对象实例内，synchronized aMethod (){} 可以防止多个线程同时访问这个对象的 synchronized 方法（如果一个对象有多个 synchronized 方法，只要一个线程访问了其中的一个 synchronized 方法，其它线程不能同时访问这个对象中任何一个 synchronized 方法）。这时，不同的对象实例的 synchronized 方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的 synchronized 方法；
2）是某个类的范围，synchronized static aStaticMethod {} 防止多个线程同时访问这个类中的 synchronized static 方法。它可以对类的所有对象实例起作用。

2、除了方法前用 synchronized 关键字，synchronized 关键字还可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。用法是: synchronized (this){/ 区块 /}，它的作用域是当前对象；

3、synchronized 关键字是不能继承的，也就是说，基类的方法 synchronized f (){} 在继承类中并不自动是 synchronized f (){}，而是变成了 f (){}。继承类需要你显式的指定它的某个方法为 synchronized 方法；

Java 对多线程的支持与同步机制深受大家的喜爱，似乎看起来使用了 synchronized 关键字就可以轻松地解决多线程共享数据同步问题。到底如何？――还得对 synchronized 关键字的作用进行深入了解才可定论。

总的说来，synchronized 关键字可以作为函数的修饰符，也可作为函数内的语句，也就是平时说的同步方法和同步语句块。如果再细的分类，synchronized 可作用于 instance 变量、object reference（对象引用）、static 函数和 class literals (类名称字面常量) 身上。

在进一步阐述之前，我们需要明确几点：

A．无论 synchronized 关键字加在方法上还是对象上，它取得的锁都是对象，而不是把一段代码或函数当作锁――而且同步方法很可能还会被其他线程的对象访问。

B．每个对象只有一个锁（lock）与之相关联。

C．实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。

接着来讨论 synchronized 用到不同地方对代码产生的影响：

假设 P1、P2 是同一个类的不同对象，这个类中定义了以下几种情况的同步块或同步方法，P1、P2 就都可以调用它们。

1． 把 synchronized 当作函数修饰符时，示例代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13

Public synchronized void methodAAA()



{



//….



}

这也就是同步方法，那这时 synchronized 锁定的是哪个对象呢？它锁定的是调用这个同步方法对象。也就是说，当一个对象 P1 在不同的线程中执行这个同步方法时，它们之间会形成互斥，达到同步的效果。但是这个对象所属的 Class 所产生的另一对象 P2 却可以任意调用这个被加了 synchronized 关键字的方法。

上边的示例代码等同于如下代码：

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

public void methodAAA()



{



synchronized (this)      //  (1)



{



       //…..



}



}

(1) 处的 this 指的是什么呢？它指的就是调用这个方法的对象，如 P1。可见同步方法实质是将 synchronized 作用于 object reference。――那个拿到了 P1 对象锁的线程，才可以调用 P1 的同步方法，而对 P2 而言，P1 这个锁与它毫不相干，程序也可能在这种情形下摆脱同步机制的控制，造成数据混乱：（

2．同步块，示例代码如下：

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

            public void method3(SomeObject so)



              {



                     synchronized(so)



{



       //…..



}



}

这时，锁就是 so 这个对象，谁拿到这个锁谁就可以运行它所控制的那段代码。当有一个明确的对象作为锁时，就可以这样写程序，但当没有明确的对象作为锁，只是想让一段代码同步时，可以创建一个特殊的 instance 变量（它得是一个对象）来充当锁：

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

class Foo implements Runnable



{



       private byte[] lock = new byte[0];  // 特殊的instance变量



    Public void methodA()



{



       synchronized(lock) { //… }



}



//…..



}

注：零长度的 byte 数组对象创建起来将比任何对象都经济――查看编译后的字节码：生成零长度的 byte [] 对象只需 3 条操作码，而 Object lock = new Object () 则需要 7 行操作码。

3．将 synchronized 作用于 static 函数，示例代码如下：

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

Class Foo



{



public synchronized static void methodAAA()   // 同步的static 函数



{



//….



}



public void methodBBB()



{



       synchronized(Foo.class)   //  class literal(类名称字面常量)



}



       }

代码中的 methodBBB () 方法是把 class literal 作为锁的情况，它和同步的 static 函数产生的效果是一样的，取得的锁很特别，是当前调用这个方法的对象所属的类（Class，而不再是由这个 Class 产生的某个具体对象了）。

记得在《Effective Java》一书中看到过将 Foo.class 和 P1.getClass () 用于作同步锁还不一样，不能用 P1.getClass () 来达到锁这个 Class 的目的。P1 指的是由 Foo 类产生的对象。

可以推断：如果一个类中定义了一个 synchronized 的 static 函数 A，也定义了一个 synchronized 的 instance 函数 B，那么这个类的同一对象 Obj 在多线程中分别访问 A 和 B 两个方法时，不会构成同步，因为它们的锁都不一样。A 方法的锁是 Obj 这个对象，而 B 的锁是 Obj 所属的那个 Class。

总结一下：

1、线程同步的目的是为了保护多个线程反问一个资源时对资源的破坏。
2、线程同步方法是通过锁来实现，每个对象都有切仅有一个锁，这个锁与一个特定的对象关联，线程一旦获取了对象锁，其他访问该对象的线程就无法再访问该对象的其他非同步方法
3、对于静态同步方法，锁是针对这个类的，锁对象是该类的 Class 对象。静态和非静态方法的锁互不干预。一个线程获得锁，当在一个同步方法中访问另外对象上的同步方法时，会获取这两个对象锁。
4、对于同步，要时刻清醒在哪个对象上同步，这是关键。
5、编写线程安全的类，需要时刻注意对多个线程竞争访问资源的逻辑和安全做出正确的判断，对 “原子” 操作做出分析，并保证原子操作期间别的线程无法访问竞争资源。
6、当多个线程等待一个对象锁时，没有获取到锁的线程将发生阻塞。
7、死锁是线程间相互等待锁锁造成的，在实际中发生的概率非常的小。真让你写个死锁程序，不一定好使，呵呵。但是，一旦程序发生死锁，程序将死掉。

# 九、线程数据传递

在传统的同步开发模式下，当我们调用一个函数时，通过这个函数的参数将数据传入，并通过这个函数的返回值来返回最终的计算结果。但在多线程的异步开发模式下，数据的传递和返回和同步开发模式有很大的区别。由于线程的运行和结束是不可预料的，因此，在传递和返回数据时就无法象函数一样通过函数参数和 return 语句来返回数据。

9.1、通过构造方法传递数据
在创建线程时，必须要建立一个 Thread 类的或其子类的实例。因此，我们不难想到在调用 start 方法之前通过线程类的构造方法将数据传入线程。并将传入的数据使用类变量保存起来，以便线程使用 (其实就是在 run 方法中使用)。下面的代码演示了如何通过构造方法来传递数据：

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
60
61
62
63
64
65
66
67
68
69

package mythread; 



public class MyThread1 extends Thread 



{ 



private String name; 



public MyThread1(String name) 



{ 



this.name = name; 



} 



public void run() 



{ 



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



} 



public static void main(String[] args) 



{ 



Thread thread = new MyThread1("world"); 



thread.start(); 



} 



} 

由于这种方法是在创建线程对象的同时传递数据的，因此，在线程运行之前这些数据就就已经到位了，这样就不会造成数据在线程运行后才传入的现象。如果要传递更复杂的数据，可以使用集合、类等数据结构。使用构造方法来传递数据虽然比较安全，但如果要传递的数据比较多时，就会造成很多不便。由于 Java 没有默认参数，要想实现类似默认参数的效果，就得使用重载，这样不但使构造方法本身过于复杂，又会使构造方法在数量上大增。因此，要想避免这种情况，就得通过类方法或类变量来传递数据。

9.2、通过变量和方法传递数据
向对象中传入数据一般有两次机会，第一次机会是在建立对象时通过构造方法将数据传入，另外一次机会就是在类中定义一系列的 public 的方法或变量（也可称之为字段）。然后在建立完对象后，通过对象实例逐个赋值。下面的代码是对 MyThread1 类的改版，使用了一个 setName 方法来设置 name 变量：

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

package mythread; 



public class MyThread2 implements Runnable 



{ 



private String name; 



public void setName(String name) 



{ 



this.name = name; 



} 



public void run() 



{ 



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



} 



public static void main(String[] args) 



{ 



MyThread2 myThread = new MyThread2(); 



myThread.setName("world"); 



Thread thread = new Thread(myThread); 



thread.start(); 



} 



} 

9.3、通过回调函数传递数据

上面讨论的两种向线程中传递数据的方法是最常用的。但这两种方法都是 main 方法中主动将数据传入线程类的。这对于线程来说，是被动接收这些数据的。然而，在有些应用中需要在线程运行的过程中动态地获取数据，如在下面代码的 run 方法中产生了 3 个随机数，然后通过 Work 类的 process 方法求这三个随机数的和，并通过 Data 类的 value 将结果返回。从这个例子可以看出，在返回 value 之前，必须要得到三个随机数。也就是说，这个 value 是无法事先就传入线程类的。

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

package mythread; 



class Data 



{ 



public int value = 0; 



} 



class Work 



{ 



public void process(Data data, Integer numbers) 



{ 



for (int n : numbers) 



{ 



data.value += n; 



} 



} 



} 



public class MyThread3 extends Thread 



{ 



private Work work; 



public MyThread3(Work work) 



{ 



this.work = work; 



} 



public void run() 



{ 



java.util.Random random = new java.util.Random(); 



Data data = new Data(); 



int n1 = random.nextInt(1000); 



int n2 = random.nextInt(2000); 



int n3 = random.nextInt(3000); 



work.process(data, n1, n2, n3); // 使用回调函数 



System.out.println(String.valueOf(n1) + "+" + String.valueOf(n2) + "+" 



+ String.valueOf(n3) + "=" + data.value); 



} 



public static void main(String[] args) 



{ 



Thread thread = new MyThread3(new Work()); 



thread.start(); 



} 



} 

好了，Java 多线程的基础知识就讲到这里了，有兴趣研究多线程的推荐直接看 java 的源码，你将会得到很大的提升！

# 关于我

Brath 是一个热爱技术的 Java 程序猿，公众号「InterviewCoder」定期分享有趣有料的精品原创文章！

非常感谢各位人才能看到这里，原创不易，文章如果有帮助可以关注、点赞、分享或评论，这都是对我的莫大支持！

# JVM 位置：在操作系统之上运行，操作系统在硬件之上运行

JDK（JRE（JVM））: JDK 包含了 JRE，JRE 包含了 JVM

# JVM 体系结构：

Java File

=> Class File

=> Class Loader SubSystem {

1 . Loading : [1 . ApplicationClassLoader 2 . ExtClassLoader 3 . BootStrapClassLoader]

2 . Linking : [1. Verify 2.Prepare 3. Resolve ]

3 . Initialization

}

=> RuntimeData Areas ：(1,2) : Memory sharing，(3,4,5) : Memory is not shared{

1 . Method Area

2 . Heap Area

3 . Stack Area {

T1 [1. Thread 2. Stack Frame ]

T2 [1. Thread 2. Stack Frame ]

}

4 . Native MethodStack Area --> JNI

5 . Program Counter Register [PC Registers for Thread]

}

=> Execution Engine {

1 . interpreter

2 . JIT Compiler {

Intermediate Code Generator

=> Code Optimizer

=> Target Code Generator

}

3 . Profiler

4 . Garbage Collection

}

=> Java Native Method Interface （JNI）

=> Native Method Library

# 类加载器： ClassLoader SubSystem : 类加载器子系统 运行时在堆中运行 不运行时是独立子系统

application ClassLoader 应用程序加载器 主要负责加载应用程序的主函数类

Ext ClassLoader 扩展加载器 主要负责加载 jre/lib/ext 目录下的一些扩展的 jar。

BootStrap ClassLoader 根类加载器 主要负责加载核心的类库 (java.lang.* 等)

加载过程：class File => Loading 加载 => Linking （验证，准备，解析） 链接 => Initialization 初始化

# 双亲委派机制

从上图中我们就更容易理解了，当一个 Hello.class 这样的文件要被加载时。不考虑我们自定义类加载器，首先会在 AppClassLoader 中检查是否加载过，如果有那就无需再加载了。如果没有，那么会拿到父加载器，然后调用父加载器的 loadClass 方法。父类中同理也会先检查自己是否已经加载过，如果没有再往上。注意这个类似递归的过程，直到到达 Bootstrap classLoader 之前，都是在检查是否加载过，并不会选择自己去加载。直到 BootstrapClassLoader，已经没有父加载器了，这时候开始考虑自己是否能加载了，如果自己无法加载，会下沉到子加载器去加载，一直到最底层，如果没有任何加载器能加载，就会抛出 ClassNotFoundException。那么有人就有下面这种疑问了？

为什么要设计这种机制
这种设计有个好处是，如果有人想替换系统级别的类：String.java。篡改它的实现，在这种机制下这些系统的类已经被 Bootstrap classLoader 加载过了（为什么？因为当一个类需要加载的时候，最先去尝试加载的就是 BootstrapClassLoader），所以其他类加载器并没有机会再去加载，从一定程度上防止了危险代码的植入。

沙箱安全机制

在 Java 中将执行程序分成本地代码和远程代码两种，本地代码默认视为可信任的，而远程代码则被看作是不受信的。对于授信的本地代码，可以访问一切本地资源。而对于非授信的远程代码在早期的 Java 实现中，安全依赖于沙箱 (Sandbox) 机制。

当前最新的安全机制实现，则引入了域 (Domain) 的概念。虚拟机会把所有代码加载到不同的系统域和应用域，系统域部分专门负责与关键资源进行交互，而各个应用域部分则通过系统域的部分代理来对各种需要的资源进行访问。虚拟机中不同的受保护域 (Protected Domain)，对应不一样的权限 (Permission)。存在于不同域中的类文件就具有了当前域的全部权限，如下图所示

# Native

native 即 JNI,Java Native Interface

Native 关键字是 JNI，也就是 java 本地方法接口，用来调用本地方法库，可以调用本地方法中的 C 语言代码

# PC 寄存器

每次线程启动的时候会创建一个 PC 寄存器，保存正在执行的 JVM 指令地址，每个线程都有自己的 PC 寄存器，是一个比较小的内存空间，是为一个一个不会出现 OutOfMemoryError 的内存区域，它的生命周期随着线程的创建而创建，随着线程的结束而死亡。

# 方法区

Hotspot 虚拟机，方法区别称：non-heap（非堆），其实就是存储堆类型的数据，而不占据堆内存的空间

方法区和堆区线程共享，方法区大小和堆一样，可以选择固定大小或者拓展

方法区大小决定了系统可以保存多少个类，如果系统定义了太多的类，导致方法区溢出，虚拟机同样会抛出内存溢出错误。

关闭 JVM 就会释放这个区域的内存

设置方法区的内存大小：

# JDK1.7 之前：

-XX：PermSize 设置永久代初始分配空间 默认是 20.75m

-XX：MaxPermSize 设置最大永久代分配空间，32 位机器默认 64m，64 位机器默认 82m

# JDK1.8 及以后：永久代被元空间代替（MetaSpace）

元空间大小可以用参数：-XX:MetaspaceSzie 和 -XX:MaxMetaspaceSize 指定

-XX:MetaspaceSzie 默认 21.75m -XX:MaxMetaspaceSize 默认 - 1 没有限制

默认情况下，虚拟机会耗尽所有可用的系统内存，如果元空间发生溢出，虚拟机照样会抛出 OOM

如果初始高位线设置过低，通过垃圾回收器日志可以观察到 Full GC 多次调用，为了避免频繁 GC，

建议将 - XX:MetaspaceSize 设置为一个相对较高的值。

# 栈：数据结构

程序 = 数据结构 + 算法

先进后出，后进先出

栈是桶的概念：先进去的后出来，后进去的先出来

栈有压栈、弹栈

队列是管道概念：先进先出 (F I F O) ，后进后出 First Input First Out

喝多了吐就是栈，吃多了拉就是队列

栈：主管程序运行，生命周期和线程同步；

main 主线程结束，栈内存也就释放了，对于栈来说，不存在垃圾回收问题，一旦线程结束，栈就 Over 了。

栈存什么东西：

八大基本数据类型 + 对象的引用地址 + 实例方法

栈运行原理：栈帧：方法索引，输入输出参数，本地变量，类引用，父帧，子帧

栈满了就会抛出错误 Error：StackOverflowError 栈溢出

# 堆：Heap

​ 一个 JVM 只有一个堆内存，堆内存大小是可以调节的。

​ 类加载器读取的类文件后，一般会把：类，方法，常量，变量，引用类型的真实对象放到堆中。

​ 堆内存还要细分为三个区域：{

新生代：Eden Space：

Survior0 区和 Survior1 区：幸存者 0/1 区

经过新生代的轻 GC 15 次的考验进入老年代。

老年代：重量级 Full GC 垃圾回收

永久代：（1.8 移除）

GC 垃圾回收集中在新生代和老年代执行。

假设内存满了，爆出 OOM，堆内存溢出。

内存溢出代码怎么写：

利用 while 循环一个字符串无限 += 随机数

JDK8 以后，永久代被移除，更名为元空间：MetaSpace

}

# 详解：

# 新生代：

​ 类：诞生成长的地方，也可能类死亡的地方

​ Eden 区、幸存者 0 和 1 区，

​ 所有对象都是在 Eden 区 new 出来的

​ Eden 区没死亡的对象在幸存者区存活

​ 如果 Eden 区存储触发了轻 GC 回收机制，就会对 Eden 区进行清除，存活下来对象在幸存区，清除的对象会消失。当 Eden 区和幸存者区都满了之后会执行一次 Full GC，再次存活下来的对象会进入老年代。

Tips：新生代 99% 都是临时对象！，能进入老年代的对象并不多。所以平时很少见到 OOM 的错误

# 老年代：

每次发生轻 GC 会对新生代进行对象清理，当新生代和幸存区的对象在轻 GC 清除下存活 15 次之后，进入老年代

永久代：用来存放 jdk 自身携带的 calss 对象，interface 元数据，存储的是运行的一些时环境，永久代不存在垃圾回收，关闭 JJVM 虚拟机就会释放永久代内存。

假设一个启动类，加载了大量的第三方 jar 包，或者一个 tomcat 部署了太多应用，或者大量动态生成的反射类，如果不断的加载，可能会导致永久代内存溢出。

jdk1.6 之前：永久代，常量池存在于方法区中

jdk1.7：去永久代，常量池在堆中

jdk1.8：无永久代，常量池在元空间中

元空间：

（方法区）：非堆

非堆指的是空间上，不属于堆空间；但是由于存储的内容，特性上又被称为堆

默认情况下：虚拟机被分配到的总内存是电脑内存的 1/4 ，而初始化的内存只有 1/64

因为与堆共享内存，逻辑上存在，物理上不存在

dump 文件～Jprofiler 插件

-Xms : 初始化内存

-Xmx : 最大内存

-XX:+PrintGCDetails 打印 GC 回收的详细信息

-XX:+HeapDumpOnOutOfMemoryError 发生 OOM 异常打印 dump 内存快照

-XX:MaxTenuringReshlod 设置最大存活时间，默认是 15 次

GC：垃圾回收

JVM 在进行 GC 时：大部分回收都在新生代，并不是三个区都回收

新生代

幸存区（form、to）Survior0、Survior1 区

老年代

GC 两个种类：轻 GC（GC）、重 GC（Full GC）

轻 GC 对新生代和幸存区进行回收

重 GC 进行全局回收

如何区分 from 和 to 区：谁空谁是 to 区

1 . 每次 GC 都会将 Eden 区活的对象移到幸存区中：一旦 Eden 区被 GC 后，就会是空的！

2 . 当一个对象经历了 15 次 GC，还没有死，就会进入老年代

-XX:MaxTenuringReshold，通过这个参数可以设定进入老年代的时间（指定在 0~15 次之间）

# 常用算法：

**1 . 标记清除 **

分为两步骤：标记 ---- 清除

标记：扫描，对存活的对象进行标记

清除：扫描，对没有标记的对象进行清除

优点：简单，成功率高

缺点：两次扫描严重耗时，清除会产生内存碎片

2 . 标记压缩（标记 — 清除 — 压缩）

标记清除的优化版：防止内存碎片产生

在标记清除基础上，再次扫描，向一端移动仍存活的对象，清除另一外的碎片

优点：在标记清除优点上优化了内存碎片

缺点：对于标记清除又多了一次移动成本，时间增加

3 . 复制算法（新生代主要用的复制算法）

把 from 区向 to 区复制一份，然后清空 from 区，这时 from 区会变成 to 区，复制过去的 to 区变成 from 区等待回收。

优点：没有内存碎片

缺点：浪费内存空间（多了一半空间永远是 to 区，假设对象 100% 存活）极端情况下不适用

复制算法最佳使用场景：对象存活度较低的时候，新生区使用复制算法！

4 . 分代收集算法：

​ 由于每个收集算法都无法符合所有的场景，就好比每个对象所在的内存阶段不一样，被回收的概率也不一样，比如在新生代，基本 90% 的对象会被回收，而到了老年代则一半以上的对象存活，所以针对不同的场景，回收的策略也就不一样，所以引出了分代收集算法，根据新生代和老年代不同的场景下使用不同的算法，比如新生代用复制算法，老年代则用标记整理算法

5. 引用计数器（不高效）

给每个对象设置计数器，只要有引用就会计数，当一个对象计数器为 0 时，进行回收。缺点：效率低下，现在基本不用

# 总结：

内存效率：复制算法 > 标记清除算法 > 标记压缩（时间复杂度）

内存整齐度：复制算法 == 标记压缩算法 > 标记清除算法

内存利用率：标记压缩算法 == 标记清除算法 > 复制算法

// 思考一个问题：难道没有最优算法吗？

答案：永远不能有最优算法。只有最合适的算法。

GC：分代收集算法：根据每个代需求来配置不同算法

年轻代：存活率低：需求时间短：所以用复制算法

老年代：存活率高、区域大：标记清除 + 标记压缩混合

内存碎片不是很多就标记清除，内存碎片太多就用压缩

JMM：

1 . 什么是 JMM：Java 内存模型（Java Memory Model）

2 . JMM 作用：

3 . 如何学习：

经历过很多面试大部分都会问一句： 你知道 Java 内存模型么？ 然后我就 pulapula 的说一大堆什么堆呀，栈呀，GC 呀什么的，这段时间把 JVM 虚拟机和多线程编程完整的学习了一遍，发现 JMM 和堆 / 栈这些完全不是一个概念，不知道是不是就是因为这才被拒了十来次的 / 尴尬。

JVM 是 Java 实现的虚拟计算机（Java Virtual Machine），对于熟悉计算机结构的同学，我感觉把这些概念和物理机对应起来更好理解。

JVM 对应的就是物理机，它有存放数据的存储区：堆、栈等由 JVM 管理的内存（对应于物理机的内存）、执行数据计算的执行单元：线程（对应于物理机的 CPU）、加速线程执行的本次存储区：可能会从存储区里分配一块空间来存储线程本地数据，比如栈（对应于物理机的 cache）。

众所周知，现代计算机一般都会包含多个处理器，多个处理器共享主内存。为了提升性能，会在每个处理器上增加一个小容量的 cache 加速数据读写。cache 会导致了缓存一致性问题，为了解决缓存一致性问题又引入了一系列 Cache 一致性协议（比如 MSI、MESI、MOSI、Synapse、Firefly 及 Dragon Protocol）来解决 CPU 本地缓存和主内存数据不一致问题。

而 JVM 中管理下的存储空间（包括堆、栈等）就对应与物理机的内存；

线程本次存储区（例如栈）就对应于物理机的 cache；

而 JMM 就对应于类似于 MSI、MESI、MOSI、Synapse、Firefly 及 Dragon Protocol 这样的缓存一致性协议，用于定义数据读写的规则。

JMM 相对于物理机的缓存一致性协议来说它还要处理 JVM 自身特有的问题：重排序问题，参见： http://cmsblogs.com/?p=2116。

那么 JMM 都有哪些内容呢？

官方文档： http://101.96.10.64/www.cs.umd.edu/~pugh/java/memoryModel/CommunityReview.pdf

通俗理解就是 happens-before 原则 https://www.cnblogs.com/chenssy/p/6393321.html

# 关于我

Brath 是一个热爱技术的 Java 程序猿，公众号「InterviewCoder」定期分享有趣有料的精品原创文章！

非常感谢各位人才能看到这里，原创不易，文章如果有帮助可以关注、点赞、分享或评论，这都是对我的莫大支持！

# mysql 查询当天、昨天、本周、上周、本月、上月、今年、去年数据

# mysql 查询今天、昨天、7 天、近 30 天、本月、上一月 数据

今天 select * from 表名 where to_days (时间字段名) = to_days (now ());

昨天 SELECT * FROM 表名 WHERE TO_DAYS (NOW () ) - TO_DAYS ( 时间字段名) = 1

近 7 天 SELECT * FROM 表名 where DATE_SUB (CURDATE (), INTERVAL 7 DAY) <= date (时间字段名)

查询当前这周的数据
SELECT name,submittime FROM enterprise WHERE YEARWEEK (date_format (submittime,’% Y-% m-% d’)) = YEARWEEK (now ());

查询上周的数据
SELECT name,submittime FROM enterprise WHERE YEARWEEK (date_format (submittime,’% Y-% m-% d’)) = YEARWEEK (now ())-1;

近 30 天 SELECT * FROM 表名 where DATE_SUB (CURDATE (), INTERVAL 30 DAY) <= date (时间字段名) 本月 SELECT * FROM 表名 WHERE DATE_FORMAT ( 时间字段名，‘% Y% m’ ) = DATE_FORMAT ( CURDATE ( ) , ‘% Y% m’ )

上一月 SELECT * FROM 表名 WHERE PERIOD_DIFF (date_format ( now () , ‘% Y% m’ ) , date_format ( 时间字段名，‘% Y% m’ ) ) =1

查询距离当前现在 6 个月的数据
select name,submittime from enterprise where submittime between date_sub (now (),interval 6 month) and now (); #查询本季度数据 select * from ht_invoice_information where QUARTER(create_date)=QUARTER(now());

查询上季度数据 select * from ht_invoice_information where QUARTER(create_date)=QUARTER(DATE_SUB(now(),interval 1 QUARTER));

查询本年数据 select * from ht_invoice_information where YEAR(create_date)=YEAR(NOW());

查询上年数据 select * from ht_invoice_information where year(create_date)=year(date_sub(now(),interval 1 year));

# 关于我

Brath 是一个热爱技术的 Java 程序猿，公众号「InterviewCoder」定期分享有趣有料的精品原创文章！

非常感谢各位人才能看到这里，原创不易，文章如果有帮助可以关注、点赞、分享或评论，这都是对我的莫大支持！

海量数据我们是如何去检索数据呢，如何快速定位呢，去查询后台数据库吗？还是走缓存，是什么缓存能承载这么大的符合呢，并且快速检索出来？对于海量的数据是对系统极大的压力，我们该从什么角度去处理这个棘手的问题呢？

# ElasticSearch 处理检索海量数据 “神器”？

# 1.1 介绍

Elasticsearch 是一个基于 Lucene 的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于 RESTful
web 接口。Elasticsearch 是用 Java 语言开发的，并作为 Apache 许可条款下的开放源码发布，是一种流行的企业级搜索引擎。Elasticsearch 用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。官方客户端在 Java、.NET（C#）、PHP、Python、Apache
Groovy、Ruby 和许多其他语言中都是可用的。根据 DB-Engines 的排名显示，Elasticsearch 是最受欢迎的企业搜索引擎，其次是 Apache
Solr，也是基于 Lucene。

# 1.2 es 介绍 “官网地址们”

1. 官方文档
2. 中文官方文档 3. 中文社区

# 2.1 基本介绍

1、Index（索引） 动词，相当于 MySQL 中的 insert； 名词，相当于 MySQL 中的 Database
2、Type（类型） 在 Index（索引）中，可以定义一个或多个类型。 类似于 MySQL 中的 Table；每一种类型的数据放在一起；
3、Document（文档）
保存在某个索引（Index）下，某种类型（Type）的一个数据（Document），文档是 JSON 格
式的，Document 就像是 MySQL 中的某个 Table 里面的内容；

# 2.2 ES 是如何进行检索的呢

# 2.3 ElasticSearch 长啥样呢，有无操作界面

ElasticSearch
是有操作界面的，它需要配置 Kibana，和它一起操作方便，也是主流的一种搭配方式，安装这两个工具，不做过多介绍

Kibana 介绍 Kibana 是一款开源的数据分析和可视化平台，它是 Elastic Stack 成员之一，设计用于和 Elasticsearch 协作。您可以使用 Kibana 对 Elasticsearch 索引中的数据进行搜索、查看、交互操作。您可以很方便的利用图表、表格及地图对数据进行多元化的分析和呈现

# 2.4 初步检索

1
2
3
4
5
6
7
8
9
10
11
12
13
14

1、_cat
GET /_cat/nodes：查看所有节点
GET /_cat/health：查看 es 健康状况
GET /_cat/master：查看主节点
GET /_cat/indices：查看所有索引 show databases;
2、索引一个文档（保存）
保存一个数据，保存在哪个索引的哪个类型下，指定用哪个唯一标识
PUT customer/external/1；在 customer 索引下的 external 类型下保存 1 号数据为
12345678
PUT 和 POST 都可以，
POST 新增。如果不指定 id，会自动生成 id。指定 id 就会修改这个数据，并新增版本号
PUT 可以新增可以修改。PUT 必须指定 id；由于 PUT 需要指定 id，我们一般都用来做修改
操作，不指定 id 会报错
1234

# 2.4.1 在 postMan 测试数据

1
2
3
4

PUT customer/external/1
{ "name": "John Doe"
}
123

2.4.2、查询文档

1
2
3
4
5
6
7
8
9
10
11
12
13
14

GET customer/external/1
1
结果：
{ "_index": "customer", //在哪个索引
"_type": "external", //在哪个类型
"_id": "1", //记录 id
"_version": 2, //版本号
"_seq_no": 1, //并发控制字段，每次更新就会+1，用来做乐观锁
"_primary_term": 1, //同上，主分片重新分配，如重启，就会变化
"found": true, "_source": { //真正的内容
"name": "John Doe"
}
}
1234567891011

2.4.3、更新文档

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

POST customer/external/1/_update
{ "doc":{ "name": "John Doew"
}
}
或者
POST customer/external/1
{ "name": "John Doe2"
}
或者
PUT customer/external/1
{ "name": "John Doe"
}
? 不同：POST 操作会对比源文档数据，如果相同不会有什么操作，文档 version 不增加
PUT 操作总会将数据重新保存并增加 version 版本；
带_update 对比元数据如果一样就不进行任何操作。
看场景；
对于大并发更新，不带 update；
对于大并发查询偶尔更新，带 update；对比更新，重新计算分配规则。
? 更新同时增加属性
POST customer/external/1/_update
{ "doc": { "name": "Jane Doe", "age": 20 }
}
PUT 和 POST 不带_update 也可以
1234567891011121314151617181920212223

2.4.4、删除文档 & 索引

1
2
3

DELETE customer/external/1
DELETE customer
12

2.4.5 bulk 批量 API

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

POST customer/external/_bulk
{"index":{"_id":"1"}}
{"name": "John Doe" }
{"index":{"_id":"2"}}
{"name": "Jane Doe" }
语法格式：
{ action: { metadata }}\n
{ request body }\n
{ action: { metadata }}\n
{ request body }\n
复杂实例：
POST /_bulk
{ "delete": { "_index": "website", "_type": "blog", "_id": "123" }}
{ "create": { "_index": "website", "_type": "blog", "_id": "123" }}
{ "title": "My first blog post" }
{ "index": { "_index": "website", "_type": "blog" }}
{ "title": "My second blog post" }
{ "update": { "_index": "website", "_type": "blog", "_id": "123", "_retry_on_conflict" : 3} }
{ "doc" : {"title" : "My updated blog post"} }
bulk API 以此按顺序执行所有的 action（动作）。如果一个单个的动作因任何原因而失败，
它将继续处理它后面剩余的动作。当 bulk API 返回时，它将提供每个动作的状态（与发送
的顺序相同），所以您可以检查是否一个指定的动作是不是失败了。
12345678910111213141516171819202122

# 2.4 SearchAPI

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

ES 支持两种基本方式检索 :
? 一个是通过使用 REST request URI 发送搜索参数（uri+检索参数）
? 另一个是通过使用 REST request body 来发送它们（uri+请求体）
1）、检索信息
? 一切检索从_search 开始
GET bank/_search 检索 bank 下所有信息，包括 type 和 docs
GET bank/_search?q=*&sort=account_number:asc 请求参数方式检索
响应结果解释：
took - Elasticsearch 执行搜索的时间（毫秒）
time_out - 告诉我们搜索是否超时
_shards - 告诉我们多少个分片被搜索了，以及统计了成功/失败的搜索分片
hits - 搜索结果
hits.total - 搜索结果
hits.hits - 实际的搜索结果数组（默认为前 10 的文档）
sort - 结果的排序 key（键）（没有则按 score 排序）
score 和 max_score –相关性得分和最高得分（全文检索用）
12345678910111213141516

其他在 Kibana 操作的语句，都可以在 es 官网去查询，不做过多的赘述！！！

# 2.5、Mapping 映射

Mapping（映射） Mapping 是用来定义一个文档（document），以及它所包含的属性（field）是如何存储和
索引的。比如，使用 mapping 来定义： ? 哪些字符串属性应该被看做全文本属性（full text fields）。 ?
哪些属性包含数字，日期或者地理位置。 ? 文档中的所有属性是否都能被索引（_all 配置）。 ? 日期的格式。 ?
自定义映射规则来执行动态添加属性。

# 2.6 分词

个 tokenizer（分词器）接收一个字符流，将之分割为独立的 tokens（词元，通常是独立 的单词），然后输出 tokens 流。
例如，whitespace tokenizer 遇到空白字符时分割文本。它会将文本 “Quick brown fox!” 分割 为
[Quick, brown, fox!]。 该 tokenizer（分词器）还负责记录各个 term（词条）的顺序或 position
位置（用于 phrase 短 语和 word proximity 词近邻查询），以及 term（词条）所代表的原始 word（单词）的
start （起始）和 end（结束）的 character offsets（字符偏移量）（用于高亮显示搜索的内容）。
Elasticsearch 提供了很多内置的分词器，可以用来构建 custom analyzers（自定义分词器）。

2.6.1 安装分词器

注意：不能用默认 elasticsearch-plugin install xxx.zip 进行自动安装
https://github.com/medcl/elasticsearch-analysis-ik/releases?after=v6.4.2
对应 es 版本安装

# 总结

elasticsearch
功能是非常强大的，可以作为生成环境的 ELK 日志存储，方便检索，也可以部署集群，提高效率，最主要是它是走内存的，查询效率极高，为大数据检索而生！！！

# 使用场景（Es）

# 关于我

Brath 是一个热爱技术的 Java 程序猿，公众号「InterviewCoder」定期分享有趣有料的精品原创文章！

非常感谢各位人才能看到这里，原创不易，文章如果有帮助可以关注、点赞、分享或评论，这都是对我的莫大支持！

# Go 语言超全详解（入门级）

# 文章目录

• 1. Go 语言的出现
• 2. go 版本的 hello world
• 3. 数据类型
• • 3.0 定义变量
  • • 3.0.1 如果变量没有初始化
    • 3.0.2 如果变量没有指定类型
    • 3.0.3 := 符号
    • 3.0.4 多变量声明
    • 3.0.5 匿名变量
    • 3.0.6 变量作用域
  • 3.1 基本类型
  • 3.2 指针
  • • 3.2.1 指针声明和初始化
    • 3.2.2 空指针
  • 3.3 数组
  • • 3.3.1 声明数组
    • 3.3.2 初始化数组
    • 3.3.3 go 中的数组名意义
    • 3.3.4 数组指针
  • 3.4 结构体
  • • 3.4.1 声明结构体
    • 3.4.2 访问结构体成员
    • 3.4.3 结构体指针
  • 3.5 字符串
  • • 3.5.1 字符串定义和初始化
    • 3.5.2 字符串 UTF8 编码
    • 3.5.3 字符串的强制类型转换
  • 3.6 slice
  • • 3.6.1 slice 定义
    • 3.6.2 添加元素
    • 3.6.3 删除元素
  • 3.7 函数
  • • 3.7.1 函数分类
    • 3.7.2 函数声明和定义
    • 3.7.3 函数传参
    • 3.7.4 函数返回值
    • 3.7.5 递归调用
  • 3.8 方法
  • 3.9 接口
  • • 3.9.1 什么是接口
    • 3.9.2 结构体类型
    • 3.9.3 具体类型向接口类型赋值
    • 3.9.4 获取接口类型数据的具体类型信息
  • 3.10 channel
  • • 3.10.1 相关结构体定义
    • 3.10.2 阻塞式读写 channel 操作
    • 3.10.3 非阻塞式读写 channel 操作
  • 3.11 map
  • • 3.11.1 插入数据
    • 3.11.2 删除数据
    • 3.11.3 查找数据
    • 3.11.4 扩容
• 4. 常用语句及关键字
• • 4.1 条件语句
  • 4.2 循环语句
  • • 4.2.1 循环处理语句
    • 4.2.1 循环控制语句
  • 4.3 关键字

# 1. Go 语言的出现

在具体学习 go 语言的基础语法之前，我们来了解一下 go 语言出现的时机及其特点。

Go 语言最初由 Google 公司的 Robert Griesemer、Ken Thompson 和 Rob Pike 三个大牛于 2007 年开始设计发明，他们最终的目标是设计一种适应网络和多核时代的 C 语言。所以 Go 语言很多时候被描述为 “类 C 语言”，或者是 “21 世纪的 C 语言”，当然从各种角度看，Go 语言确实是从 C 语言继承了相似的表达式语法、控制流结构、基础数据类型、调用参数传值、指针等诸多编程思想。但是 Go 语言更是对 C 语言最彻底的一次扬弃，它舍弃了 C 语言中灵活但是危险的指针运算，还重新设计了 C 语言中部分不太合理运算符的优先级，并在很多细微的地方都做了必要的打磨和改变。

# 2. go 版本的 hello world

在这一部分我们只是使用 “hello world” 的程序来向大家介绍一下 go 语言的所编写的程序的基本组成。

1
2
3
4
5
6
7

package main
import "fmt"
func main() {
	// 终端输出hello world
	fmt.Println("Hello world!")
}
123456

和 C 语言相似，go 语言的基本组成有：

• 包声明，编写源文件时，必须在非注释的第一行指明这个文件属于哪个包，如 package main 。
• 引入包，其实就是告诉 Go 编译器这个程序需要使用的包，如 import "fmt" 其实就是引入了 fmt 包。
• 函数，和 c 语言相同，即是一个可以实现某一个功能的函数体，每一个可执行程序中必须拥有一个 main 函数。
• 变量，Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。
• 语句 / 表达式，在 Go 程序中，一行代表一个语句结束。每个语句不需要像 C 家族中的其它语言一样以分号；结尾，因为这些工作都将由 Go 编译器自动完成。
• 注释，和 c 语言中的注释方式相同，可以在任何地方使用以 // 开头的单行注释。以 /* 开头，并以 */ 结尾来进行多行注释，且不可以嵌套使用，多行注释一般用于包的文档描述或注释成块的代码片段。

需要注意的是：标识符是用来命名变量、类型等程序实体。一个标识符实际上就是一个或是多个字母和数字、下划线_组成的序列，但是第一个字符必须是字母或下划线而不能是数字。

1. 当标识符（包括常量、变量、类型、函数名、结构字段等等）以一个大写字母开头，如：Group1，那么使用这种形式的标识符的对象就可以被外部包的代码所使用（客户端程序需要先导入这个包），这被称为导出（像面向对象语言中的 public）；
2. 标识符如果以小写字母开头，则对包外是不可见的，但是他们在整个包的内部是可见并且可用的（像面向对象语言中的 protected）。

# 3. 数据类型

在 Go 编程语言中，数据类型用于声明函数和变量。

数据类型的出现是为了把数据分成所需内存大小不同的数据，编程的时候需要用大数据的时候才需要申请大内存，就可以充分利用内存。具体分类如下：

# 3.0 定义变量

声明变量的一般形式是使用 var 关键字，具体格式为： var identifier typename 。如下的代码中我们定义了一个类型为 int 的变量。

1
2
3
4
5
6
7

package main
import "fmt"
func main() {
	var a int = 27
	fmt.Println(a);
} 
123456

# 3.0.1 如果变量没有初始化

在 go 语言中定义了一个变量，指定变量类型，如果没有初始化，则变量默认为零值。零值就是变量没有做初始化时系统默认设置的值。

# 3.0.2 如果变量没有指定类型

在 go 语言中如果没有指定变量类型，可以通过变量的初始值来判断变量类型。如下代码

1
2
3
4
5
6
7

package main
import "fmt"
func main() {
    var d = true
    fmt.Println(d)
}
123456

# 3.0.3 := 符号

当我们定义一个变量后又使用该符号初始化变量，就会产生编译错误，因为该符号其实是一个声明语句。

使用格式： typename := value

也就是说 intVal := 1 相等于：

1
2
3

var intVal int 
intVal =1 
12

# 3.0.4 多变量声明

可以同时声明多个类型相同的变量（非全局变量），如下图所示：

1
2
3
4

var x, y int
var c, d int = 1, 2
g, h := 123, "hello"
123

关于全局变量的声明如下：
var ( vname1 v_type1 vname2 v_type2 )
具体举例如下：

1
2
3
4
5

var ( 
    a int
    b bool
)
1234

# 3.0.5 匿名变量

匿名变量的特点是一个下画线 _ ，这本身就是一个特殊的标识符，被称为空白标识符。它可以像其他标识符那样用于变量的声明或赋值（任何类型都可以赋值给它），但任何赋给这个标识符的值都将被抛弃，因此这些值不能在后续的代码中使用，也不可以使用这个标识符作为变量对其它变量进行赋值或运算。

使用匿名变量时，只需要在变量声明的地方使用下画线替换即可。

示例代码如下：

1
2
3
4
5
6
7
8
9

    func GetData() (int, int) {
        return 10, 20
    }
    func main(){
        a, _ := GetData()
        _, b := GetData()
        fmt.Println(a, b)
    }
12345678

需要注意的是匿名变量不占用内存空间，不会分配内存。匿名变量与匿名变量之间也不会因为多次声明而无法使用。

# 3.0.6 变量作用域

作用域指的是已声明的标识符所表示的常量、类型、函数或者包在源代码中的作用范围，在此我们主要看一下 go 中变量的作用域，根据变量定义位置的不同，可以分为一下三个类型：

1. 函数内定义的变量为局部变量，这种局部变量的作用域只在函数体内，函数的参数和返回值变量都属于局部变量。这种变量在存在于函数被调用时，销毁于函数调用结束后。
2. 函数外定义的变量为全局变量，全局变量只需要在一个源文件中定义，就可以在所有源文件中使用，甚至可以使用 import 引入外部包来使用。全局变量声明必须以 var 关键字开头，如果想要在外部包中使用全局变量的首字母必须大写。
3. 函数定义中的变量成为形式参数，定义函数时函数名后面括号中的变量叫做形式参数（简称形参）。形式参数只在函数调用时才会生效，函数调用结束后就会被销毁，在函数未被调用时，函数的形参并不占用实际的存储单元，也没有实际值。形式参数会作为函数的局部变量来使用。

# 3.1 基本类型

以上就是 go 语言基本的数据类型，有了数据类型，我们就可以使用这些类型来定义变量，Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。

# 3.2 指针

与 C 相同，Go 语言让程序员决定何时使用指针。变量其实是一种使用方便的占位符，用于引用计算机内存地址。Go 语言中的的取地址符是 & ，放到一个变量前使用就会返回相应变量的内存地址。

指针变量其实就是用于存放某一个对象的内存地址。

# 3.2.1 指针声明和初始化

和基础类型数据相同，在使用指针变量之前我们首先需要申明指针，声明格式如下： var var_name *var-type ，其中的 var-type 为指针类型，var_name 为指针变量名，* 号用于指定变量是作为一个指针。

代码举例如下：

1
2
3

var ip *int        /* 指向整型*/
var fp *float32    /* 指向浮点型 */
12

指针的初始化就是取出相对应的变量地址对指针进行赋值，具体如下：

1
2
3
4
5

   var a int= 20   /* 声明实际变量 */
   var ip *int        /* 声明指针变量 */

   ip = &a  /* 指针变量的存储地址 */
1234

# 3.2.2 空指针

当一个指针被定义后没有分配到任何变量时，它的值为 nil，也称为空指针。它概念上和其它语言的 null、NULL 一样，都指代零值或空值。

# 3.3 数组

和 c 语言相同，Go 语言也提供了数组类型的数据结构，数组是具有相同唯一类型的一组已编号且长度固定的数据项序列，这种类型可以是任意的原始类型例如整型、字符串或者自定义类型。

# 3.3.1 声明数组

Go 语言数组声明需要指定元素类型及元素个数，语法格式如下：

1

var variable_name [SIZE] variable_type

以上就可以定一个一维数组，我们举例代码如下：

1
2

var balance [10] float32
1

# 3.3.2 初始化数组

数组的初始化方式有不止一种方式，我们列举如下：

1. 直接进行初始化： var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
2. 通过字面量在声明数组的同时快速初始化数组： balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
3. 数组长度不确定，编译器通过元素个数自行推断数组长度，在 [ ] 中填入 ... ，举例如下： var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0} 和 balance := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
4. 数组长度确定，指定下标进行部分初始化： balanced := [5]float32(1:2.0, 3:7.0)