synchronized同步方法简单介绍（一）

非线程安全和线程安全

非线程安全：其实会在多个线程对同一个对象中的实例变量进行并发访问时产生，结果就是脏读。

线程安全：获得的实例变量的值经过同步处理，不会出现脏读的现象。

一个方法中的变量不存在非线程安全问题，永远都是线程安全的。这是因为方法内部的变量是私有特性造成的。

代码如下解读

public class HasSelfPrivateNum {

	public void addI(String username) {
		try {
			int num = 0;//注意该变量在方法内部
			if (username.equals("a")) {
				num = 100;
				System.out.println("a set over!");
				Thread.sleep(2000);
			} else {
				num = 200;
				System.out.println("b set over!");
			}
			System.out.println(username + " num=" + num);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

public class ThreadA extends Thread {

	private HasSelfPrivateNum numRef;

	public ThreadA(HasSelfPrivateNum numRef) {
		super();
		this.numRef = numRef;
	}

	@Override
	public void run() {
		super.run();
		numRef.addI("a");
	}

}

public class ThreadB extends Thread {

	private HasSelfPrivateNum numRef;

	public ThreadB(HasSelfPrivateNum numRef) {
		super();
		this.numRef = numRef;
	}

	@Override
	public void run() {
		super.run();
		numRef.addI("b");
	}

}

public class Run {

	public static void main(String[] args) {

		HasSelfPrivateNum numRef = new HasSelfPrivateNum();

		ThreadA athread = new ThreadA(numRef);
		athread.start();

		ThreadB bthread = new ThreadB(numRef);
		bthread.start();

	}

}

把上面的代码改成如下：不加同步出现脏读，加上没有问题

结论：两个线程访问同一个对象中的同步方法时一定是线程安全的

public class HasSelfPrivateNum {

	//该变量放在方法的外面 不安全
	private int num = 0;

	//加上synchronized后多个线程并发访问，只能排队访问资源，不会出现线程安全问题
	 public synchronized void addI(String username) {
		try {
			if (username.equals("a")) {
				num = 100;
				System.out.println("a set over!");
				Thread.sleep(2000);
			} else {
				num = 200;
				System.out.println("b set over!");
			}
			System.out.println(username + " num=" + num);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

再对上面的main（）代码改造。

public class Run {

	public static void main(String[] args) {
		
		//两个线程访问两个不同的实例的相同的同步方法，结果异步执行
		HasSelfPrivateNum numRef1 = new HasSelfPrivateNum();
		HasSelfPrivateNum numRef2 = new HasSelfPrivateNum();

		ThreadA athread = new ThreadA(numRef1);
		athread.start();

		ThreadB bthread = new ThreadB(numRef2);
		bthread.start();

	}

}

总结：关键字synchronized获得的锁都是对象锁，不是说的吧一段代码或者方法当做锁，上面的案例就是那个线程先执行带synchronized关键字的方法，那个线程就持有该方法所属对象的锁Lock，其他线程只能等待，前提是多个线程访问同一个对象。这里不做synchronized锁的是对象代码阐述。