线程的同步问题

我觉得这是一篇极好的文章，可以帮助你更深层次地理解java。

http://blog.youkuaiyun.com/aaa1117a8w5s6d/article/details/8251456   《java中的各种数据类型在内存中存储的方式》

下面我就最近对java线程的了解，稍微写点东西，当然，很多东西都是参考别人的文章，不过时间有点久了，找不到原作者

只是保留了当时为了验证而从原作者那拷贝的一些程序，如有冒犯，请多包涵。

实现：

    程序是让10个线程在控制台上数数，从1数到99。要求，一个线程数完，然后才是另一个线程开始数数。

    （难点：如何让各个线程不争抢报数）

第一种实现：

public class ThreadTest extends Thread {   
    private int threadNo;   
    public ThreadTest(int threadNo) {   
        this.threadNo = threadNo;   
    }   
    public static void main(String[] args) throws Exception {   
        for (int i = 1; i < 10; i++) {   
           new ThreadTest(i).start();   
            Thread.sleep(1);   
        }   
     }   
    
    @Override  
     public synchronized void run() {   
        for (int i = 1; i < 100; i++) {   
            System.out.println("No." + threadNo + ":" + i);  
            
        }   
     }   
 }   

该函数运行之后，程序截图如下：

原因分析：这实际上是以这个成员方法所在的对象本身作为对象锁。在本例中，就是 以ThreadTest类的一个具体对象，也就是该线程自身作为对象锁。

该程序中有10个对象，每个线程有自己的对象锁。没有临界区的概念，也就不会起到同步的效果了。

第二种实现：

public class ThreadTest2 extends Thread {
	private int threadNo;
	private String lock;

	public ThreadTest2(int threadNo, String lock) {
		this.threadNo = threadNo;
		this.lock = lock;
	}

	public static void main(String[] args) throws Exception {
		String lock = new String("lock");
		for (int i = 1; i < 10; i++) {
			new ThreadTest2(i, lock).start();
			Thread.sleep(1);
		}
	}

	public void run() {
		synchronized (lock) {
			for (int i = 1; i < 100; i++) {
				System.out.println("No." + threadNo + ":" + i);
			}
		}
	}
}

该程序运行截图如下：

原因分析：我们发现，启动10个线程之前，main方法创建了一个String类型的对象，并且通过构造函数，

将这个对象赋值 给每一个ThreadTest2线程对象中的私有变量lock，这些线程的lock变量实际上指向的是堆内存中的 同一个区域，即存放main函数中的lock变量的区域。

在这里，就体现出了临界区的概念，当然，程序在执行时由于对该临界区有上锁，所以会一个个执行。

第三种实现：

public class ThreadTest3 extends Thread {
	private int threadNo;

	public ThreadTest3(int threadNo) {
		this.threadNo = threadNo;
	}

	public static void main(String[] args) throws Exception {
		for (int i = 1; i < 10; i++) {
			new ThreadTest3(i).start();
			Thread.sleep(1);
		}
	}

	public static synchronized void abc(int threadNo) {
			for (int i = 1; i < 100; i++) {
				System.out.println("No." + threadNo + ":" + i);
		}
	}
	 public void run() {   
		 abc(threadNo);   
	 } 
}

程序截图：

原因分析： 由于该abc()方法是用static来修饰的，static方法的初始化是在类加载，也就是第一次用到这个类的时候初始化，对于后来的实例的创建，不再次进行初始化。

也就是说，这10个线程，共用的是同一个abc()方法。该方法也是临界区的概念，理所当然，对其加锁也可以起到同步的作用。

另外的一点说明：

有细心的读者可以也会去一个个试验程序，关于后两个同步的例子，由于10个线程是先后创建出来的。除了第一个线程创建出来后立即执行报数。

后面的9个线程则在等待池中等待锁定释放。而该锁被释放后，具体是哪个线程抢到该锁则不固定。