脏读可能出现的几种情况

脏读可能出现的情况1

package entity;
public class PublicVar {
	public String username = "A";
	public String password = "AA";
	synchronized public void setValue(String username, String password) {
		try {
			this.username = username;
			Thread.sleep(5000);
			this.password = password;
			System.out.println("setValue method thread name="
					+ Thread.currentThread().getName() + " username="
					+ username + " password=" + password);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	synchronized public void getValue() {
		System.out.println("getValue method thread name="
				+ Thread.currentThread().getName() + " username=" + username
				+ " password=" + password);
	}
}

package extthread;
import entity.PublicVar;
public class ThreadA extends Thread {
	private PublicVar publicVar;
	public ThreadA(PublicVar publicVar) {
		super();
		this.publicVar = publicVar;
	}
	@Override
	public void run() {
		super.run();
		publicVar.setValue("B", "BB");
	}
}

package test;
import entity.PublicVar;
import extthread.ThreadA;
public class Test {
	public static void main(String[] args) {
		try {
			PublicVar publicVarRef = new PublicVar();
			ThreadA thread = new ThreadA(publicVarRef);
			thread.start();
            /**
             * 如果这个时间过短的话，在没有setValue()的方法，
             * 执行结束，就运行getValue() 方法了，所以getValue()方法得到的值就是不对的
             */
			Thread.sleep(20000);
			publicVarRef.getValue();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

脏读可能出现的情况2

当A 和B 两个线程执行带有分支判断的方法时，就会出现逻辑上的错误，有可能出现脏读

下面这个有可能出现脏读(由于里面含有分支for 循环)：

package extthread;
import mylist.MyList;
public class MyThreadA extends Thread {
	private MyList list;
	public MyThreadA(MyList list) {
		super();
		this.list = list;
	}
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			list.add("threadA" + (i + 1));
		}
	}
}

package extthread;
import mylist.MyList;
public class MyThreadB extends Thread {
	private MyList list;
	public MyThreadB(MyList list) {
		super();
		this.list = list;
	}
	@Override
	public void run() {
		for (int i = 0; i < 100000; i++) {
			list.add("threadB" + (i + 1));
		}
	}
}

package extthread;
import mylist.MyList;
public class MyThreadB extends Thread {
	private MyList list;
	public MyThreadB(MyList list) {
		super();
		this.list = list;
	}
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			list.add("threadB" + (i + 1));
		}
	}
}

package test;
import mylist.MyList;
import extthread.MyThreadA;
import extthread.MyThreadB;
public class Test {
	public static void main(String[] args) {
		MyList mylist = new MyList();
		MyThreadA a = new MyThreadA(mylist);
		a.setName("A");
		a.start();
		MyThreadB b = new MyThreadB(mylist);
		b.setName("B");
		b.start();
	}
}

 结果为：
 

ThreadName=A执行了add方法！
ThreadName=A退出了add方法！
ThreadName=B执行了add方法！
ThreadName=B退出了add方法！
ThreadName=A执行了add方法！
ThreadName=A退出了add方法！
ThreadName=A执行了add方法！
ThreadName=A退出了add方法！
ThreadName=B执行了add方法！
ThreadName=B退出了add方法！
ThreadName=A执行了add方法！
ThreadName=A退出了add方法！
ThreadName=B执行了add方法！
ThreadName=B退出了add方法！
ThreadName=A执行了add方法！
ThreadName=A退出了add方法！
ThreadName=B执行了add方法！
ThreadName=B退出了add方法！
ThreadName=A执行了add方法！
ThreadName=A退出了add方法！
ThreadName=A执行了add方法！
ThreadName=A退出了add方法！
ThreadName=A执行了add方法！
ThreadName=A退出了add方法！
ThreadName=B执行了add方法！
ThreadName=B退出了add方法！
ThreadName=A执行了add方法！
ThreadName=A退出了add方法！
ThreadName=A执行了add方法！
ThreadName=A退出了add方法！
ThreadName=B执行了add方法！
ThreadName=B退出了add方法！
ThreadName=B执行了add方法！
ThreadName=B退出了add方法！
ThreadName=B执行了add方法！
ThreadName=B退出了add方法！
ThreadName=B执行了add方法！
ThreadName=B退出了add方法！
ThreadName=B执行了add方法！
ThreadName=B退出了add方法！

 但是A 和B 线程是异步的，这种情况下就有可能出现脏读

 当A 和B 两个线程执行带有分支判断的方法时，就会出现逻辑上的错误，有可能出现脏读

分支结构if

package mylist;
import java.util.ArrayList;
import java.util.List;
public class MyOneList {
	private List list = new ArrayList();
	synchronized public void add(String data) {
		list.add(data);
	};
	synchronized public int getSize() {
		return list.size();
	};
}

package mythread;
import mylist.MyOneList;
import service.MyService;
public class MyThread1 extends Thread {
	private MyOneList list;
	public MyThread1(MyOneList list) {
		super();
		this.list = list;
	}
	@Override
	public void run() {
		MyService msRef = new MyService();
		msRef.addServiceMethod(list, "A");
	}
}

package mythread;
import service.MyService;
import mylist.MyOneList;
public class MyThread2 extends Thread {
	private MyOneList list;
	public MyThread2(MyOneList list) {
		super();
		this.list = list;
	}
	@Override
	public void run() {
		MyService msRef = new MyService();
		msRef.addServiceMethod(list, "B");
	}
}

原来的程序是这样的

package service;

import mylist.MyOneList;

public class MyService {

	public MyOneList addServiceMethod(MyOneList list, String data) {
		try {
//			synchronized (list) {
				if (list.getSize() < 1) {
					Thread.sleep(2000);
					list.add(data);
				}
//			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		return list;
	}

}

package test;
import mylist.MyOneList;
import mythread.MyThread1;
import mythread.MyThread2;
public class Run {
	public static void main(String[] args) throws InterruptedException {
		MyOneList list = new MyOneList();
		MyThread1 thread1 = new MyThread1(list);
		thread1.setName("A");
		thread1.start();
		MyThread2 thread2 = new MyThread2(list);
		thread2.setName("B");
		thread2.start();
		
		Thread.sleep(6000);
		
		System.out.println("listSize=" + list.getSize());
	}
}

运行结果

把MyService 类中的注释放开的话，就正常了

package service;
import mylist.MyOneList;
public class MyService {
	public MyOneList addServiceMethod(MyOneList list, String data) {
		try {
			synchronized (list) {
				if (list.getSize() < 1) {
					Thread.sleep(2000);
					list.add(data);
				}
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		return list;
	}
}