package com.cwt.study.java中级.s_20240803;


public interface Stack {
    //接口
    //先进后出
    //推入到最后的位置
    public void push(char obj);
    //把最后一个取出来
    public Character  pull();
    public int size();
}


package com.cwt.study.java中级.s_20240803;

import java.util.LinkedList;
import java.util.List;

//继承接口
public class MyStack implements Stack {
    List<Character> list = new LinkedList<>();

    @Override
    public synchronized int size() {
        return list.size();
    }

    @Override
    public synchronized void push(char obj) {
        try {
            if (list.size() >= 200) {
                this.wait();
            } else {
                list.add(obj);
                this.notify();
            }
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public synchronized Character pull() {
        Character c = null;
        try {
            if (list.size() <= 0) {
                this.wait();
            } else {
                this.notify();
                c = list.remove(list.size() - 1);
            }
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        return c;
    }

}


package com.cwt.study.java中级.s_20240803;

import java.util.List;

public class Producer extends Thread {
    //生产者
    //接口类
    final MyStack myStack;
    //测试类中的方法

    public Producer(MyStack myStack) {
        this.myStack = myStack;
    }

    public void run() {
        try {
            while (true) {
                //判断集合中是否为200,若为200则是该线程等待
                Thread.sleep(1000);
                synchronized (myStack) {
                    List<Character> list = myStack.list;

                    if (list.size() >= 200) {
                        System.out.println(this.getName() + " 正在等待消费者消费");
                    } else {
                        char har = getChar();
                        myStack.push(har);
                        System.out.println(this.getName() + " 压入：" + har + ", 当前集合长度：" + list.size());
                    }
                }
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    //随机类
    public char getChar() {
        char a = (char) (Math.random() * ('Z' - 'A' + 1) + 'A');
        return a;
    }


}


package com.cwt.study.java中级.s_20240803;

import java.util.List;

public class Consumer extends Thread {
    //消费者
    //调用MyStack继承接口
    final MyStack myStack;

    public Consumer(MyStack myStack) {
        this.myStack = myStack;
    }

    public void run() {
        try {
            while (true) {
                //判断集合中是否为0,若为0则是该线程等待
                Thread.sleep(1000);
                synchronized (myStack) {
                    List<Character> list = myStack.list;

                    if (!list.isEmpty()) {
                        Character a = myStack.pull();
                        System.out.println(this.getName() + " 弹出：" + a + ", 当前集合长度为：" + list.size());
                    } else {
                        System.out.println(this.getName() + " 正在等待生产者生产");
                    }
                }
            }
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}


package com.cwt.study.java中级.s_20240803;

public class TestThread {

    public static void main(String[] args) {
        MyStack myStack = new MyStack();
        Producer producer1 = new Producer(myStack);
        Producer producer2 = new Producer(myStack);
        Consumer consumer1 = new Consumer(myStack);
        Consumer consumer2 = new Consumer(myStack);
        Consumer consumer3 = new Consumer(myStack);
        producer1.setName("producer1");
        producer2.setName("producer2");
        consumer1.setName("consumer1");
        consumer2.setName("consumer2");
        consumer3.setName("consumer3");
        producer1.start();
        producer2.start();
        consumer1.start();
        consumer2.start();
        consumer3.start();
    }
}

package com.cwt.study.java中级.s_20240731;

public class Hero5 {
    public String name;
    public float hp;
    public int damage;
    //回血
    public synchronized void recover(){
        if (hp>=1000) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        hp =hp+1;
        System.out.printf("%s 回血1点,增加血后，%s的血量是%.0f%n", name, name, hp);
        this.notifyAll();
    }
    //减血
    public synchronized void hurt(){
        while (hp <=1) {
            try {
                // 让占有this的减血线程，暂时释放对this的占有，并等待
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        hp =hp-1;
        System.out.printf("%s 减血1点,减少血后，%s的血量是%.0f%n", name, name, hp);
        this.notifyAll();
    }

    public void attackHero(Hero5 h){
        h.hp-=damage;
        System.out.println(name+"正在攻击"+h.name+","+h.name+"的血变成了"+h.hp);
        if (h.isDead()) {
            System.out.println(h.name+"死了！");
        }
    }
    public boolean isDead(){
        return 0>=hp?true:false;
    }
}


package com.cwt.study.java中级.s_20240731;

public class testThread5 {
    /*在上面的练习的基础上，增加回血线程到2条，减血线程到5条，同时运行。
      运行一段时间，观察会发生的错误，分析错误原因，并考虑解决办法*/
    public static void main(String[] args) {
        final Hero5 gareen = new Hero5();
        gareen.name = "盖伦";
        gareen.hp = 616;
        for (int i = 0; i < 5; i++) {
            Thread t1 = new Thread(){
                public void run() {
                    while (true){

                        gareen.hurt();
                        System.out.printf("t1 为%s 减血1点,减少血后，%s的血量是%.0f%n",gareen.name,gareen.name,gareen.hp);
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            };
            t1.start();
        }


for (int i = 0; i < 2; i++) {
    Thread t2 = new Thread(){
        public void run(){
            while(true){
                gareen.recover();
                System.out.printf("t2 为%s 回血1点,增加血后，%s的血量是%.0f%n",gareen.name,gareen.name,gareen.hp);

                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    };
    t2.start();
}

    }
}

package com.cwt.study.java中级.s_20240731;

public class Hero4 {
    public String name;
    public float hp;
    public int damage;
    //回血
    public synchronized void recover(){
        if (hp>=1000) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        hp =hp+1;
        System.out.printf("%s 回血1点,增加血后，%s的血量是%.0f%n", name, name, hp);
    }
    //减血
    public synchronized void hurt(){
        if (hp ==1) {
            try {
                // 让占有this的减血线程，暂时释放对this的占有，并等待
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        hp =hp-1;
        System.out.printf("%s 减血1点,减少血后，%s的血量是%.0f%n", name, name, hp);
        this.notifyAll();
    }

    public void attackHero(Hero4 h){
        h.hp-=damage;
        System.out.println(name+"正在攻击"+h.name+","+h.name+"的血变成了"+h.hp);
        if (h.isDead()) {
            System.out.println(h.name+"死了！");
        }
    }
    public boolean isDead(){
        return 0>=hp?true:false;
    }
}


package com.cwt.study.java中级.s_20240731;

public class testThread4 {
    public static void main(String[] args) {
        final Hero4 gareen = new Hero4();
        gareen.name = "盖伦";
        gareen.hp = 616;
        Thread t1 = new Thread(){
            public void run() {
                while (true){

                    gareen.hurt();
                    System.out.printf("t1 为%s 减血1点,减少血后，%s的血量是%.0f%n",gareen.name,gareen.name,gareen.hp);
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t1.start();

        Thread t2 = new Thread(){
            public void run(){
                while(true){
                    gareen.recover();
                    System.out.printf("t2 为%s 回血1点,增加血后，%s的血量是%.0f%n",gareen.name,gareen.name,gareen.hp);

                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

            }
        };
        t2.start();
    }
}

//————消费者线程类————//

package testThread;

import j2se.MyStack;

public class ConsumerThread extends Thread {
	private MyStack<Character> stack;

	public ConsumerThread(String name, MyStack<Character> stack) {
		super(name);
		this.stack = stack;
	}

	@Override
	public void run() {
		while (true) {
			if(stack.peek()!=null)
			{
				char c = stack.pull();
				System.out.println(this.getName() + " 弹出 ：" + c);
			}
		}
	}
}

//————生产者线程类————//

package testThread;

import j2se.MyStack;

public class ProducerThread extends Thread {
	private MyStack<Character> stack;

	public ProducerThread(String name, MyStack<Character> stack) {
		super(name);
		this.stack = stack;
	}

	@Override
	public void run() {
		while(true)
		{
			char c;
			stack.push(c = TestThread.getRandChar());
			System.out.println(this.getName()+" 压入 ："+c);
		}

	}

}

//————Mystack类————//

package j2se;

import java.util.LinkedList;

public class MyStack<E> implements Stack<E> {

	private LinkedList<E> value;

	public MyStack() {
		value = new LinkedList<>();
	}

	@Override
	public synchronized void push(E element) {
		while (size() >= 200)
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		value.add(element);
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		this.notify();

	}

	@Override
	public synchronized E pull() {
		try {
			while (value.isEmpty()) {
				this.wait();
			}
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		this.notify();
		return value.pollLast();

	}

	@Override
	public E peek() {
		if (!value.isEmpty())
			return value.peekLast();
		else
			return null;
	}

	public int size() {
		return value.size();
	}

	@Override
	public synchronized String toString() {
		if (value.isEmpty())
			return null;
		String res = "size:" + size();
		try {
			res = "size:" + size() + " " + value.toString();
		} catch (Throwable e) {
			// e.printStackTrace();
			return "size:" + size() + " Error";
			// TODO: handle exception
		}
		return res;
	}

	public void print() {
		System.out.println(this);
	}

}

//————主方法调用————//

public static void main(String[] args) {
		final MyStack<Character> stack = new MyStack<>();
		for (int i = 1; i <= 2; i++) {
			ProducerThread t = new ProducerThread("Producer"+i, stack);
			t.start();
		}
		
		for (int i = 1; i <= 3; i++) {
			ConsumerThread t = new ConsumerThread("\tConsumer"+i, stack);
			t.start();
		}
	}

public class Hero {
    public String name;
    public float hp;

    public int damage;

    public synchronized void recover() {
        if (hp >= 1000) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }

        hp = hp + 1;
        System.out.printf("%s 回血1点,增加血后，%s的血量是%.0f%n", name, name, hp);

        // 通知那些等待在this对象上的线程，可以醒过来了，如第20行，等待着的减血线程，苏醒过来
        this.notifyAll();
    }

    public synchronized void hurt() {
        if (hp <= 1) {    // TODO：改成 while
            try {
                // 让占有this的减血线程，暂时释放对this的占有，并等待
                this.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        hp = hp - 1;
        System.out.printf("%s 减血1点,减少血后，%s的血量是%.0f%n", name, name, hp);

        this.notifyAll();
    }

    public void attackHero(Hero h) {
        h.hp -= damage;
        System.out.format("%s 正在攻击 %s, %s的血变成了 %.0f%n", name, h.name, h.name, h.hp);
        if (h.isDead())
            System.out.println(h.name + "死了！");
    }

    public boolean isDead() {
        return 0 >= hp;
    }

}