笔记之_Java整理IO流

线程重复执行：
ScheduledExecutorService exec = Executors.newScheduledThreadPool(1);
        exec.scheduleAtFixedRate(线程名, 1, 1, TimeUnit.SECONDS);
字符输出流writer写完后要执行flush()方法，不然内容不存在
IO流：实时交互
Socket网络交互
多线程和socket合为一体
所有软件几乎都会有多线程，所有跟网络有关的必须要使用socket
大多数的程序只能循环运行单独的程序块，但无法同时运行不同的多个程序块
Poc、计算器、记事本等都是单线程
Java支持多线程
进程：一般是对操作系统而言的(windows、linux/Android、Unix/ios)
所有的应用程序都要运行在进程中
    分类：
        前台进程：有界面，用户能感知
        后台进程：无界面，但是后台运行(升级、maven)
线程：在应用程序中去开辟
    多线程：含义是指在单个进程中，可以同时运行不同的线程，执行不同任务
            共享同一块内存空间和同一组系统资源，有可能相互影响
            多线程的执行策略是抢占式策略
            一般由exe、虚拟机执行
    单线程：同一时间，一个进程只执行一个线程，无论这个线程多复杂
进程是由操作系统来管理的，而线程则是在一个程序中(进程中)
线程优先级为十个等级：默认为5，标准普通，值越大，优先级越高
线程一词来源于linux
Java实现线程：
        继承Thread类(Thread类实现了Runnable的方法)
            实现Runnable做公共类，使用AtomicInteger定义变量
        实现Runnable接口
            Thread可用静态变量int
优先级低不代表抢不到资源，而是抢到的几率小一点
多线程执行的顺序无法保证，每次顺序不一样
接口在实现未实现的方法可以被new
并发变量AtomicInteger：
做操作时其他线程等待
get()取值，set(int)设值
getandIncrement()取得之后再加一
AtomicInteger  i=new AtomicInteger(20);
并发：同一时间多个方法对同一个变量进行操作
一个进程new完后只能调用一次start()，后面会报错
线程启动用start()，如果用run()则调用的是一个普通方法
同步：为了防止多个线程同时访问同一个数据对象，对象数据造成损坏
防止同步：排队，一个一个对共享资源进行操作，而不是同时操作





Java线程同步方法：synchronized
    同步方法
        public synchronized void test() {
}
    同步代码块
        private static Object obj=new Object();
public void test() {
    synchronized(obj){
    }
}
或者
public void test() {
    synchronized(this.class){ 
    }
}
相对而言同步方法安全性要高些

死锁：同步的线程分别占用地方需要的资源不放弃，都在等待对方放弃自己需要的同步资源，从而形成线程的死锁
死锁与死循环
死锁导致的情况就是程序不执行操作了，一直在等待(不占用cpu资源)
死循环是一直在执行
Java线程通信规定使用wait()、notify()、notifyAll()
存放线程的容器叫做线程池(有序的集合，LinkedList,方便新增和删除)
线程池中的线程处于wait()状态，执行一个线程后notify()或notifyAll()
多线程中wait()、notify()、notifyAll()方法属于Object类
Wait()与sleep()区别：
Wait()线程处于等待状态，释放对象锁(放弃抢占资源)，让其他线程进行运行，由notify()或notifyAll()唤醒线程
    Sleep()线程处于休眠状态，等到指定时间会自动唤醒，并且在休眠中不会释放对象锁
Yield()静态方法，放弃本次执行，让其他线程先执行
isAlive()判断线程是否还存在
join()将一个线程加入子线程
每个Java程序都会有一个主线程，多线程的实现就是在主线程main()中创建新的线程
线程的状态转换：
        创建：Thread myThread = new MyThreadClass( );
        就绪：调用start()
        运行：
        阻塞：sleep()或wait()方法时
        销毁：正常结束或强制结束(stop())
Suspend()容易出现死锁，被wait()替代了，用resume()唤醒
Native关键字，本地的，虚拟机的资源


AtomicInteger的方法：
        Set()设置值
        Get()取值
如果在方法中使用了wait()或者notify()/notifyAll()这个方法必须加synchronized关键字
CPU在同一时刻处理线程数为：cpu核数*3-1
线程池：
    含义：
线程池的基本思想还是一种对象池的思想，开辟一块内存空间，
里面存放了众多（未死亡）的线程，池中线程执行调度由池管
理器来处理。当有线程任务时，从池中取一个，执行完成后线
程对象归池，这样可以避免反复创建线程对象所带来的性能开
销，节省了系统的资源
作用： 优化程序，节约系统的开销
线程池比较重要的类
ExecutorService： 真正的线程池接口。
ScheduledExecutorService： 能和Timer/TimerTask类似，解决那些需要任务重复执行的问题。 
ThreadPoolExecutor：  ExecutorService的默认实现。
ScheduledThreadPoolExecutor  继承ThreadPoolExecutor的ScheduledExecutorService接口实现，周期性任务调度的类实现。
配置线程池方法：
newSingleThreadExecutor 创建一个单线程的线程池
newFixedThreadPool 创建固定大小的线程池
newCachedThreadPool 创建一个可缓存的线程池
newScheduledThreadPool 创建一个大小无限的线程池
    执行用execute()
    关闭用shutdown()
线程控制方法：
start() 线程方法，新建的线程进入Runnable状态
wait()对象方法，释放对象锁，线程进入blocked状态，等待被notify或时间到期
notify()/notifyAll() 对象方法，唤醒其他的线程
yield() 线程静态方法，放弃执行，回到Runnable状态，使其他优先级不低于此线程的线程有机会先运行
sleep() 线程静态方法，线程睡眠指定的一段时间，线程进入blocked状态
join()线程方法，调用这个方法的线程，会等待加入的子线程完成
isAlive() 判断某一个线程是否还在运行run,Run方法结束返回false 
    setPriority()设置线程优先级
    currentThread()获得当前线程
getId()取得线程Id
getName()取得线程名称
setName()设置线程名称






调度策略
协同式：
线程的执行时间由线程本身控制，线程把自己的工作执行完了之后，要主动通知系统切换到另一个线程上。
坏处：线程执行时间不可控制
抢占式：
高优先级的线程抢占CPU
每个线程将由系统来分配执行时间，线程的切换不由线程本身来决定.
(线程划分为1~10等级，默认为5)
Java的调度方法
同优先级线程组成先进先出队列，使用时间片策略
对高优先级，使用优先调度的抢占式策略
多线程的优势
减轻编写交互频繁、涉及面多的程序的困难（如监听网络端口）。
程序的吞吐量会得到改善（同时监听多种设备， 如网络端口、串口、并口以及其他外设）。
有多个处理器的系统，可以并发运行不同的线程（否则，任何时刻只有一个线程在运行）。
进程和线程的不同点
进程是由操作系统来管理的，而线程则是在一个程序（进程）内。
不同进程的代码、内部数据和状态都是完全独立的，而一个程序内的多线程是共享同一块内存空间和同一组系统资源，有可能互相影响。
线程本身的数据通常只有寄存器数据，以及一个程序执行时使用的堆栈，所以线程的切换比进程切换的负担要小。
线程池实例：
        ExecutorService  pool=Executors.newSingleThreadExecutor();
        Thread  t1=new MyThread();
        pool.execute(t1);
pool.shutdonw();
1： 线程的基本概念、线程的基本状态及状态之间的关系？
线程是比进程更小的单位，是进程内部独立的、有序的指令流。因此，一个进程能包括多个并发执行的线程。由于各个线程之间的控制流彼此独立，使得各个线程之间的代码是乱序执行的，由此带来的线程调度、同步等问题需要进行特殊处理。
线程有五种状态：新生态，可运行态，运行态，阻塞态，死亡态。
1、当利用new创建线程实例对象后，他仅仅作为一个实例存在，jvm没有为其分配CPU时间片等线程运行资源，该线程处于新生态。
2、可运行态，当线程对象调用了start()方法后，该线程处于可运行态，这时线程已经获得了除cpu之外的其他系统资源，只等jvm的线程调度管理器按照线程的优先级对该线程进行调度，从而使该现成拥有能够获取cpu时间片的机会。3、运行状态，jvm选中一个可运行状态线程，使其占有cpu并转换为运行状态。运行状态的线程执行自己的run()方法中的代码，直到调用其他方法而终止，或等待某资源而阻塞或完成任务而死亡。
4、阻塞状态，处于运行状态的线程在某些情况下，如执行了sleep()方法，或等待I/O设备资源，将让出cpu并暂时终止自己的运行，进入阻塞状态，也称为不可运行状态。出于阻塞状态的线程是不可执行的，即使cpu空闲 
5、死亡状态，死亡状态是线程生命周期中最后一个阶段。导致现成死亡有两种情况：一种是线程正常完成了全部工作，即run()方法的代码。另一种是线程被强制性的终止，如通过stop()方法来终止一个线程。
2：多线程有几种实现方法，都是什么？
两种实现方法，一种是继承Thread,另外一种是实现接口Runnable。
3：同步有几种实现方法，都是什么？
同步的实现方法有两种，分别是synchronized, wait与notify。用synchronized可以对一段代码、一个对象及一个方法进行加锁。用wait与notify可以使对象处于等待及唤醒方式导致同步，因为每个对象都直接或间接的继承了Object类。
4：sleep()和wait()有什么区别？
sleep是线程类(Thread)的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监恐状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。
wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法(或notifyAll方法)后本线程才进入对象锁定池准备获得对象锁进入运行状态。
5：同步和异步有何异同，在什么情况下分别使用他们？举例说明。
如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存储(也就是给对象资源加锁)，在java中用synchronized关键字给对象、程序段、方法加锁。
当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回值时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。
6：当一个线程进入一个对象的一个synchronized方法后，其他线程是否可以进入此对象的方法？
不能，一个对象的一个synchronized方法只能由一个线程访问。
7：简述synchronized和java.util.concurrent.locks.Lock的异同？
主要相同点：Lock能完成synchronized所实现的所有功能
主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally从句中释放。
8：java中有几种方法可以实现一个线程？
用什么关键字修饰同步方法？
stop()和suspend()方法为何不推荐使用？
第二问就是synchronized。
下面说说第三问：
反对使用stop()，是因为它不安全。
它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改他们。结果很难检查出真正的问题所在。suspend()方法容易发生死锁。调用suspend()方法的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。此时，其他任何线程都不能访问锁定的资源，除非被“挂起”的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成死锁。所以不应该使用suspend()，而应该在自己的Thread类中置一个标志，指出线程应该活动还是挂起。若标志指出线程应该挂起，使用wait()命令进入等待状态。若标志指出线程应当恢复，则用一个notify()重新启动线程。
流：可以理解为一组有序的、有起点的和有终点的管道
输入和输出是就程序本身而言的
    输入流：读取数据到内存
    输出流：内存数据写入磁盘
流的分类：
    输入流
输出流
    或：字节流：处理图片、压缩文件、包括字符串(会乱码)
字符流：处理字符串
字节输入流：inputSteam
字节输出流：outputStream
字符输入流：Reader接口
字符输出流：Writer接口
包装类：字节流与字符流的转换

输出时new  FileOutputStream(“文件地址及名称”,true)，为true时表示存在文件就追加内容，没有就新建，不写true表示存在就覆盖，不存在就新建
使用byteArrayOutputStream解决InputStream传输字符串乱码问题
后缀为dat的文件存放重要数据，可以反序列化
地址栏输入网址请求，一定是get请求
支付宝接口、微信接口
Eclips中project?clearn重新编译项目
Eclipse中项目右键?properties?Java compiler?设置编译JDK的版本
字节输入流：
    节点流类型：
            FileInputStream
            PipedInputStream
            ByteArrayInputStream
    处理流类型(包装类)：
    BufferedInputStream
    SequenceInputStream
    ObjectInputStream
字节输入流方法：
    int read()
    int read(byte[]  b)
    int read(byte[],int  offset,int  length)
字符输入流：
    节点流类型：
FileReader
PipedReader
charArrayReader
    处理流类型(包装类)：
        BufferedReader
        InputStreamReader
字符输入流方法：
    int read()
    int read(chare[]  b)
    int read(char[],int  offset,int  length)









字节输出流：
    节点流类型：
            FileOutputStream
            PipedOutputStream
            ByteArrayOutputStream
    处理流类型(包装类)：
    BufferedOutputStream
    DateOutputStream
    ObjectOutputStream
    PrintStream
字节输出流方法：
    void write (byte[]  b)
    void write (byte[],int  offset,int  length)
字符输出流：
    节点流类型：
FileWriter
PipedWriter
charArrayWriter
    处理流类型(包装类)：
        BufferedWriter
        InputStreamWriter
printWriter
字符输出流方法：
    void write ()
    void write (char[]  b)
    void write (char[],int  offset,int  length)


















字节输入流：
    private static void readAll(){
        InputStream  is=null;
        try {
             is=new FileInputStream("f:\\xiaoshuo.txt");
             byte[]  data=new byte[1024]; 
             int len=0;
             StringBuffer str=new StringBuffer();
             while(   (len=is.read(data))!=-1  ){
                 System.out.println("本次读了长度为："+len+"个字节的数据");
                 
                 str.append(  new  String(data,0,len,"UTF-8")  ); 
             }
             System.out.println("------------读完了---------------");
             System.out.println(str.toString());
        } catch (FileNotFoundException e) { 
            e.printStackTrace();
        } catch (IOException e) { 
            e.printStackTrace();
        }finally{
            if(is!=null){
                try {
                    is.close();
                } catch (IOException e) { 
                    e.printStackTrace();
                }
            }
        } 
    }
字符输入流：
    private static void readAll(){
        Reader rd=null;        
        try {
            rd=new FileReader("f:\\xiaoshuo.txt");
            char[] data=new char[1024];
            int len=0;
            StringBuffer str=new StringBuffer();
            while(  (len=rd.read(data))!=-1  ){
                 System.out.println("本次读了长度为："+len+"个字符的数据");
                 str.append(new String(data, 0, len));
            }
            System.out.println(str.toString());
        } catch (FileNotFoundException e) { 
            e.printStackTrace();
        } catch (IOException e) { 
            e.printStackTrace();
        }finally{
            if(rd!=null){
                try {
                    rd.close();
                } catch (IOException e) { 
                    e.printStackTrace();
                }
            }
        }
利用包装类解决字节流乱码问题：
        private static void readAll(){
        InputStream  is=null;
        ByteArrayOutputStream baos=null;
        try {
             is=new FileInputStream("f:\\xiaoshuo.txt");
             baos=new ByteArrayOutputStream();
             byte[]  data=new byte[1024]; 
             int len=0;
             while(   (len=is.read(data))!=-1  ){
                 System.out.println("本次读了长度为："+len+"个字节的数据");
                 baos.write(data, 0, len);
             }
             
             System.out.println("------------读完了---------------");
             System.out.println(  baos.toString("UTF-8"));
        } catch (FileNotFoundException e) { 
            e.printStackTrace();
        } catch (IOException e) { 
            e.printStackTrace();
        }finally{
            if(is!=null){
                try {
                    is.close();
                } catch (IOException e) { 
                    e.printStackTrace();
                }
            }
            if(baos!=null){
                try {
                    baos.close();
                } catch (IOException e) { 
                    e.printStackTrace();
                }
            }
        }
    }
输出流实例：
        private static void write1(){
        OutputStream  os=null;
        try {
            os=new FileOutputStream("f:\\11.txt",true);
            String info="\r\n这是我的四个数据";
            os.write( info.getBytes("UTF-8"));
            os.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) { 
            e.printStackTrace();
        } catch (IOException e) {             
            e.printStackTrace();
        }finally{
            if(os!=null){
                try {
                    os.close();
                } catch (IOException e) { 
                    e.printStackTrace();
                }
            }
        }
    }
序列化：将对象写入文件，对象要继承serializable实现接口
        private static void xulihua() {
        Student st = new Student();
        st.setId(1000);
        st.setName("测试");
        st.setSex("男");
        st.setHp(100);
        ObjectOutputStream oos = null;
        try {
            OutputStream os = new FileOutputStream("f:\\stu.dat");
            oos = new ObjectOutputStream(os);
            st.setHp(50);   
            System.out.println(".....保存游戏进度......");
            System.out.println("被弄死了......");
            System.out.println("Game over.....");
            oos.writeObject(st);
            oos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (oos != null) {
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
反序列化：对象不能改变
        private static void reload(){
        ObjectInputStream  ois=null;
        try {
            InputStream  in=new FileInputStream("f:\\stu.dat");
            ois=new ObjectInputStream(in);
            Student  stu=(Student) ois.readObject();
            System.out.println(stu.toString());
        } catch (FileNotFoundException e) { 
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) { 
            e.printStackTrace();
        }finally{
            if(ois!=null){
                try {
                    ois.close();
                } catch (IOException e) { 
                    e.printStackTrace();
                }
            }
        }
    }
网络下载器：
    public static void main(String[] args) {
            OutputStream  download=null;
            HttpURLConnection conn=null;
            try {
                URL    url=new URL
("http://dlc2.pconline.com.cn/filedown_171040_8417060/Yx2PSEuB/jpwb2017cl.exe");
                conn=(HttpURLConnection) url.openConnection();
                conn.setRequestMethod("GET");
                conn.setConnectTimeout(3000);
                 System.out.println("响应码:"+conn.getResponseCode());
                if(conn.getResponseCode()==200){
                    InputStream  readInfo=conn.getInputStream();
                    download=new FileOutputStream("f:\\jpwb2.exe");
                    byte[]  data=new byte[1024*100];
                    int len=0;
                    
                    while( (len=readInfo.read(data))!=-1){
                        System.out.println("从服务器上面读取了"+(len/1024.0)+"KB的数据");
                        download.write(data, 0, len);
                        download.flush();
                    }
                    System.out.println("-----文件下载成功----");
                }
            } catch (MalformedURLException e) {             
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }finally{
                if(download!=null){
                    try {
                        download.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if(conn!=null){
                    conn.disconnect();                }
            }
        }


线程实例Thread：
public class Test1 {
    public static void main(String[] args) {
        Test1  test=new Test1();
        MyThread1  t1=test.new MyThread1();
        t1.setPriority(10);   //优先级设这最高
        t1.start();  //启动多线程
        MyThread1  t2=test.new MyThread1();
        t2.setPriority(1);   //优先级设为最低
        t2.start();
    }
    class MyThread1 extends Thread {
        @Override
        public void run() {
            for(int i=1;i<=20;i++){
                System.out.println("线程"+this.getId()+":"+i);
            }
        }
    }
}
线程实例Runnable接口：
public class MyRunnable implements Runnable{
    public void run() {
       for(int i=1;i<=20;i++){ 
           System.out.println("线程"+Thread.currentThread().getId()+":"+i); 
       }
    }
}
public static void main(String[] args) {
        MyRunnable myRun = new MyRunnable();
        Thread t1 = new Thread(myRun);
        t1.start();
        Thread t2 = new Thread(myRun);
        t2.start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 20; i++) {
                    System.out.println("线程" + Thread.currentThread().getId()
                            + ":" + i); 
                }
            }
        }).start();
    }