黑马程序员——java中关于同步函数（或同步代码块）解决多线程安全问题的加锁

------- android培训、 java培训、期待与您交流！ ----------

重点：多锁解决安全问题（同步静态函数和非静态函数），懒汉式（单例模式的一种）的加锁问题。    

先举例说明说明线程的安全问题。

一、

    有一个需求：有四个窗口卖票，用java模拟其卖票过程。

需求分析：必须用四个多线程解决。

代码如下：

class Tickets implements Runnable {
	private int tickets = 100;

	public void run() {
		while (true) {
			if (tickets > 0) {
				try {
					Thread.sleep(1);
				} catch (Exception e) {
				}
				System.out.println(Thread.currentThread().getName()
						+ "---tickets---" + tickets--);

			}
		}
	}
}

class ThreadDemo {
	public static void main(String[] args) {
		Tickets t = new Tickets();
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		Thread t3 = new Thread(t);
		Thread t4 = new Thread(t);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

    运行结果如下：

    出现了0,-1和-2，这显然是不符合实际情况的，也就是说多线程出现了安全隐患。

    问题原因分析：当执行到下列代码时

if(tickets>0){
	try
	{
		Thread.sleep(1);
	}
	catch (Exception e){
		
	}
	}

    System.out.println(Thread.currentThread().getName()+"---tickets---"+tickets--)，该代码块出现了线程共同数据tickets，当一个线程执行了一句sleep了1毫秒，另一个线程进来了也sleep了1毫秒，第一个线程醒来执行了打印操作并减1，这是tickets已经是零了，但是另一个线程同样执行了打印操作，这样就产生了错误。也就是说，当多个线程对同一数据进行操作时，如果对该数据的操作不止一行代码，则有可能发生安全问题。

      

    解决方法：对该数据操作的代码块加锁。有必要加锁的前提是：有多个线程对同一数据进行多行代码操作。检查方法是，1.先找出多个线程执行了那些代码块。2.这些代码中有没有共同（或共享）数据。3.操作该共同数据的代码是否有多行。如果以上三条都满足的话。则必须要加锁（也就是同步代码块或者同步函数）。现改写代码如下：

class Tickets implements Runnable {
	Object obj = new Object();
	private int tickets = 100;

	public void run() {
		while (true) {
			synchronized (obj) {
				if (tickets > 0) {
					try {
						Thread.sleep(1);
					} catch (Exception e) {
					}
					System.out.println(Thread.currentThread().getName()
							+ "---tickets---" + tickets--);

				}
			}
		}
	}
}

class ThreadDemo {
	public static void main(String[] args) {
		Tickets t = new Tickets();
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		Thread t3 = new Thread(t);
		Thread t4 = new Thread(t);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

运行结果正常。

二、

    现在我改成两个线程运行，并且用了两个同步，一个是同步代码块，一个是同步函数（即加了两把锁），代码如下：

class Tickets implements Runnable {
	Object obj = new Object();
	Object obj1 = new Object();
	private int tickets = 100;
	boolean flag = true;

	public void run() {
		if (flag) {
			while (true) {
				synchronized (obj) {
					if (tickets > 0) {
						try {
							Thread.sleep(10);
						} catch (Exception e) {
						}
						System.out.println(Thread.currentThread().getName()
								+ "---tickets---" + tickets--);

					}
				}
			}
		} else
			while (true)
				show();
	}

	public synchronized void show() {
		if (tickets > 0) {
			try {
				Thread.sleep(10);
			} catch (Exception e) {
			}
			System.out.println(Thread.currentThread().getName()
					+ "---tickets---" + tickets--);

		}
	}
}

class ThreadDemo {
	public static void main(String[] args) {
		Tickets t = new Tickets();
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		t1.start();
		try {
			Thread.sleep(1);
		} catch (Exception e) {
		}
		t.flag = false;
		t2.start();
	}
}

运行结果如下：

tickets0出现了，显然又是错误的。

    原因分析：因为用了两个同步，但不是同一把锁，所以导致了问题的出现。所以第一看是不是多线程，第二要看是不是用了同一把锁，如果是同一把锁的话才能解决同步问题。因为同步函数的同步用的调用对象，而同步代码块用的自定义的obj，所以把obj换成this就搞定了。

    结论是：多线程调用两个及以上同步代码块处理共同数据时必须用同一对象（即同一把锁）才能解决安全问题。

三、

    因静态函数随着类的加载而加载 ，不随对象产生。当我把同步函数改成静态的，那当同步静态代码块时synchronized用哪个对象呢？ 原来当类加载到内存中时，已经产生了一个叫类名.class的对象，所以这是把obj改成Tickets.class即可。

四、

    懒汉式单例模式的多线程安全问题。

假设有一个单例模式如下：

class Demo {
	private Demo() {
	}

	private Demo d = null;

	public static Demo getInstance() {

		if (d == null)
			d = new Demo();
		return d;
	}
}

当有多个线程执行这些语句时，因为要对共同数据d做操作，而d不止一条语句，所以容易出现安全问题而造成了不止建立一个对象，违背了单例模式。所以解决方案依然是使用synchronized语句进行加锁。代码如下：

class Demo {
	private Demo() {
	}

	private static Demo d = null;

	public static Demo getInstance() {
		if (d == null) {
			synchronized (Demo.class) {
				if (d == null)
					d = new Demo();
			}
		}
		return d;
	}
}