JAVAday29

.IO流:  作用:  传输数据， 从数据源 到  数据汇的过程
    字节输入流: InputStream: 抽象类     
                   |-- FileInputStream 文件流
                   |-- ObjectInputStream 反序列化
                   |-- ByteArrayInputStream 字节数组流
    字节输出流: OutputStream:
                   |-- FileOutputStream 
                   |-- ObjectOutputStream
                   |-- ByteArrayOutputSteam 
       
2.字符输入流: Reader 
                   |-- BufferedReader  字符流缓冲区
                   |-- InputSteamReader 转换流
                          |-- FileReader  文件字符李璐
                   |-- CharArrayReader   字符数组流
    字符输出流: Writer 
                  |-- BufferedWriter    
                  |-- OutputStreamWriter
                        |-- FileWriter
                  |-- CharArrayWriter
                  |-- PrintWriter 打印流
                            append();
                            print();
                            println();
                            writer();
                            
File：的应用
  1.文件的复制
  2.文件夹的复制
  3.文件夹遍历
  4.文件夹删除

***：
  抛出异常 ， 所以大多数 都是 提示异常信息
  
流 ， 异常：  将程序的 异常信息打印到  日志文件中
 xxx.txt  日期  包 
 
  \ by zero
-------------------------------------------------------------
多线程: 
  什么叫 进程: 在操作系统中，正在运行的程序 叫 进程;
    它会占用操作 系统的 内存， 每个进程都有自己独立的内存空间
     互相不干扰，这种现象叫 并行;  一个程序中可以有多个 运行的程序出现 ;
   
  什么叫线程: 
   线程是 运行在  正在执行的程序程序(进程)中的 子程序流，可以有多个
    每一个线程 都占用 进程的内存空间，住过程序终止了 ，那么 线程也就不存在了
      线程和线程都是独立运行的 相互 不干扰;  他们都公用一个 进程的内存

多线程?  多个线程 并发执行， 高并发;
  多个正在执行的 子程序流

总结: 
  Eclipse: 程序 -----> 进程(运行在操作系统后台的)
     |-- 线程(main线程)
         |-- 子线程  (所有的子线程想要运行 就必须通过  main线程调用)

如何 实现 线程的 并发执行; 

java中如何 实现多线程?
  1.继承 Thread 线程类     线程
  
  2.实现Runable 接口    具有线程的功能， 它本身 不是线程 
  3.实现Callable接口 
  
1.模拟迅雷 下载电影: 
     3个 线程   3个任务
       
每一个功能 最基本是 有由一个线程来执行的 ,
  但是一个线程可以执行多个 功能
  
  main
    new Thread();
    
 Thread类的构造方法: 
     new Thread();
     new Thread(Runnable r);
     new Thread(Runnable r , String name);      
     new Thread(String name);  线程的名字，如果没有 就默认Thread-0
 
 Thread类的常用方法: 
     1.currentThread(); 返回当前线程  的对象   
     2.getId();
     3.getName();
       setName();
     4.getPriority(); 获取线程的优先级 
       setPriority();
     5.isDaemon(); 守护线程   最后执行 ，不确定
         jvm GC 就是一个守护 线程
       setDaemon(true);
       toString();
    
     7.run(); 线程体 ， 一般被重写
     8.start(); 启动线程的方式

线程的生命周期: 
     6.join();   强制加入 : 一般用于 main函数下
     9.sleep(long millis);
     10.yield();  让步   测试

 100

-------------------------------------------------  
1.线程的生命周期: 
   新建 new   
                  
                  
2.sleep 方法  和  yield方法的区别：
   1.sleep方法会让线程进入阻塞状态                   
     yield方法是让线程直接进入就绪状态
   2.sleep方法 需要传入 时间片
     yield不需要入参
   3.sleep方法异常
     yield没有异常
     
   4.sleep： sleep方法执行后 ，这个线程回到了 就绪状态，
                 他会让线程优先高 优先执行
     yield： yield执行后，有可能让 线程优先级较低的先执行
                          
yield一般用于测试环境下; 

join方法 会让 线程进入阻塞状态：；
  调用者 是 强制加入 ，让正在执行的线程  进入阻塞状态         
}
--------------------------------------------------
线程同步: 
   案例: 小朋友抢苹果 ：5个苹果  ， 2个小朋友抢
         
多个 共享一个资源         
   
   在线程并发情况下 ， 多个线程共享 一个资源的时候，
   有可能出现 资源竞争问题;  多个线程同时 执行的这部分代码
        
如何解决 这个资源竞争问题 ？ 
  1.java提供了一个 锁机制   同步锁
      synchronized 关键字
      
java中有两种方式来解决 资源竞争问题: 
 1.同步代码块儿
      synchronized(锁标记(对象)){
          //这里 编写 核心 代码  ，一般情况下 不会 将循环写在这里
      }
 
 2.同步方法
 
     在普通方法上 添加 synchronized 
 
 自己模拟 火车站售票: 
  
   1.Station implement Runnable{
         Rnadom r = new Random();
           
         int tickets = 100;
         public void run(){
        //同步代码块儿  synchronized(this){   }
        //同步方法         public synchronized void catchTicket(){
        
                      } 
         }     
         Thread.sleep(r.nextInt(4000));
   }
   2.Thread t1 = new Thread(station, "窗口一"); 
     Thread t2 = new Thread(station, "窗口二"); 
     Thread t3 = new Thread(station, "窗口三"); 
     Thread t4 = new Thread(station, "窗口四");   
  
    t1.start();
    t2.start();
    t3.start();
    t4.start();