6、线程安全

线程安全问题是如何产生的:
多个线程同时争抢一个公共资源。当一个线程执行到一半的时候，线程失去时间片，处于等待状态，其他线程修改公共资源。此时当这个属于等待状态的线程再回来的时候，继续操作的数据就是修改之后的，而这个时候两个线程都修改过这个资源，就容易造成问题。

如何解决：
使用锁机制。在可能出现线程安全问题的代码块部分，加上锁，这么锁通常在普通方法的时候是this，在static方法的时候是类名.class这个对象。一个线程将一段代码加上锁之后，这个段代码不进行完，这个锁对象不会被释放。其他的线程即便准备执行这段代码由于拿不到锁对象也会无法执行。

两种加锁的方式：
一：synchronized代码块

/*
 * 本类用于演示第二种实现Runnable接口的方式多线程
 * 三个窗口卖100张票，卖完退出
 * 实现Runnable接口的方式由于开启多线程的时候创建的多个Thread对象，所以只需要一个自定义线程类对象，
 * 那么这个自定义线程类对象的普通属性就可以被多个线程同时方法。所以我们说实现Runnable接口的方式更适合多个线程访问同一个数据。
 * 本类采用synchronized代码块处理线程安全问题
 */
public class SellTicket implements Runnable {

	private int ticket = 100;
	@Override
	public void run() {
		// TODO Auto-generated method stub
		
		while(true){
			//synchronized同步代码块，被代码块括中的内容，在一个线程没有执行完所有代码的时候，其他线程是无执行这段代码。
			//担任锁对象这个对象必须保证所有的线程用的是同一个锁对象。普通方法的锁对象通常就是this。
			synchronized (this) {
				if(ticket <= 0){
					System.out.println("票已卖完================，退出");
					break;
				}
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"售票窗口卖出一张票~~~~~~~~~~~~~~~~~当前还剩余："+(--ticket));
			}
		}
	}

}

synchronized代码块需要一个锁对象，通常普通方法这个锁对象就是this。
二：synchronized方法
当一个方法里所有的代码都应该被synchronized代码块括中的时候，就直接将这个synchronized关键字加上方法的修饰上。此时方法内所有的代码是线程安全的。那么锁对象就是this，不能更改。

/*
 * 本类用于演示第二种实现Runnable接口的方式多线程
 * 三个窗口卖100张票，卖完退出
 * 实现Runnable接口的方式由于开启多线程的时候创建的多个Thread对象，所以只需要一个自定义线程类对象，
 * 那么这个自定义线程类对象的普通属性就可以被多个线程同时方法。所以我们说实现Runnable接口的方式更适合多个线程访问同一个数据。
 * 本类采用synchronized方法处理线程安全问题
 */
public class SellTicket2 implements Runnable {

	private int ticket = 100;
	private boolean flag = true;
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while (flag) {
			sellSticket();
		}
	}

	// 线程安全的方法，synchronized的方法相当于将一个synchronized代码块的开始和方法的开始一起，结束和方法的结束一起。
	// synchronized的方法的锁对象就是this
	public synchronized void sellSticket() {
		// synchronized同步代码块，被代码块括中的内容，在一个线程没有执行完所有代码的时候，其他线程是无执行这段代码。
		// 担任锁对象这个对象必须保证所有的线程用的是同一个锁对象。普通方法的锁对象通常就是this。
		if (ticket <= 0) {
			System.out.println("票已卖完================，退出");
			flag = false;
			return;
		}
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName() + "售票窗口卖出一张票~~~~~~~~~~~~~~~~~当前还剩余：" + (--ticket));
	}

}

注意：由于锁机制是将原本的多线程编程单线程。所以加了锁的代码执行效率会降低。

线程的死锁问题：
死锁
不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
解决方法
专门的算法、原则
尽量减少同步资源的定义

public class TestDeadThread {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		DeadThreadDemo one = new DeadThreadDemo();
		one.setFlag(true);//绑匪开始工作
		one.start();
		DeadThreadDemo two = new DeadThreadDemo();
		two.setFlag(false);//马先生开始工作
		two.start();
		
		
	}

}

class DeadThreadDemo extends Thread{

	private boolean flag;
	private static BadBoy bb = new BadBoy();
	private static MrMa mm = new MrMa();
	
	public boolean isFlag() {
		return flag;
	}

	public void setFlag(boolean flag) {
		this.flag = flag;
	}
	//想做出死锁的效果首先需要两把锁，需要两把锁互相调用。
	@Override
	public void run() {
		// TODO Auto-generated method stub
		if(flag){
			synchronized (bb) {
				bb.say();
				synchronized (mm) {
					bb.get();
				}
			}
			
		}else{
			synchronized (mm) {
				mm.say();
				synchronized (bb) {
					mm.get();
				}
			}
			
		}
	}
	
}


class BadBoy{
	public void get(){
		System.out.println("得到赎金");
	}
	public void say(){
		System.out.println("你先给我赎金，我就放人质。");
	}
}

class MrMa{
	public void get(){
		System.out.println("得到人质");
	}
	public void say(){
		System.out.println("你先给我人质，我就给你赎金。");
	}
}