老师 我想请问一下 就是只剩最后一张票的时候，我能明白ABC三个窗口都确认有一张票的情况，我想问的是，为什么会跳过ticket--这个步骤，if判定成功了以后，不会立刻执行输出吗 ，难道是因为ABC三个窗口都是同线程的原因所以会抢占位置？抢占完然后按之前判定的顺序依次输出？虽然视频演示在剩五张票的时候没有出现这种情况，但剩五张票的时候 这种情况是存在的吗

老师好，这里的this对象为什么不是threadlocalmap而是threadlocal。

老师好，这里的时间为什么不能当前时间而是1970年的时间。

老师好：

       我的这个最终版服务器运行后出现这些，视频中老师的运行后什么也没有，麻烦老师帮我一下

package com.bjxst;

class Ticket_1 implements Runnable{
	private static int ticket=100;
	@Override
	public void run() {
		while (ticket>0){
                    sale();
        }    
			
		
		
	}
	public synchronized void sale(){       
        if (ticket>0){
            System.out.println(Thread.currentThread().getName() + "在卖第" + (ticket--) + "张票");
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
	
	
}


public class TestTicket_2 {
		public static  void main(String[] args){
			Ticket_1  t1=new Ticket_1();
			Ticket_1 t2=new Ticket_1();
			Thread d1=new Thread(t1,"东站");
			Thread d2=new Thread(t2,"南站");
			
			d1.start();
			d2.start();
			
			
			
			
			
			
		}
	
	

}

老师 运行 结果不对 ，请问 是代码问题，还是那里出

东站在卖第100张票
南站在卖第100张票
南站在卖第99张票
东站在卖第98张票
东站在卖第97张票
南站在卖第96张票
南站在卖第95张票
东站在卖第94张票
南站在卖第93张票
东站在卖第92张票
东站在卖第91张票
南站在卖第90张票
东站在卖第89张票
南站在卖第88张票

package com.gakki.thread;

public class TestSynchronized implements Runnable{
  //声明票的数量
  private int ticket = 100;

  @Override
  public void run() {
    for (int i = 0; i < 100; i++) {
      this.saleTicket();
    }
  }
  private synchronized void saleTicket() {
    if (ticket > 0) {
      try {
        Thread.sleep(2000);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      System.out.println(Thread.currentThread().getName() + "正在卖第" + (ticket--) + "张票");
    }
  }
}

package com.gakki.thread;

public class TestTicket {
  public static void main(String[] args) {
//    Ticket ticket = new Ticket();
    TestSynchronized ticket = new TestSynchronized();
    Thread thread1 = new Thread(ticket, "窗口A");
    Thread thread2 = new Thread(ticket, "窗口B");
    Thread thread3 = new Thread(ticket, "窗口C");

    thread1.start();
    thread2.start();
    thread3.start();
  }
}

问题：我票的数量改了，等待时间也挺长的 依旧是只有A窗口在卖票。 我设置过300的票，它会走完A 的100个人 才到下一个  这是为什么呀？

老师好：

         最后一步服务器没有反应，前面都正常，这个地方试了好久还是不行

老师，文件字节和字符输出流，都是当缓存区满了之后，才会自动调用flush()进行刷新

我测试了一下字符和字节不关闭，IO流是否能将数据写入文件中

字节不关闭IO流可以，字符不行，必须关闭IO或使用flush(）刷新一下

public class Example{
    public static void main(String[] args) throws IOException{
        FileWriter fil = new FileWriter("D:/a.txt");
        char[] arry = new char[] {'s','s'};
        fil.write(arry);
//        fil.close();
    }
}

public class TestFileOutputStream {
    public static void main(String[] args) throws IOException {
        //搭建通道（程序与目的地）
        FileOutputStream fil = new FileOutputStream("D:/keobei2.txt");
        //write()     一次写入一个字节
        //write(byte[] buf)    //将数组中所有内存写入缓存区中
        //write(byte[] buf,int off,int len)    //指定一次写入多少个字节
        //write(String str) //直接写入字符串
        //flush() 强制刷新缓存区
        //close() 关闭IO流
        //注意：写入的数据不是直接写入文件当中，而是写入缓存区当中
        //当缓冲满了后自动调用flush()方法，刷新缓存区，将缓存区的
        //内容存到文件当中
        
        //一次写入一个字节，以数字形式写入
        //fil.write(97);
        //一次写入一个字符串
        //但是他不能直接字符串，需要转换一次
        //fil.write(String.valueOf("你好呀").getBytes());
        //一次输入多个字节
        byte[] arry = "你好我是你的老师1".getBytes();
//        byte[] arry02 = new byte[] {02,52,35,15,124};
        fil.write(arry);
        //关闭IO流
//        if (fil != null) {
//            fil.close();
//        }
    }

老师好，为什么我这样写线程并没有发生死锁。

package com.casco;

import java.util.TreeMap;

public class DeadLock extends Thread {

    private Object money;
    private Object water;
    public boolean flag;

    public DeadLock(Object money, Object water) {
        this.money = money;
        this.water = water;
    }

    @Override
    public void run() {
        if(flag){
            synchronized (money){
                System.out.println("有钱，买水");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            synchronized (water){
                System.out.println("有水，等钱");
            }
        } else {
            synchronized (water){
                System.out.println("有水，等钱");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (money){
                    System.out.println("有钱，买水");
                }
            }

        }
    }
}

package com.casco;

public class Test {
    public static void main(String[] args) {
        Object money = new Object();
        Object water = new Object();
        DeadLock d1 = new DeadLock(money,water);
        DeadLock d2 = new DeadLock(money,water);
        d1.flag = true;
        d2.flag = false;
        d1.start();
        d2.start();
    }
}

老师好：

          打开index.html为什么乱码了，如下图，是要设置什么吗

这个第二阶段的资料怎么没有呢？我看光源代码。希望老师给传一下！

老师您好！

请问：在代码

int read（byte b[],int off,int len）;

运行原理是否时字节读取位置是从索引为off的位置开始到len位置的字节结束。还是说off只能设置为-1或者0

老师，视频中提出了时间片的概念：当线程中其中一个线程内容运行时其他线程需要等待该线程运行完之后，在继续执行。

            但是是一个视频好像说的是在进程里面线程是可以同时运行的，这是否会与时间片的概念有冲突？

老师，get请求方式可能含有参数，也就是说请求中第一行可能有参数，如果没有参数，那paraString是空，还是和post方式一样在正文中？

1.老师好，String类是不可变字符序列，代码第二行对对象str1进行了重新赋值（str1值改变了），代码第三行对字符串进行了截取（str1值又改变了）。String类是不可变字符序列，指的是String类无法修改数组引用地址的常量值，但是可以改变数组的引用（代码第二行，生成新的常量“hello”，不覆盖原来的常量“he”）达到对值的改变，我的理解对吗，麻烦老师再讲解一下，这里不太懂？

2.代码第五六行，在内存空间里，执行完第六行，1是会被2覆盖掉吗？

String str1 = new String("he");
str1 = "hello";
str1 = str1.substring(0,1);
int a = 1;
a = 2;