java线程安全问题

什么是线程安全

线程安全问题的产生必须满足一下三个条件：

• 多个线程
• 多个线程共享同一个静态变量或者全局变量变量
• 对共享变量做写操作

一句话表达：当多个线程共享同一个静态变量或者全局变量时，并且对共享变量进行写操作，那么久很有可能产生线程安全问题。

下面举例说明

先进行一次单线程操作：
既是把第二个线程注释了，不运行第二个线程。

package com.jwb;

public class ThreadDemo {
	// 这是一个全局变量
	public static int count = 10;

	public static void main(String[] args) {
		// 一个线程
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				while (count > 0) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					count = count - 1; // 对共享变量做写操作
					System.out.println(Thread.currentThread().getName() + ":当前count = " + count);
				}
			}
		});
		// 另一个线程
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				while (count > 0) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					count = count - 1; // 对共享变量做写操作
					System.out.println(Thread.currentThread().getName() + ":当前count = " + count);
				}
			}
		});
		t1.start();
//		t2.start();
	}

}

运行结果如下:
第一次运行：

Thread-0:当前count = 9
Thread-0:当前count = 8
Thread-0:当前count = 7
Thread-0:当前count = 6
Thread-0:当前count = 5
Thread-0:当前count = 4
Thread-0:当前count = 3
Thread-0:当前count = 2
Thread-0:当前count = 1
Thread-0:当前count = 0

第二次运行：

Thread-0:当前count = 9
Thread-0:当前count = 8
Thread-0:当前count = 7
Thread-0:当前count = 6
Thread-0:当前count = 5
Thread-0:当前count = 4
Thread-0:当前count = 3
Thread-0:当前count = 2
Thread-0:当前count = 1
Thread-0:当前count = 0

第三次运行：

Thread-0:当前count = 9
Thread-0:当前count = 8
Thread-0:当前count = 7
Thread-0:当前count = 6
Thread-0:当前count = 5
Thread-0:当前count = 4
Thread-0:当前count = 3
Thread-0:当前count = 2
Thread-0:当前count = 1
Thread-0:当前count = 0

再进行一次多线程操作：
既是吧第二个线程也运行起来。

package com.jwb;

public class ThreadDemo {
	// 这是一个全局变量
	public static int count = 10;

	public static void main(String[] args) {
		// 一个线程
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				while (count > 0) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					count = count - 1; // 对共享变量做写操作
					System.out.println(Thread.currentThread().getName() + ":当前count = " + count);
				}
			}
		});
		// 另一个线程
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				while (count > 0) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					count = count - 1; // 对共享变量做写操作
					System.out.println(Thread.currentThread().getName() + ":当前count = " + count);
				}
			}
		});
		t1.start();
		t2.start();
	}

}

以上代码就是一个会出现线程安全的代码，多个线程对同一个全局变量进行了写的操作，运行多出后，打印结果如下：

第一次运行：

Thread-0:当前count = 8
Thread-1:当前count = 8
Thread-0:当前count = 7
Thread-1:当前count = 6
Thread-0:当前count = 5
Thread-1:当前count = 4
Thread-0:当前count = 3
Thread-1:当前count = 2
Thread-0:当前count = 1
Thread-1:当前count = 0
Thread-0:当前count = -1

第二次运行：

Thread-0:当前count = 9
Thread-1:当前count = 9
Thread-0:当前count = 8
Thread-1:当前count = 7
Thread-0:当前count = 6
Thread-1:当前count = 6
Thread-0:当前count = 5
Thread-1:当前count = 4
Thread-0:当前count = 2
Thread-1:当前count = 2
Thread-0:当前count = 0
Thread-1:当前count = 0

第三次运行：

Thread-1:当前count = 8
Thread-0:当前count = 8
Thread-1:当前count = 6
Thread-0:当前count = 6
Thread-1:当前count = 4
Thread-0:当前count = 4
Thread-0:当前count = 3
Thread-1:当前count = 2
Thread-0:当前count = 1
Thread-1:当前count = 0

由此看来，线程安全问题，会超出变量的数据并非我们所预期，与单线程时运行的打印结果又差异，并且，每次运行的结果都有所不同，这样的结果，在开发中是不可取的。

线程安全解决办法

下面是解决线程安全的方法。

解决线程安全的思想主要就是让多线程之间同步，既是当多个线程在操作同一个变量时，每个线程类似排队进行执行，“每一次”只能允许一个线程执行操作。

java中有提供了关键字synchronized解决线程同步。下面举例：

例子中还是在前面的代码的基础上进行修改：

package com.jwb;

public class ThreadDemo {
	// 这是一个全局变量
	public static int count = 10;

	public static void main(String[] args) {
		Object lockObject = new Object();

		// 一个线程
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				while (count > 0) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					synchronized (lockObject) { // 线程同步
						if (count > 0) {
							count = count - 1; // 对共享变量做写操作
							System.out.println(Thread.currentThread().getName() + ":当前count = " + count);
						}
					}
				}
			}
		});
		// 另一个线程
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				while (count > 0) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					synchronized (lockObject) { // 线程同步
						if (count > 0) {
							count = count - 1; // 对共享变量做写操作
							System.out.println(Thread.currentThread().getName() + ":当前count = " + count);
						}
					}
				}
			}
		});
		t1.start();
		t2.start();
	}

}

执行结果如下：
第一次运行：

Thread-1:当前count = 9
Thread-0:当前count = 8
Thread-1:当前count = 7
Thread-0:当前count = 6
Thread-1:当前count = 5
Thread-0:当前count = 4
Thread-0:当前count = 3
Thread-1:当前count = 2
Thread-0:当前count = 1
Thread-1:当前count = 0

第二次运行：

Thread-1:当前count = 9
Thread-0:当前count = 8
Thread-1:当前count = 7
Thread-0:当前count = 6
Thread-1:当前count = 5
Thread-0:当前count = 4
Thread-1:当前count = 3
Thread-0:当前count = 2
Thread-1:当前count = 1
Thread-0:当前count = 0

第三次运行：

Thread-0:当前count = 9
Thread-1:当前count = 8
Thread-1:当前count = 7
Thread-0:当前count = 6
Thread-1:当前count = 5
Thread-0:当前count = 4
Thread-1:当前count = 3
Thread-0:当前count = 2
Thread-1:当前count = 1
Thread-0:当前count = 0

由此看来，同步线程以后，线程安全的问题已经得到了解决。

synchronized的用法注意事项

同步代码块

第一种用法，就是上一段代码中的使用方法，就是同步代码块。

// 同步代码块
synchronized (lockObject) {
    // ...
}

注意事项：此处的lockObject必须是同一个对象实例，可以是任意的实例对象比如常用的this，该对象被称为锁对象。

同步函数

// 同步函数
public synchronized void func(){
    // ...
}

注意事项：同步函数时，synchronized使用的同步锁对象是this对象(既函数所属的实例对象)，也就是说，当使用同步代码块时，如果也用的this作为锁对象，同样可以实现线程同步，否则是不能实现的。
举例看看：

先是一个线程同步的例子：

package com.jwb;

public class ThreadDemo2 {
	// 这是一个全局变量
	public static int count = 10;

	static class SyFun {
		// 同步函数
		public synchronized void fun() {
			if (count > 0) {
				count = count - 1; // 对共享变量做写操作
				System.out.println(Thread.currentThread().getName() + ":当前count = " + count);
			}
		}
	}

	public static void main(String[] args) {
		SyFun sf = new SyFun();

		// 一个线程
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				while (count > 0) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					synchronized (sf) { // 注意，此处不能用this，因为此处的this是变量t1，所有应该用sf
						if (count > 0) {
							count = count - 1; // 对共享变量做写操作
							System.out.println(Thread.currentThread().getName() + ":当前count = " + count);
						}
					}
				}
			}
		});
		// 另一个线程
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				while (count > 0) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					sf.fun();// 执行同步方法
				}
			}
		});
		t1.start();
		t2.start();
	}

}

打印结果：

Thread-0:当前count = 9
Thread-1:当前count = 8
Thread-1:当前count = 7
Thread-0:当前count = 6
Thread-1:当前count = 5
Thread-0:当前count = 4
Thread-0:当前count = 3
Thread-1:当前count = 2
Thread-1:当前count = 1
Thread-0:当前count = 0

再给一个例子，没有实现线程同步的例子：

package com.jwb;

public class ThreadDemo2 {
	// 这是一个全局变量
	public static int count = 10;

	static class SyFun {
		// 同步函数
		public synchronized void fun() {
			if (count > 0) {
				count = count - 1; // 对共享变量做写操作
				System.out.println(Thread.currentThread().getName() + ":当前count = " + count);
			}
		}
	}

	public static void main(String[] args) {
		SyFun sf = new SyFun();

		// 一个线程
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				while (count > 0) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					synchronized (new Object()) { 
						if (count > 0) {
							count = count - 1; // 对共享变量做写操作
							System.out.println(Thread.currentThread().getName() + ":当前count = " + count);
						}
					}
				}
			}
		});
		// 另一个线程
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				while (count > 0) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					sf.fun();// 执行同步方法
				}
			}
		});
		t1.start();
		t2.start();
	}
}

打印结果：

Thread-1:当前count = 8
Thread-0:当前count = 8
Thread-1:当前count = 7
Thread-0:当前count = 6
Thread-1:当前count = 5
Thread-0:当前count = 4
Thread-0:当前count = 2
Thread-1:当前count = 2
Thread-0:当前count = 0
Thread-1:当前count = 0

静态函数同步

静态函数的同步使用方法和上面提到的同步函数的使用是一样的，唯一不一样的区别在于：
同步函数的锁对象是当前实例对象，静态同步函数的锁对象是所在类的字节码对象（既.class对象）。其他的都一样，此处不做累述。

线程死锁

使用线程同步时，如果同步嵌套了，就有可能会出现锁无法释放，导致死锁的现象。例如一下的例子：

package com.jwb;

public class ThreadDemo3 {

	public static void main(String[] args) {
		Object o1 = new Object();
		Object o2 = new Object();

		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				while (true) {
					synchronized (o1) {
						System.out.println("线程1：外同步代码");
						synchronized (o2) {
							System.out.println("线程1：内同步代码");
						}
					}
				}
			}
		});

		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				while (true) {
					synchronized (o2) {
						System.out.println("线程2：外同步代码");
						synchronized (o1) {
							System.out.println("线程2：内同步代码");
						}
					}
				}
			}
		});
		t1.start();
		t2.start();
	}

}

执行结果如下：

程序卡住了，没有再继续执行下去，也没有退出，这个现象就是死锁造成的，具体原因是:

• 第一步：当线程1执行到了外层的同步代码块时，获取o1对象为锁，同时线程2的外层同步代码也获取了o2对象锁。
• 第二步（下面两点是同时执行的）：
  • 1.当线程1执行到了内层同步代码块时，发现o2这个对象锁并没有被释放，因为线程2此时并没有执行完代码。
  • 2.当线程2执行到了内层同步代码块时，发现o1这个对象锁并没有被释放，因为线程1此时并没有执行完代码。
• 第三步：两个线程就这样，一直的互相等待下去，就造成了死锁。所有，在开发中，尽量不要使用同步嵌套。