多线程开发，表示很凌乱

上面说法可能理解会有错误，楼主如果站在一个对象的内部来考虑线程安全，那么上面说法是正确的，但如果从类的外部来考虑，比如：如果一个方法的参数是一个对象，而多个线程调用该方法时传入的参数是同一个对象，那么这个对象确实不是线程安全的。这是由于参数的引用传递导致。我对线程的理解并没有深入到JVM实现中去，但是希望给楼主提供一个简单的思路去考虑线程安全。

下面举个例子：

public void run() {
     Model object = new Model();

     object.changeMap1();

     object.changeMap2();
}


public class Model{
     private static Map map1 = new HashMap();

     private Map map2 = new HashMap();

     public void changeMap1() {
        //.....change map1
     }

     public void changeMap2() {
        //.....change map2
     }
}

 run方法中，他创建了一个Model对象。Model类中，定义有2个map和2个操作对应map的方法，其中map1是static的。楼主现在能判断这2个changeMap方法是不是线程安全的吗？

如果不能，以下是思路：

1、首先明确，类变量才有线程安全问题，在Model类内部，咋看之下这2个方法都不是线程安全的，因为他们都改变了类变量map的值。

2、但是跳出Model类，在run方法中，Model的实例object是run方法的一个临时变量，那么就发生了变化，多个线程执行run方法时，会创建多个Model对象，Model对象中的map2也会有多个且之间没有任何关系，所以changeMap2方法是线程安全的，因为他们根本不是访问的同一个map。

3、同理，虽然多线程也创建了多个Model对象，但是对map1而言，因为他是static的，map1只会创建一次！是单例的！，所有线程在调用changeMap1方法时都是访问同一个map，所以changeMap1不是线程安全的方法，需要加上synchronized关键字标识。

/**
	 * 还是要看目标对象被并发使用的上下文有几个，跟是不是方法的local变量没关系吧
	 */
	private void dummy() {
		//这是个方法内的本地变量吧？
		final AtomicInteger ai = new AtomicInteger(0);
		for (int i=0; i<10; i++) {
			ai.incrementAndGet();
			new Thread() {
				public void run() {
					ai.decrementAndGet();
				}
			}.start();
		}
		System.out.println(ai);//等于几？
	}

/**
	 * 还是要看目标对象被并发使用的上下文有几个，跟是不是方法的local变量没关系吧
	 */
	private void dummy() {
		//这是个方法内的本地变量吧？
		final AtomicInteger ai = new AtomicInteger(0);
		for (int i=0; i<10; i++) {
			ai.incrementAndGet();
			new Thread() {
				public void run() {
					ai.decrementAndGet();
				}
			}.start();
		}
		System.out.println(ai);//等于几？
	}

嗯。。。

/**
	 * 还是要看目标对象被并发使用的上下文有几个，跟是不是方法的local变量没关系吧
	 */
	private void dummy() {
		//这是个方法内的本地变量吧？
		final AtomicInteger ai = new AtomicInteger(0);
		for (int i=0; i<10; i++) {
			ai.incrementAndGet();
			new Thread() {
				public void run() {
					ai.decrementAndGet();
				}
			}.start();
		}
		System.out.println(ai);//等于几？
	}

受教了，对于我而言，我还是会尽量避免这种写法。。