类
在java.util.concurrent.atomic包下，有AtomicBoolean , AtomicInteger, AtomicLong, AtomicReference等类，它们的基本特性就是在多线程环境下，执行这些类实例包含的方法时，具有排他性，即当某个线程进入方法，执行其中的指令时，不会被其他线程打断，而别的线程就像自旋锁一样，一直等到该方法执行完成，才由JVM从等待队列中选择一个另一个线程进入。
举例说明
以AtomicBoolean为例，单线程执行普通的方法（如下），不会出现线程问题：
复制代码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
package com.secbro.test.atomic;
/**
* @author zhuzhisheng
* @Description
* @date on 2016/5/26.
*/
public class NormalBoolean implements Runnable{
public static boolean exits = false;
private String name;
public NormalBoolean(String name){
this.name = name;
}
@Override
public void run() {
if(!exits){
exits = true;
System.out.println(name + ",step 1");
System.out.println(name + ",step 2");
System.out.println(name + ",step 3");
exits = false;
} else {
System.out.println(name + ",step else");
}
}
public static void main(String[] args) {
new NormalBoolean("张三").run();
}
}
登录后复制然而，当多线程执行时，就会出现在执行判断之后的命令时，会有其他线程插入，变更exits的值。如下段代码：
复制代码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
package com.secbro.test.atomic;
/**
* @author zhuzhisheng
* @Description
* @date on 2016/5/26.
*/
public class NormalBoolean2 implements Runnable{
public static boolean exits = false;
private String name;
public NormalBoolean2(String name) {
this.name = name;
}
@Override
public void run() {
if(!exits){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
exits = true;
System.out.println(name + ",step 1");
System.out.println(name + ",step 2");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(name + ",step 3");
exits = false;
} else {
System.out.println(name + ",step else");
}
}
}
登录后复制同时执行两线程，打印结果为：
复制代码1
2
3
4
5
6
张三,step 1
李四,step 1
张三,step 2
李四,step 2
张三,step 3
李四,step 3
登录后复制现在，使用AtomicBoolean就可以确保多线程的情况下安全的运行，只有一个线程进行业务处理。
复制代码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
package com.secbro.test.atomic;
import java.util.concurrent.atomic.AtomicBoolean;
/**
* @author zhuzhisheng
* @Description
* @date on 2016/5/26.
*/
public class TestAtomicBoolean implements Runnable{
public static AtomicBoolean exits = new AtomicBoolean(false);
private String name;
public TestAtomicBoolean(String name) {
this.name = name;
}
@Override
public void run() {
if(exits.compareAndSet(false,true)){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(name + ",step 1");
System.out.println(name + ",step 2");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(name + ",step 3");
exits.set(false);
} else {
System.out.println(name + ",step else");
}
}
}
登录后复制当两个线程执行此类时，打印结果如下：
复制代码1
2
3
4
张三,step else
李四,step 1
李四,step 2
李四,step 3
登录后复制测试类：
复制代码1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.secbro.test.atomic;
/**
* @author zhuzhisheng
* @Description
* @date on 2016/5/26.
*/
public class TestBoolean {
public static void main(String[] args) {
Thread thread1 = new Thread(new NormalBoolean2("李四"));
Thread thread2 = new Thread(new NormalBoolean2("张三"));
thread1.start();
thread2.start();
//-------------------------------------------------------
Thread thread3 = new Thread(new TestAtomicBoolean("李四"));
Thread thread4 = new Thread(new TestAtomicBoolean("张三"));
thread3.start();
thread4.start();
}
}
登录后复制以上就是java中Atomic类之AtomicBoolean的详细内容，更多请关注靠谱客其它相关文章！
最后
以上就是怡然纸飞机最近收集整理的关于java中Atomic类之AtomicBoolean的全部内容，更多相关java中Atomic类之AtomicBoolean内容请搜索靠谱客的其他文章。
本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
发表评论 取消回复