线程安全问题

共计 3528 个字符，预计需要花费 9 分钟才能阅读完成。

1、为什么出现线程安全问题？

首先想为什么出现问题?(也是我们判断是否有问题的标准)
是否是多线程环境
是否有共享数据
是否有多条语句操作共享数据

public class SellTicket implements Runnable {// 定义 100 张票 
	private static int tickets = 100;
 
	// 定义同一把锁 
	private Object obj = new Object();
	private Demo d = new Demo();
 
	private int x = 0;
	
	// 同步代码块用 obj 做锁 
//	@Override
//	public void run() {
//		while (true) {
//			synchronized (obj) {
//				if (tickets > 0) {
//					try {
//						Thread.sleep(100);
//					} catch (InterruptedException e) {
//						e.printStackTrace();
//					}
//					System.out.println(Thread.currentThread().getName()
//							+ "正在出售第" + (tickets--) + "张票");
//				}
//			}
//		}
//	}
	
	// 同步代码块用任意对象做锁 
//	@Override
//	public void run() {
//		while (true) {
//			synchronized (d) {
//				if (tickets > 0) {
//					try {
//						Thread.sleep(100);
//					} catch (InterruptedException e) {
//						e.printStackTrace();
//					}
//					System.out.println(Thread.currentThread().getName()
//							+ "正在出售第" + (tickets--) + "张票");
//				}
//			}
//		}
//	}
	
	@Override
	public void run() {while (true) {if(x%2==0){synchronized (SellTicket.class) {if (tickets > 0) {try {Thread.sleep(100);
						} catch (InterruptedException e) {e.printStackTrace();
						}
						System.out.println(Thread.currentThread().getName()
								+ "正在出售第" + (tickets--) + "张票");
					}
				}
			}else {//				synchronized (d) {
//					if (tickets > 0) {
//						try {
//							Thread.sleep(100);
//						} catch (InterruptedException e) {
//							e.printStackTrace();
//						}
//						System.out.println(Thread.currentThread().getName()
//								+ "正在出售第" + (tickets--) + "张票");
//					}
//				}
				
				sellTicket();}
			x++;
		}
	}
 
//	private void sellTicket() {
//		synchronized (d) {
//			if (tickets > 0) {
//			try {
//					Thread.sleep(100);
//			} catch (InterruptedException e) {
//					e.printStackTrace();
//			}
//			System.out.println(Thread.currentThread().getName()
//						+ "正在出售第" + (tickets--) + "张票");
//			}
//		}
//	}
	
	// 如果一个方法一进去就看到了代码被同步了，那么我就再想能不能把这个同步加在方法上呢?
//	 private synchronized void sellTicket() {
//			if (tickets > 0) {
//			try {
//					Thread.sleep(100);
//			} catch (InterruptedException e) {
//					e.printStackTrace();
//			}
//			System.out.println(Thread.currentThread().getName()
//						+ "正在出售第" + (tickets--) + "张票");
//			}
//	}
	
	private static synchronized void sellTicket() {if (tickets > 0) {try {Thread.sleep(100);
		} catch (InterruptedException e) {e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()
					+ "正在出售第" + (tickets--) + "张票");
		}
}
}
 
class Demo {
}

/*
 * A: 同步代码块的锁对象是谁呢?
 * 		任意对象。* 
 * B: 同步方法的格式及锁对象问题?
 * 		把同步关键字加在方法上。* 
 * 		同步方法是谁呢?
 * 			this
 * 
 * C: 静态方法及锁对象问题?
 * 		静态方法的锁对象是谁呢?
 * 			类的字节码文件对象。(反射会讲)
 */
public class SellTicketDemo {public static void main(String[] args) {// 创建资源对象 
		SellTicket st = new SellTicket();
 
		// 创建三个线程对象 
		Thread t1 = new Thread(st, "窗口 1");
		Thread t2 = new Thread(st, "窗口 2");
		Thread t3 = new Thread(st, "窗口 3");
 
		// 启动线程 
		t1.start();
		t2.start();
		t3.start();}
}

2、如何解决线程安全问题？

基本思想：让程序没有安全问题的环境。
怎么实现呢?
把多个语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可。

解决线程安全问题实现 1

同步代码块
格式：
synchronized(对象){需要同步的代码;}
同步可以解决安全问题的根本原因就在那个对象上。该对象如同锁的功能。
同步代码块的对象可以是哪些呢?

同步的特点

同步的前提
多个线程
多个线程使用的是同一个锁对象
同步的好处
同步的出现解决了多线程的安全问题。
同步的弊端
当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。

解决线程安全问题实现 2
同步方法
就是把同步关键字加到方法上
同步方法的锁对象是什么呢?

如果是静态方法，同步方法的锁对象又是什么呢?
那么，我们到底使用谁?
如果锁对象是 this，就可以考虑使用同步方法。
否则能使用同步代码块的尽量使用同步代码块。

3、死锁问题

同步弊端
效率低
如果出现了同步嵌套，就容易产生死锁问题
死锁问题及其代码
是指两个或者两个以上的线程在执行的过程中，因争夺资源产生的一种互相等待现象
同步代码块的嵌套案例

public class MyLock {// 创建两把锁对象 
	public static final Object objA = new Object();
	public static final Object objB = new Object();}

class DieLock extends Thread {private boolean flag;
 
	public DieLock(boolean flag) {this.flag = flag;
	}
 
	@Override
	public void run() {if (flag) {synchronized (MyLock.objA) {System.out.println("if objA");
				synchronized (MyLock.objB) {System.out.println("if objB");
				}
			}
		} else {synchronized (MyLock.objB) {System.out.println("else objB");
				synchronized (MyLock.objA) {System.out.println("else objA");
				}
			}
		}
	}
}

/*
 * 同步的弊端：* 		A: 效率低
 * 		B: 容易产生死锁
 * 
 * 死锁：* 		两个或两个以上的线程在争夺资源的过程中，发生的一种相互等待的现象。* 
 * 举例：* 		中国人，美国人吃饭案例。* 		正常情况：* 			中国人: 筷子两支
 * 			美国人: 刀和叉
 * 		现在：* 			中国人：筷子 1 支，刀一把
 * 			美国人：筷子 1 支，叉一把
 */
public class DieLockDemo {public static void main(String[] args) {DieLock dl1 = new DieLock(true);
		DieLock dl2 = new DieLock(false);
 
		dl1.start();
		dl2.start();}
}