package com.Thread;

/**
 *测试缓冲区的作用
 */
public class TestBufferThread {
    public static void main(String[] args) {
      SyncStack ss=new SyncStack();
      new XiaoFei(ss).start();
        new Product(ss).start();
    }
}
/***
 * 设置一个馒头类
 */
class Mantou{
    private int id;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}
/***
 * 设置缓冲区
 */
class SyncStack{
    //定义存放那个馒头的盒子
    private Mantou[] mt=new Mantou[10];
    //操作馒头的索引
    private int index;

    /**
     * 放馒头
     */
    public synchronized void push(Mantou mantou){
        //判断盒子是否满
        while (this.index==this.mt.length){
            try {
                /**
                 * 语法：wait(),该方法必须要在synchronized块中调用。
                 * wait执行后，线程会将持有的对象锁释放，并进入阻塞状态，
                 * 其他需要该对象锁的线程就可以继续运行了。
                 */
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //唤醒取馒头的线程
            /**
             * 语法：该方法必须要在synchronized块中调用。
             * 该方法会唤醒处于等待状态队列中的一个线程。
             */
            this.notify();
            this.mt[this.index]=mantou;
            this.index++;
        }
    }
    /**
     * 取馒头
     */
    public synchronized Mantou pop(){
        while(this.index == 0){
            try {
                /**
                 * 语法：wait(),该方法必须要在synchronized块中调用。
                 * wait执行后，线程会将持有的对象锁释放，并进入阻塞状态，
                 * 其他需要该对象锁的线程就可以继续运行了。
                 */
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.notify();
        this.index--;
        return this.mt[this.index];
    }

}
   /**
 * 定义生产者线程
 */
class  Product extends Thread{
       //传入缓冲区
       private SyncStack ss;
       public Product(SyncStack ss){
           this.ss=ss;
       }
       @Override
       public void run() {
           for (int i = 0; i <10 ; i++) {
               Mantou mt=new Mantou();
               mt.setId(i);
               System.out.println("生产馒头"+mt.getId());
               this.ss.push(mt);
           }
       }
   }
/**
 * 定义消费者线程
 */
class XiaoFei extends Thread{
    private SyncStack ss;
    public XiaoFei(SyncStack ss){
        this.ss = ss;
    }
    @Override
    public void run() {
        for(int i=0;i<10;i++){
            Mantou mt = this.ss.pop();
            System.out.println("消费馒头："+mt.getId());
        }
    }
}

老师，帮我看看，只启动生产者线程，消费者线程没反应?

对于同一个对象的多种操作，存在逻辑上的先后顺序，就应该采用线程同步锁吗？

可以这么理解吗？

对于同一个对象，存在逻辑上的先后顺序，就应该采用线程同步锁吗？

可以这么理解吗？

老师为什么stream要放在collectors中

老师这个ele是什么意思，为什么可以直接用ele.调用startWith这些方法

老师从这些代码怎么看出反射机制，反射表现在哪些方面

老师完全看不懂，该怎么学习理解呢？

GregorianCalendar calendar4 = new GregorianCalendar();
calendar4.setTime(new Date());
怎么理解这两行

import java.io.*;

public class TestLineNumber2 {
    public static void main(String[] args) {
        try(BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("d:/liuxuan1.txt")))){
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("d:/liuxuan4.txt")));
            String temp = "";
            int i = 1;
            while ((temp = br.readLine()) != null){
                bw.write(i+","+temp);
                bw.newLine();
                i++;

            }
        }catch (IOException e){
            e.printStackTrace();

        }
    }
}

代码实现了文本的创建，但是文本里没后数据

import java.io.ByteArrayInputStream;

import java.io.ObjectInputStream;

import java.net.DatagramPacket;

import java.net.DatagramSocket;

//利用UDP发送自定义对象<服务端>

public class UDP_SendPersonObjectTypeServer {

public static void main(String[] args) {

try(DatagramSocket dgs=new DatagramSocket(9999)){

byte[] bb=new byte[1024];

DatagramPacket dgp=new DatagramPacket(bb, bb.length);

//接收数据

dgs.receive(dgp);

//类型转换

try(ObjectInputStream ois =new ObjectInputStream(new ByteArrayInputStream(dgp.getData()))){

Person p=(Person) ois.readObject();

System.out.println(p);

} catch (Exception e) {

e.printStackTrace();

// TODO: handle exception

}

}catch (Exception e) {

e.printStackTrace();

// TODO: handle exception

}

}

}

import java.io.ByteArrayOutputStream;

import java.io.ObjectOutputStream;

import java.net.DatagramPacket;

import java.net.DatagramSocket;

import java.net.InetSocketAddress;

public class UDP_SendPersonObjectTypeClient {

public static void main(String[] args) {

try(DatagramSocket dgst=new DatagramSocket(8888);

ByteArrayOutputStream bos=new ByteArrayOutputStream();

ObjectOutputStream oos=new ObjectOutputStream(bos)){

//创建自定义对象

Person p=new Person();

p.setName("张三");

p.setAge(28);

//写出对象

oos.writeObject(p);

byte[] by= bos.toByteArray();

//将数据包装成datagrampacket对象

DatagramPacket dap=new DatagramPacket(by,by.length,new InetSocketAddress("127.0.0.1",9999));

//发送数据

dgst.send(dap);

} catch (Exception e) {

e.printStackTrace();

// TODO: handle exception

}

}

}

老师，请问我这里运行后服务端只收到了这个，是为什么

老师这里为什么要用到ObjectInputStream

Scanner对象不用使用try-with-resource关闭吗

老师，快捷进入源码是什么快捷键来着？

import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class test1 {
    public static void main(String[] args) {
        try {
            FileInputStream fis = new FileInputStream("d:/a.txt");
            int s1 = fis.read();
            int s2 = fis.read();
            int s3 = fis.read();
            int s4 = fis.read();
            int s5 = fis.read();
            System.out.println(s1);
            System.out.println(s2);
            System.out.println(s3);
            System.out.println(s4);
            System.out.println(s5);

            //流对象使用完，必须关闭，不然，总占用系统资源，最终系统会崩溃。
            fis.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

97

98

99

13

10

为啥最后没有数据读入时返回的值不是-1呢，一个13，一个10

import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class test1 {
    public static void main(String[] args) {
        try {
            FileInputStream fis = new FileInputStream("d:/a.txt");
            int s1 = fis.read();
            int s2 = fis.read();
            int s3 = fis.read();
            int s4 = fis.read();
            int s5 = fis.read();
            System.out.println(s1);
            System.out.println(s2);
            System.out.println(s3);
            System.out.println(s4);
            System.out.println(s5);

            //流对象使用完，必须关闭，不然，总占用系统资源，最终系统会崩溃。
            fis.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

97

98

99

13

10

为啥没有数据时返回的数值不是-1呢，一个13，一个10