我们知道,当多个线程对一个域访问时,会产生意想不到的后果,一个线程在还没来得及会写数据的时候,第二个线程已经访问了这个数据,这就使得数据产生问题,我们看个demo
package com.mingrisoft.thread;
import com.sun.org.apache.bcel.internal.generic.NEW;
public class Demo1 {
Bank bank=new Bank();
public static void main(String[] args) {
// TODO Auto-generated method stub
new Demo1();
}
public Demo1() {
// TODO Auto-generated constructor stub
Thread thread=new Thread(new Run());
thread.start();
Thread thread1=new Thread(new Run());
thread1.start();
}
class Run implements Runnable{
public void run() {
for(int i=0;i<10;i++){
bank.setV(10);
}
}
}
class Bank{
int v=100;
public int getV() {
return v;
}
public void setV(int va) {
this.v +=va;
System.out.println("数据为:"+v);
}
}
}
对于这种情况,我们可以使用很对技术解决,例如
1.synchronized代码块,或者修饰方法,
2.使用特殊域 volatile关键字
3使用ReentrantLock
4.使用线程局部变量ThreadLocal
5.LinkedBlockingQueue阻塞队列实现
6.使用信号量Semaphore同步
7.使用原子变量实现AtomicInteger实现
具体应该还有,不过我就知道这几种,一般来说,还是喜欢用synchronized来实现,不比比了,我们还是说说今天的主人公
AtomicInteger
我们使用代码
package com.mingrisoft.thread;
import java.util.concurrent.atomic.AtomicInteger;
import com.sun.org.apache.bcel.internal.generic.NEW;
public class Demo1 {
Bank bank=new Bank();
public static void main(String[] args) {
// TODO Auto-generated method stub
new Demo1();
}
public Demo1() {
// TODO Auto-generated constructor stub
Thread thread=new Thread(new Run());
thread.start();
Thread thread1=new Thread(new Run());
thread1.start();
}
class Run implements Runnable{
public void run() {
for(int i=0;i<10;i++){
bank.setV(10);
}
}
}
class Bank{
AtomicInteger atomicInteger=new AtomicInteger(100);
public int getV() {
return atomicInteger.get();
}
public void setV(int va) {
atomicInteger.addAndGet(va);
System.out.println("当前的值为:"+atomicInteger.get());
}
}
}
结果为
SO easy,简单几步,我们就解决了线程的同步问题
那么我们现在看看官方文档,加深下对这个类的理解
文档说的不明不白,原子?那么什么是原子方式?
所谓原子操作是指不会被线程调度机制打断的操作;这种操作一旦开始,就一直运行到结束,中间不会有任何 context switch (切[1] 换到另一个线程)。
百度上搜的,自己也不知道怎么解释,大致就是操作的不可分割性,不会受到线程的影响