Java的语言特点是什么(java语言的主要特点是什么)
530
2022-05-30
保证线程可见性
当多个线程访问同一个共享资源时,线程会拷贝资源的副本到自己的工作内存。这样如果某个线程对这个资源进行写操作,其他线程不会马上知道。当对这个资源加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小时内删除侵权内容。