package com.bjsxt.ls.DuoXianCheng.线程并发;
/*
线程并发：生产者和消费者模型
定义一个做馒头和取馒头的类，中间有一个缓冲区。做好的馒头放入缓冲区，取馒头从缓冲区取。
假设缓冲区容量是10，那么当做了十个馒头的时候，做馒头线程就要停止(阻塞)。当缓冲区没有馒头的时候，取馒头线程就要停止(阻塞)。
但是当做馒头线程放入馒头的时候，就要用notify提醒取馒头线程，不要一直处于阻塞状态；
同样当取馒头线程拿馒头的时候，也要提醒做馒头线程要做馒头，不要一直处于阻塞状态；
*/

//定义馒头类
class ManTou{
    private int id;
    public ManTou(int id) {
        this.id = id;
    }
    public int getId() {
        return id;
    }
}

//定义缓冲区,用数组来存放馒头
class resitor{
    
    private ManTou[] arr =new ManTou[10]; //创建一个长度为10，类型为ManTou的数组
    private int index; //定义索引

    //定义做馒头方法
    //因为做馒头和取馒头都是对同样对象进行操作，所以这两个状态是要互斥，即同步的。所以要用synchronized使得这两个状态处于同步状态
    //synchronzied放在方法名上相当于将synchronized(this){}将方法体包裹起来。
    public synchronized void makeMantou(ManTou manTou){
        //用while做出判断，如果当数组满的时候，就要用wait方法，使得此线程进入阻塞状态，不再生产馒头了；
        while (this.index == this.arr.length){
            try {
                wait();    /*wait属于Object类只能用在synchronized块中。
                           此方法执行之后，在本方法所在的对象锁会被阻塞， 其他需要该对象锁的线程就可以继续运行了。*/
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }              //notify也属于Object类
        this.notify();//当放入馒头的时候，要用notify唤醒取馒头的线程，以防拿馒头线程处于阻塞状态 。
                     //该方法会唤醒处于等待状态队列中的一个线程
        this.arr[this.index]=manTou;
        index++;
    }

    //定义取馒头方法
    public synchronized ManTou takeMantou(){
        //用while判断，当索引为0，即缓冲区没有馒头的时候，就用wait阻塞此状态，不要再去取馒头了；
        while (this.index==0){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.notify();//拿馒头的时候也要唤醒做馒头的线程，以防处于阻塞状态不做馒头了。
        this.index--;
        return this.arr[this.index];
    }
}


//创建做馒头线程
class makeThread extends Thread{
    private resitor r; //定义一个类型是resitor的变量r
    public makeThread(resitor r){
        this.r = r;
    }

    @Override
    public void run() {
        for (int i=1;i<11;i++){
            System.out.println("生成第"+i+"个馒头");
            ManTou manTou =new ManTou(i);
            this.r.push(manTou);
        }
    }
}

//创建取馒头线程
class takeThread extends Thread{
    private resitor r; //定义一个类型是resitor的变量r
    public takeThread(resitor r){
        this.r = r;
    }

    @Override
    public void run() {
        for (int i=1;i<11;i++){
            ManTou manTou =this.r.pop();
            System.out.println("拿走第"+i+"个馒头");
        }
    }
}

public class ProducerThread {
    public static void main(String[] args) {
        resitor tt =new resitor();
        new makeThread(tt).start();
        new takeThread(tt).start();
    }
}

老师这是什么原因造成的？

老师，this 、字符串、Class、自定义这几个对象锁，分别都应该在什么情况下使用？ 

老师，用字符串作为对象缩的时候，是不是根据程序员类提供的构造方法的类型的。如果构造方法是一个整型或者其他类型，那么这个字符串索就没用了？

如果说我们拆到"[" 请问添加的字符串"]"是加到"["左边还是右边

老师我想问一下，Set不是单例集合么 为什么能存键值对呢

下面的6是什么意思，还有为什么i的值不是从0开始加的？

能不能这么理解，IO流操作出现后，main主线程进入阻塞状态，st.stop也运行不了，结束了IO流操作，main运行后子线程st就可以调用stop方法结束子线程st。

这一章节的文件拷贝实操总是报错，请老师看看，是需要我先创建文件吗？

package com.program;

import java.io.*;

public class CopyFileDirectory {
    public static void main(String[] args) {
        File src=new File("D:/a/java");

        File des=new File("E:/b");
       copyDir(src,des);



    }
    public static void copyDir(File SrcDir,File TargetDir) {
        if (TargetDir != null) {
            TargetDir.mkdir();//如果目的地的目录不存在，那么创建目录
        }
        File[] files = SrcDir.listFiles();
        for (File file : files) {
            if (file.isFile()) {
                copyFile(new File(SrcDir + "" + file.getName()), new File(TargetDir + "" + file.getName()));
            } else {
                copyDir(new File(SrcDir + "" + file.getName()), new File(TargetDir + "" + file.getName()));
            }
        }
    }

    public static void copyFile(File srcfile, File Desfile ){
        BufferedInputStream bis= null;
        BufferedOutputStream bos=null;
        try{
            bis=new BufferedInputStream(new FileInputStream(srcfile));
            bos=new BufferedOutputStream(new FileOutputStream(Desfile));
            byte[] by=new byte[1024];
            int temp=0;
            while((temp=bis.read(by))!=-1){
                bos.write(temp);
            }
            bos.flush();
        }catch(Exception e){
            e.printStackTrace();
        }finally {
            try{
                if (bos!=null){
                    bos.close();
                }
                if (bis!=null){
                    bis.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }

        }
    }
}

有些同学觉得老师讲的不好，我觉得没必要这样说，觉得老师讲的快的可以弄成0.5倍速或者更慢。而且老师讲的快的地方基本都是前面讲过的基础操作，我觉得老师讲的很不错

什么情况用字节流读取文本文件并添加行号更好？直接用字符缓冲流字符流不是更方便吗？

老师，为什么switch的case后面要跟着break？我试着不加break，也不报错，但是显示出来的东西有点奇怪

Set<String> set=new HashSet<>();中，为什么不是HashSet<String> set=new HashSet<>();

addLast和pop();啥意思，什么关系啊

老师，我这咋错了，还有索引的数值不能大于元素个数，元素个数不是有5个吗，3怎么就不能？

老师这节课中

synchronized (this)

和上一节课

synchronized (this.account)

对什么时候要加后面的.account 有点不理解