//案例：买票系统，5个窗口共卖1000张票；观察卖票过程：
//例如： 窗口1正则卖第1000张票;
//      窗口5正则卖第999张票;
//      窗口3正则卖第998张票;
//      ...
//      窗口3正则卖第1张票;
//分析：创建5个窗口-5个线程    票数-共享数据（安全隐患）
//方式1：实现Runnable方式
//问题1：出现部分重票问题
//原因：共享数据有篡改数据--有隐患；
//解决方案：加锁  锁住共享数据操作;  需要考虑锁的范围
//问题2：出现负数
//原因：临界点判断出现了问题
//处理方案: 在锁里继续判断；大于0才买票

//优化升级：买完票应该要有退出的提示，且提示应该是完整的
//使用while(true)循环，表示只有一个出口退出即可

//锁的分类：同步代码块   同步方法
class Task implements Runnable{
	private int ticket = 1000;  //1000张票-共享数据 
	@Override
	public void run() {
		while(true) {
			/*  
			//同步代码块方式
			synchronized (this) { //"lock"  静态对象
				if(ticket>0) {
					//Thread.currentThread().getName():实现任务获取的线程名
					System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
					ticket--;
				}else {
					System.out.println(Thread.currentThread().getName()+"已经卖完了");
					break;
				}
			}*/
			
			if(save()) {  //同步方法调用
				break;
			}
		}
	}
	//同步方法： 如何确保同一个锁对象？谁调的方法就是哪个对象--this(同一个锁对象)
	private synchronized boolean save() {  
		if(ticket>0) {
			//Thread.currentThread().getName():实现任务获取的线程名
			System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
			ticket--;
			return false; //返回false表示还可继续循环卖票
		}else {
			System.out.println(Thread.currentThread().getName()+"已经卖完了");
			return true;  //结束卖票
		}
	}
}
public class Test1 {
	public static void main(String[] args) {
		Task task = new Task();
		for(int i=1;i<=5;i++) {
			new Thread(task,"窗口"+i).start();
		}
	}
}

//案例：买票系统，5个窗口共卖1000张票；观察卖票过程：
//方式2：继承Thread方式
//问题1：每new线程对象，都有一份独立的属性--卖了5000张
//处理方案：将属性变为共享数据   属性+static--静态属性值维护一份
//问题2：会出现部分重票问题----原因是this不是同一个锁对象
//解决方案：锁对象变为字符串常量
class MyThread extends Thread{
	private static int ticket = 1000;  //1000张票-共享数据 
	
	public  MyThread(String name) {
		super(name);
	}
	@Override
	public void run() {
		while(true) { 
			//同步代码块方式
			synchronized ("lock") { 
				if(ticket>0) {
					System.out.println(getName()+"正在卖第"+ticket+"张票");
					ticket--;
				}else {
					System.out.println(getName()+"已经卖完了");
					break;
				}
			}
		}
	}
}
public class Test2 {
	public static void main(String[] args) {
		for(int i=1;i<=5;i++) {
			new MyThread("窗口00"+i).start();
		}
	}
}

//死锁案例：两个线程，各自执行自身的代码
class MyThread extends Thread{
	private boolean a;  //标记判断
	public MyThread(boolean a) {
		this.a = a;
	}
	@Override
	public void run() {
		if(a) {
			synchronized ("A") { //线程1
				System.out.println("进入线程1的A锁");
				synchronized ("B") {
					System.out.println("进入线程1的B锁");
				}
			}
		}else {
			synchronized ("B") { //线程2
				System.out.println("进入线程2的B锁");
				synchronized ("A") {
					System.out.println("进入线程2的A锁");
				}
			}
		}
	}
}
public class Test1 {
	public static void main(String[] args) {
		new MyThread(true).start();  //线程1
		
		new MyThread(false).start(); //线程2
	}
}

//案例：生产者消费者线程案例，生产者一直负责生产，消费者一直负责消费
//分析：生产者线程和消费者线程都操作同一个库存(共享数据)
//问题：
//1.会出现还没有等到生产，就已经消费了的情况  
//2.数据混乱:生产者线程数量+1后，直接打印出了消费数据

//处理方案：
//数据混乱--需要加锁来解决
//没有生产提前消费的问题：线程等待的功能，判断件数为0，一直等待，无限期等待，直到发指令
//wait()--等待；  notify--唤醒（唤醒等待）

public class Test1 {
	public static void main(String[] args) {
		Store store = new Store();
		//生产者和消费者都操作同一个库存
		new Producter(store).start();
		
		new Customer(store).start();
	}
}

public class Producter extends Thread { //生产者线程
	private Store store;
	public Producter(Store store) { //从外面传入库存对象
		this.store = store;
	}
	@Override
	public void run() {
		while(true) {//循环生产
			try {
				store.push();    //生产者负责入库
			} catch (Exception e) {
				e.printStackTrace();
			} 
		}
	}
}

public class Customer extends Thread {  //消费者线程
	private Store store;  //消费者操作库存
	public Customer(Store store) {
		this.store = store;
	}
	@Override
	public void run() {
		while(true) { //循环消费
			try {
				store.pop();    //消费者出库
			} catch (InterruptedException e) {
				e.printStackTrace();
			}  
		}
	}
}

//仓满和仓空由库存决定--在库存中判断
public class Store {
	private int count; //库存数量的标记--共享数据，库存对象只有一个，那么成员也只有一个
	public void push() throws InterruptedException {//负责生产的功能
		synchronized (this) { //this可以表示同一个锁对象
			if(count>=20) {  //仓满则停止生产
				this.wait();  //等待；释放锁资源
			}
			count++;
			System.out.println("已经生产了第"+count+"件货");
			
			this.notify(); //唤醒，唤醒等待的线程(唤醒对方)
		}
	}
	public void pop() throws InterruptedException { //负责消费的功能
		synchronized (this) {
			if(count<=0) {//仓空停止消费
				this.wait();   //等待；释放锁资源
			}
			System.out.println("已经消费了第"+count+"件货");
			count--;
			
			this.notify(); //唤醒，唤醒生产者
		}
	}
}

//线程池:
class Task implements Runnable{
	@Override
	public void run() {
		for(int i=1;i<=10;i++) {
			System.out.println(Thread.currentThread().getName()+"-->"+i);
		}
	}
}
public class Test1 {
	public static void main(String[] args) {
		//在线程池中创建单个线程对象，通过单个线程对象去处理多个任务
		//ExecutorService es = Executors.newSingleThreadExecutor();
		//带缓冲区的线程池：有多少个任务，则会产生多少个线程对象的处理
		//ExecutorService es = Executors.newCachedThreadPool();
		//带复用机制的线程池：指定线程池个数，进行复用
		ExecutorService es = Executors.newFixedThreadPool(2);//（常用）
		es.submit(new Task()); //任务接口Runnable
		es.submit(new Task());
		es.submit(new Task());  //有三个任务，则谁先执行完，再执行第3个--复用
		
		es.shutdown();  //线程池的终止
	}
}

//需求：使用两个线程并发的执行1~50，51~100的和；并汇总结果
//线程池中有Callable接口，可以带返回结果
public class Test2 {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		ExecutorService es = Executors.newFixedThreadPool(2);
		Future<Integer> fu1 = es.submit(new Callable<Integer>() {
			@Override
			public Integer call() throws Exception { //线程1
				int sum = 0;
				for(int i=1;i<=50;i++) {
					sum += i;
				}
				return sum;
			}
		});
		Future<Integer> fu2 = es.submit(new Callable<Integer>() {
			@Override
			public Integer call() throws Exception { //线程2
				int sum = 0;
				for(int i=51;i<=100;i++) {
					sum += i;
				}
				return sum;
			}
		});
		int sum = fu1.get()+fu2.get();  //get是阻塞方法--和join类似
		System.out.println("和为："+sum);
		es.shutdown();
	}
}