释放双眼，带上耳机，听听看~！
JAVA之旅（十三）——线程的安全性，synchronized关键字，多线程同步代码块，同步函数，同步函数的锁是this
一.线程的安全性
当我们开启四个窗口（线程）把票陆陆续续的卖完了之后，我们要反思一下，这里面有没有安全隐患呢？在实际情况中，这种事情我们是必须要去考虑安全问题的，那我们模拟一下错误
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
2
3import javax.security.auth.callback.TextInputCallback;
4
5//公共的 类 类名
6public class HelloJJAVA {
7
8 public static void main(String[] args) {
9
10 /**
11 * 需求：简单的卖票程序，多个线程同时卖票
12 */
13 MyThread myThread = new MyThread();
14 Thread t1 = new Thread(myThread);
15 Thread t2 = new Thread(myThread);
16 Thread t3 = new Thread(myThread);
17 Thread t4 = new Thread(myThread);
18
19 t1.start();
20 t2.start();
21 t3.start();
22 t4.start();
23 }
24
25}
26
27/**
28 * 卖票程序
29 *
30 * @author LGL
31 *
32 */
33class MyThread implements Runnable {
34
35 // 票数
36 private int tick = 100;
37
38 @Override
39 public void run() {
40 while (true) {
41 if (tick > 0) {
42 try {
43 Thread.sleep(1000);
44 } catch (InterruptedException e) {
45 // TODO Auto-generated catch block
46 e.printStackTrace();
47 }
48 System.out.println("卖票:" + tick--);
49 }
50 }
51 }
52}
53
54
我们输出的结果
这里出现了0票，如果你继续跟踪的话，你会发现，还会出现-1，-2之类的票，这就是安全隐患，那原因是什么呢？
- 当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一个部分，还没有执行完，另外一个线程参与了执行，导致共享数据的错误
解决办法：对多条操作共享数据的语句，只能让一个线程都执行完再执行过程中其他线程不可以参与运行
JAVA对多线程的安全问题提供了专业的解决办法，就是同步代码块
2
3
4
5
6
2 synchronized(对象){
3 //需要同步的代码
4 }
5
6
那我们怎么用呢？
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
2
3//公共的 类 类名
4public class HelloJJAVA {
5
6 public static void main(String[] args) {
7
8 /**
9 * 需求：简单的卖票程序，多个线程同时卖票
10 */
11 MyThread myThread = new MyThread();
12 Thread t1 = new Thread(myThread);
13 Thread t2 = new Thread(myThread);
14 Thread t3 = new Thread(myThread);
15 Thread t4 = new Thread(myThread);
16
17 t1.start();
18 t2.start();
19 t3.start();
20 t4.start();
21 }
22
23}
24
25/**
26 * 卖票程序
27 *
28 * @author LGL
29 *
30 */
31class MyThread implements Runnable {
32
33 // 票数
34 private int tick = 100;
35
36 Object oj = new Object();
37 @Override
38 public void run() {
39 while (true) {
40 synchronized(oj){
41 if (tick > 0) {
42 try {
43 Thread.sleep(10);
44 } catch (InterruptedException e) {
45 // TODO Auto-generated catch block
46 e.printStackTrace();
47 }
48 System.out.println("卖票:" + tick--);
49 }
50 }
51
52 }
53 }
54}
55
56
这样，就输出
二.多线程同步代码块
我们为什么可以这样去同步线程？
对象如同锁，持有锁的线程可以在同步中执行，没有执行锁的线程即使获取了CPU的执行权，也进不去，因为没有获取锁，我们可以这样理解
- 四个线程，哪一个进去就开始执行，其他的拿不到执行权，所以即使拿到了执行权，也进不去，这个同步能解决线程的安全问题
但是，同步是有前提的
- 1.必须要有两个或者两个以上的线程，不然你同步也没必要呀
- 2.必须是多个线程使用同一锁
必须保证同步中只能有一个线程在运行
但是他也有一个弊端：那就是多个线程都需要判断锁，较为消耗资源
三.多线成同步函数
我们可以写一段小程序，来验证这个线程同步的问题，也就是说我们看看下面这段程序是否有安全问题，有的话，如何解决？
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
2
3//公共的 类 类名
4public class HelloJJAVA {
5
6 public static void main(String[] args) {
7
8 /**
9 * 需求：银行里有一个金库 有两个人要存钱300
10 */
11 MyThread myThread = new MyThread();
12 Thread t1 = new Thread(myThread);
13 Thread t2 = new Thread(myThread);
14
15 t1.start();
16 t2.start();
17
18 }
19
20}
21
22/**
23 * 存钱程序，一次100
24 * @author LGL
25 *
26 */
27class MyThread implements Runnable {
28
29 private Bank b = new Bank();
30
31 @Override
32 public void run() {
33 for (int i = 0; i < 3; i++) {
34 b.add(100);
35 }
36 }
37
38}
39
40/**
41 * 银行
42 * @author LGL
43 *
44 */
45class Bank {
46 private int sum;
47
48 public void add(int n) {
49 sum = sum + n;
50 System.out.println("sum:" + sum);
51 }
52}
53
54
当你执行的时候你会发现
这里是没错的，存了600块钱，但是，这个程序是有安全隐患的
如何找到问题？
- 1.明确哪些代码是多线成运行代码
- 2.明确共享数据
- 3.明确多线成运行代码中哪些语句是操作共享数据的
那我们怎么找到安全隐患呢？我们去银行的类里面做些认为操作
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
2 * 银行
3 * @author LGL
4 *
5 */
6class Bank {
7 private int sum;
8
9 public void add(int n) {
10 sum = sum + n;
11 try {
12 Thread.sleep(10);
13 } catch (InterruptedException e) {
14 // TODO Auto-generated catch block
15 e.printStackTrace();
16 }
17 System.out.println("sum:" + sum);
18 }
19}
20
让他sleep一下你就会发现
这样的话，我们就可以使用我们的同步代码了
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
2 * 银行
3 *
4 * @author LGL
5 *
6 */
7class Bank {
8 private int sum;
9
10 Object j = new Object();
11
12 public void add(int n) {
13 synchronized (j) {
14 sum = sum + n;
15 try {
16 Thread.sleep(10);
17 } catch (InterruptedException e) {
18 // TODO Auto-generated catch block
19 e.printStackTrace();
20 }
21 System.out.println("sum:" + sum);
22 }
23 }
24}
25
这样代码就可以同步了
哪些代码该同步，哪些不该同步，你一定要搞清楚，根据上面的3个条件
大家有没有注意到，函数式具有封装代码的特定，而我们所操作的同步代码块也是有封装代码的特性，拿这样的话我们就可以换一种形式去操作，那就是写成函数的修饰符
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
2/**
3 * 银行
4 *
5 * @author LGL
6 *
7 */
8class Bank {
9 private int sum;
10
11 public synchronized void add(int n) {
12 sum = sum + n;
13 try {
14 Thread.sleep(10);
15 } catch (InterruptedException e) {
16 // TODO Auto-generated catch block
17 e.printStackTrace();
18 }
19 System.out.println("sum:" + sum);
20 }
21}
22
23
这样也是OK的
四.同步函数的锁是this
既然我们学习了另一种同步函数的写法，那我们就可以把刚才的买票小例子进一步封装一下了
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
2
3//公共的 类 类名
4public class HelloJJAVA {
5
6 public static void main(String[] args) {
7
8 /**
9 * 需求：简单的卖票程序，多个线程同时卖票
10 */
11 MyThread myThread = new MyThread();
12 Thread t1 = new Thread(myThread);
13 Thread t2 = new Thread(myThread);
14 Thread t3 = new Thread(myThread);
15 Thread t4 = new Thread(myThread);
16
17 t1.start();
18 t2.start();
19 t3.start();
20 t4.start();
21 }
22
23}
24
25/**
26 * 卖票程序
27 *
28 * @author LGL
29 *
30 */
31class MyThread implements Runnable {
32
33 // 票数
34 private int tick = 100;
35
36 @Override
37 public synchronized void run() {
38 while (true) {
39 if (tick > 0) {
40 try {
41 Thread.sleep(10);
42 } catch (InterruptedException e) {
43 // TODO Auto-generated catch block
44 e.printStackTrace();
45 }
46 System.out.println(Thread.currentThread()+"卖票:" + tick--);
47 }
48 }
49 }
50}
51
52
但是这样做，你却会发现一个很严重的问题，那就是
永远只有0线程在执行卖票
那是因为我们并没有搞清楚需要同步哪一个代码段，我们应该执行的只是里面的那两段代码，而不是整个死循环，所以我们得封装个函数进行线程同步
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
2
3//公共的 类 类名
4public class HelloJJAVA {
5
6 public static void main(String[] args) {
7
8 /**
9 * 需求：简单的卖票程序，多个线程同时卖票
10 */
11 MyThread myThread = new MyThread();
12 Thread t1 = new Thread(myThread);
13 Thread t2 = new Thread(myThread);
14 Thread t3 = new Thread(myThread);
15 Thread t4 = new Thread(myThread);
16
17 t1.start();
18 t2.start();
19 t3.start();
20 t4.start();
21 }
22
23}
24
25/**
26 * 卖票程序
27 *
28 * @author LGL
29 *
30 */
31class MyThread implements Runnable {
32
33 // 票数
34 private int tick = 100;
35
36 @Override
37 public void run() {
38 while (true) {
39 show();
40 }
41 }
42
43 private synchronized void show() {
44 if (tick > 0) {
45 try {
46 Thread.sleep(10);
47 } catch (InterruptedException e) {
48 // TODO Auto-generated catch block
49 e.printStackTrace();
50 }
51 System.out.println(Thread.currentThread() + "卖票:" + tick--);
52 }
53 }
54}
55
56
这样输出解决了
问题是被解决了，但是随之问题也就来了
- 同步函数用的是哪一个锁呢？
函数需要被对象调用，那么函数都有一个所属对象的引用，就是this，所以同步函数所引用的锁是this,我们来验证一下，我们把程序改动一下
使用两个线程来卖票，一个线程在同步代码块中，一个线程在同步函数中，都在执行卖票动作
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
2
3//公共的 类 类名
4public class HelloJJAVA {
5
6 public static void main(String[] args) {
7
8 /**
9 * 需求：简单的卖票程序，多个线程同时卖票
10 */
11 MyThread myThread = new MyThread();
12 Thread t1 = new Thread(myThread);
13 Thread t2 = new Thread(myThread);
14 // Thread t3 = new Thread(myThread);
15 // Thread t4 = new Thread(myThread);
16
17 t1.start();
18 myThread.flag = false;
19 t2.start();
20 // t3.start();
21 // t4.start();
22 }
23
24}
25
26/**
27 * 卖票程序
28 *
29 * @author LGL
30 *
31 */
32class MyThread implements Runnable {
33
34 // 票数
35 private int tick = 100;
36
37 Object j = new Object();
38
39 boolean flag = true;
40
41 @Override
42 public void run() {
43
44 if (flag) {
45 while (true) {
46 synchronized (j) {
47 if (tick > 0) {
48 try {
49 Thread.sleep(10);
50 } catch (InterruptedException e) {
51 // TODO Auto-generated catch block
52 e.printStackTrace();
53 }
54 System.out.println(Thread.currentThread() + "code:"
55 + tick--);
56 }
57 }
58 }
59 } else {
60 while (true) {
61 show();
62 }
63 }
64
65 }
66
67 private synchronized void show() {
68 if (tick > 0) {
69 try {
70 Thread.sleep(10);
71 } catch (InterruptedException e) {
72 // TODO Auto-generated catch block
73 e.printStackTrace();
74 }
75 System.out.println(Thread.currentThread() + "show:" + tick--);
76 }
77 }
78}
79
80
当我们运行的时候就发现
他只在show中进行，那是为什么呢？因为主线程开启的时候瞬间执行，我们要修改一下，让线程1开启的时候，主线程睡个10毫秒试试
2
3
4
5
6
7
8
9
10
11
12
2
3 try {
4 Thread.sleep(10);
5 } catch (InterruptedException e) {
6 // TODO Auto-generated catch block
7 e.printStackTrace();
8 }
9
10 myThread.flag = false;
11 t2.start();
12
这样输出的结果貌似是交替进行
但是所知而来的，是0票，这说明这个线程不安全，我们明明加了同步啊，怎么还是不安全呢？因为他用的不是同一个锁，一个用Object，一个是用this的锁，我们再改动一下，我们把Object更好为this，这样输出
现在就安全，也正确了
好的，我们本篇幅就先到这里了，我们下篇也继续讲线程
