/*
1.增加一个知识点
一个类怎么在所有的类中，让其它类来共同修改它的数据呢？
可以用单例设计模式
可以用静态
可以在其它类中做一个构造函数，接受同一个对象，这样就可以实现对象
2.状态选择
可以用数字0 1 判断
可以用bool
注意变量的范围即可
3.加了同步后，还是有安全怎么办？
想前提！ 1. 两个及以上线程（同步的） 2.操作公用资源 3.要用同一锁
*/
/*
线程间通讯：
其实就是多个线程在操作同一个资源，
但是操作的动作不同。
*/
/*
1.为什么会出现安全问题？
就是不满足前提呗
2.我们还没有了解到线程的本质
1.线程的执行时互相争抢执行权的
2.如果没有同步代码块的话，就会对数据进行胡乱修改，有可能修改到一半，另一个线程进来，有可能修改好几次，等等，甚至还会无视条件
3.即便有了同步代码块，也不能保证代码是按次序相互执行，因为，第一个线程执行完之后，还会参与下一次的争抢当中来，拥有相同的争抢概率
所以就出现同步中的不同步状况，这时候就要用到唤醒
4.其实程序就是一个逻辑判断问题，就是看有没有数据
*/
/*五种状态之一的等待
1.是Thread从上帝那里继承来的
2.而且这个函数是抛了异常的，根据异常的格式，要try和catch
3.唤醒也是继承上帝的
4.使用的时候，直接用对象点出来就可以
5.这样很容易区分，也造成为什么要把这两个函数写在上帝里面的原因，锁是任意类型的，什么对象都可以
*/
class Res /*定义一个类，里面封装好数据成员，用来去调用*/
{
String name;
String sex;
boolean flag = false; /*用来判断是否已经存入数据，封装好用来调用*/
}
class Input implements Runnable
{
private Res r ;
Input(Res r)
{
this.r = r;
}
public void run()
{
int x = 0;
while(true)
{
synchronized(r) /*只能让一个线程进来，而且输入的先进来，输出的就不给进了，这样就满足了前提，有两个线程，同一锁，公共资源*/
{
if(r.flag) /*真，冻结*/
try{r.wait();}catch(Exception e){} /*线程池，等待线程都在线程池当中，唤醒的是什么，唤醒的都是线程池当中的线程*/
if(x==0)
{
r.name="mike"; /*赋值*/
r.sex="man";
}
else
{
r.name="丽丽";
r.sex = "女女女女女";
}
x = (x+1)%2; /*转换性别*/
r.flag = true;
r.notify(); /*有就唤醒，没有就不唤醒，按顺序来自然就不需要这个，唤醒的是另一个线程*/
}
}
}
}
class Output implements Runnable
{
private Res r ; /*对象数据成员*/
Output(Res r)
{
this.r = r; /*传递对象进来*/
}
public void run()
{
while(true)
{
synchronized(r) /*放的是对象*/
{
if(!r.flag)
try{r.wait();}catch(Exception e){}
System.out.println(r.name+"...."+r.sex); /*删除*/
r.flag = false;
r.notify(); /*唤醒输入线程*/
}
}
}
}
class InputOutputDemo
{
public static void main(String[] args)
{
Res r = new Res(); /*封装好的类，将会当作参数，传递给其它类*/
Input in = new Input(r); /*实现多线程类的对象*/
Output out = new Output(r);
Thread t1 = new Thread(in); /*开启线程，把实现线程的对象放进来*/
Thread t2 = new Thread(out);
t1.start(); /*开启线程，调用run函数*/
t2.start();
}
}
//notifyAll();
/*
wait:
notify();
notifyAll();
都使用在同步中，因为要对持有监视器(锁)的线程操作。
所以要使用在同步中，因为只有同步才具有锁。
为什么这些操作线程的方法要定义Object类中呢？
因为这些方法在操作同步中线程时，都必须要标识它们所操作线程只有的锁，
只有同一个锁上的被等待线程，可以被同一个锁上notify唤醒。
不可以对不同锁中的线程进行唤醒。
也就是说，等待和唤醒必须是同一个锁。
而锁可以是任意对象，所以可以被任意对象调用的方法定义Object类中。
*/
代码优化：
/*
线程间通讯：
其实就是多个线程在操作同一个资源，
但是操作的动作不同。
*/
class Res
{
private String name;
private String sex;
private boolean flag = false;
public synchronized void set(String name,String sex)
{
if(flag)
try{this.wait();}catch(Exception e){} /*记住，加同步的是共同操作的数据，不是定义数据，是会变动的数据*/
this.name = name;
this.sex = sex;
flag = true;
this.notify(); /*this代表同步函数的锁，也代表当前对象*/
}
public synchronized void out()
{
if(!flag)
try{this.wait();}catch(Exception e){}
System.out.println(name+"........"+sex);
flag = false;
this.notify();
}
}
class Input implements Runnable
{
private Res r ; /*用来接收同一个对象*/
Input(Res r)
{
this.r = r;
}
public void run()
{
int x = 0;
while(true)
{
if(x==0)
r.set("mike","man"); /*这个函数已经是同步函数了*/
else
r.set("丽丽","女女女女女");
x = (x+1)%2;
}
}
}
class Output implements Runnable
{
private Res r ;
Output(Res r)
{
this.r = r;
}
public void run()
{
while(true)
{
r.out(); /*不断输出*/
}
}
}
class InputOutputDemo2
{
public static void main(String[] args)
{
Res r = new Res();
new Thread(new Input(r)).start(); /*全部使用无名对象，优化代码*/
new Thread(new Output(r)).start();
/*
Input in = new Input(r);
Output out = new Output(r);
Thread t1 = new Thread(in);
Thread t2 = new Thread(out);
t1.start();
t2.start();
*/
}
}