Java的语言特点是什么（java语言的主要特点是什么）
482
2022-05-30
Java 多线程与高并发
保证线程可见性
当多个线程访问同一个共享资源时，线程会拷贝资源的副本到自己的工作内存。这样如果某个线程对这个资源进行写操作，其他线程不会马上知道。当对这个资源加volatile关键字，其他线程就会随时监听，更新新的值。
如下例子，不加volatile关键字，线程不会停止，加volatile关键字后会及时重新更新副本stop的值，线程停止。
package com.nobody.thread; /** * 不加volatile，输出： * main start... * thread start... * change stop=true * * 加volatile，输出： * main start... * thread start... * thread stop... * change stop=true * @author Μr.ηobοdy * * @date 2020-04-19 * */ public class VolatileDemo { private /* volatile */ static boolean stop = false; public static void main(String[] args) { Thread t = new Thread(() -> { System.out.println("thread start..."); while (!stop) { } System.out.println("thread stop..."); }); System.out.println("main start..."); t.start(); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } stop = true; System.out.println("change stop=" + stop); } }
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
禁止指令重排序
JIT(即时编译器just-in-time compiler) 是一种提高程序运行效率的方法，会将指令重排序。例如实例化一个对象，一般可分为3步骤，第一分配内存空间，第二初始化变量等，第三将引用地址赋值给引用对象。指令重排序可将顺序改为132。这样引用对象可能就拿到一个未初始化的对象，导致出错。
package com.nobody.thread; /** * 单例模式(懒汉式) * 懒汉式必须加volatile * * @author Μr.ηobοdy * * @date 2020-04-19 * */ public class Singleton { private /* vovalite */ static Singleton INSTANCE; private String name; private Singleton(String name) { this.name = name; } public static Singleton getInstance() { if (null == INSTANCE) { synchronized (Singleton.class) { if (null == INSTANCE) { // 可能会出现指令重排序，即未进行成员变量name的初始化就退出了， // 这样别人就会拿到未初始化(name=null)的Singleton对象 INSTANCE = new Singleton("hh"); } } } return INSTANCE; } public String getName() { return name; } public void setName(String name) { this.name = 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
不保证原子性
package com.nobody.thread; import java.util.ArrayList; import java.util.List; /** * volatile不保证原子性，最终结果一般小于10000 * * 若要保证原子性，直接将doCount方法加synchronized关键字即可，而volatile可有可无 * * @author Μr.ηobοdy * * @date 2020-04-19 * */ public class VolatileDemo1 { private volatile static int count = 0; private /*synchronized*/ void doCount() { for (int i = 0; i < 1000; i++) { count++; } } public static void main(String[] args) { VolatileDemo1 v = new VolatileDemo1(); // 启动10个线程 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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
设置新值之前会先将旧的值与期望值比较，如果相等才set，不然就重试或者失败。这是有CPU原语支持的。
package com.nobody.thread; import java.util.ArrayList; import java.util.List; import java.util.concurrent.atomic.AtomicInteger; /** * CAS AtomicInteger保证原子性，最终结果一定等于10000 * * * @author Μr.ηobοdy * * @date 2020-04-19 * */ public class AtomicIntegerDemo { private static AtomicInteger count = new AtomicInteger(0); private void doCount() { for (int i = 0; i < 1000; i++) { count.incrementAndGet(); } } public static void main(String[] args) { AtomicIntegerDemo v = new AtomicIntegerDemo(); // 启动10个线程 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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
不过这种会出现ABA问题，即由值A先变成值B，然后又变回A值，最后旧值与期望值比较还是相等。可用版本号解决这个问题。
采用分段锁思想，假如有1000个线程对同一个共享变量进行操作(例如自增)，此处假设分为4小组，250个线程为1组，组内进行自增操作，这样分组能减少锁的概率，最后将每个小组进行求总和处理。其实分段锁组内还是CAS原理。一般在线程数高时，效率比synchronized和AtomicLong高。
package com.nobody.thread; import java.util.ArrayList; import java.util.List; import java.util.concurrent.atomic.AtomicLong; import java.util.concurrent.atomic.LongAdder; /** * LongAdder,AtomicLong,synchronized多线程时效率比较 * 模拟1000个线程对一个等于0的值进行自增操作，每个线程自增10000 * * 输出结果： * longAdderCount:10000000, time:227 * atomicLongCount:10000000, time:395 * synchronizedCount:10000000, time:909 * * @author Μr.ηobοdy * * @date 2020-04-20 * */ public class LongAdderDemo { private static LongAdder longAdderCount = new LongAdder(); private static AtomicLong atomicLongCount = new AtomicLong(0L); private static long synchronizedCount = 0L; public static void main(String[] args) { // LongAdder测试 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
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
Java 任务调度 多线程
版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。
相关文章
推荐文章
最近发表
