线程同步

线程同步：多个线程操作同一个资源
锁机制：synchronized
线程同步-锁机制存在的问题：

1. 一个线程有锁会导致其他所i有需要此锁的线程挂起
2. 再多个线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度时延，引起性能问题
3. 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题

不安全状态

//不安全的买票
//线程不安全。票数有负数
//每个线程会在自己的工作内存交互，内存控制不当会造成数据不一致


public class UnsafeBuyTicket {
	public static void main(String[] args) {
		BuyTicket bt=new BuyTicket();
		new Thread(bt,"庆安县的陌生人").start();
		new Thread(bt,"西安的你").start();
		new Thread(bt,"咸阳的我").start();
	}

}
class BuyTicket implements Runnable{
	//票
	private int ticketNums=10;
	boolean flag=true;//外部停止方式
	@Override
	public void run() {
		// TODO Auto-generated method stub
		
		
		//买票
		while(flag) {
			try {
				buy();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
	}
	
	private void buy() throws InterruptedException {
		//判断是否有票
		if(ticketNums<=0) {
			flag=false;
			return;
			
		}
		
		//模拟延时
		Thread.sleep(1000);
		
		
		System.out.println(Thread.currentThread().getName()+"买到了"+ticketNums--);
	}
	
}




 

//不安全的取钱
//两个人去银行取钱，账户
public class UnsafeBank {
	public static void main(String[] args) {
		Account account=new Account(100,"结婚基金");//账户
		Drawing you=new Drawing(account, 50, "你");
		Drawing wife=new Drawing(account, 100, "你的妻子");
		you.start();
		wife.start();
		
		
		
	}
}

class Account{
	
	int money;//余额
	String name;//卡名
	
	public Account(int money, String name) {
		// TODO Auto-generated constructor stub
	}
	
}



//银行：模拟取款
class Drawing extends Thread{
	Account account;//账户
	int drawingMoney;//去多少钱
	int nowMoney;//现在手里有多少钱
	public Drawing(Account account,int drawingMoney,String name){
		super(name);
		this.account=account;
		this.nowMoney=nowMoney;
		this.drawingMoney=drawingMoney;
		
		
	}
	
	//取钱
	public void run() {
		// 判断账户有没有钱
		if(account.money-drawingMoney<0) {
			System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
			return;
		}
		
		//模拟延时
		//sleep可以放大问题的发生性
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		//卡内余额=余额-取出的钱
		account.money=account.money-drawingMoney;
		//手里的钱=手里的钱+取出的钱
		nowMoney=nowMoney+drawingMoney;
		
		System.out.println(account.name+"余额为："+account.money);
		System.out.println(this.getName()+"手里的钱为："+nowMoney);
		
		
	}
}

//线程不安全的集合
public class UnsafeList {
	public static void main(String[] args) {
	List<String> list=new ArrayList<String>();
	for(int i=0;i<100;i++) {
		new Thread(()->	{
			list.add(Thread.currentThread().getName());
		}).start() ;
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		System.out.println(list.size());
		
	}
		
		
	}
}

安全状态的完成：同步方法
我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需针对方法提供一套机制，这套机制就是synchronized关键字，他包括两种用法：
synchronized方法和synchronized快：

//同步方法：public sychronized void method(int args){
//}

synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获取调用方法的对象的锁才能执行，否则线程会阻塞，方法一旦进行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行

//缺陷：若将一个大的方法申请为synchronized将会影响效率
//方法里面需要修改的资源才需要加锁，锁太多，浪费资源

//同步块：synchronized（Obj）{}