线程、输入输出流

1、IO流：File对象

       在java里\代表转译符，所以文件之间的分割符用\\代替

       File   file=new   File("文件路径")  String类型

       Long   length=file.Length()    返回文件多少字节

       File   file1=new   File("文件夹")   路径

       String[]   fileNames=file1.list()    返回当前文件夹下文件名称数组

       file.exists()    判断文件是否存在

       file1.getAbsolutepath()   获取文件绝对路径

       file.isFile()   判断是否是单个文件true

       file1.isFile()    判断是否是单个文件false

       file.isDirectory()   是否是文件夹false

       file1.isDirectory()   是否是文件夹true

       File[]   files=file1.listFile()   获取文件夹中的文件

       Long   xz=file.LastModified()获取文件最后修改时间

       File   file2=new   File("\\新创建的文件.txt")

       boolean   flag=file2.crerteNewFile()   创建一个文件  

       File   file3=new    File("\\新建文件夹")

       boolean   flag=file3.mkdir()   创建文件夹

       boolean   flag=file3.mkdirs()    创建一个文件夹下面还有一个文件夹，就是同时创建两个文件夹

       File   file4=new   File("url")   

       boolean   flag=file4.delete()    删除

       file.renameTo("")    重命名

2、字节流：inputStream输入流，outputStream输出流

      例：File   file=new File("URL")

             File   file1=new File("URL")

             InputStream  is=new  FileInputStream(file)

             outputStream  os=new FileOutputstream(file1)

             if(is!=null&&os!=null){

                   int   len=-1  定义一个数组，将内存中读取字节存在数组中

                   byte[]   myBytes=new   byte[1024]

                   while(len=is.read(myBytes)!=-1){

                          os.write(myBytes,0,len)   a从哪个数组中读取，输出流从哪写出，b从第几个元素开始读取，c读取多少个元素

                   }

                   is.close()

                   os.close()

             }

3、BufferedInputStream建立在字节输入流基础上，不用一个字节一个字节处理，提高了性能

      BufferedoutputStream建立在输出流基础上

4、字符流：不能对单字节构成的文件进行读写，不嫩处理视频的图片，以字节流为基础实现

     InputStream   in=new   FileInputStream(file)

     InputStreamreader    read=new    InputstreamReader(in)

     OutputStream   out=new   FileOutputStream(file)

     OutputStreamWriter   wr=new   OutputStreamWriter(out)

5、bufferedReader、BufferedWriter高级流

     br.readline   读取每一行的字符

     br.colse()

     bw.flush()   缓存中

     bw.colse()   

6、线程：

      自定义一个类继承自Thread类，重写父类的run方法，创建自定义类的对象（实例），用该对象调用父类的start()方法启动线程

       实现Runnable接口，并实现run方法，穿件线程对象（两种方式），用对象调用start()方法

       线程同步：Sychronized(object){

                         }

                         修饰符   Sychronized   返回值    方法名/sale（）{

                         }

                         在run()方法中调用sale（）方法

        线程：在一个程序中同时运行多个独立流程

                  主线程：main

                  在java中创建线程的方法有两种：继承java.lang.Thread类，实现java.lang.Runnable接口

                  例如：public  class  Mythread  extends  Thread{

                                     private  Test  test=new  Test();

                                     run(){重写run方法

                                               Syso.....(Thread.currentThread().getName());

                                               test.dowork();

                                      }

                                      main()方法{

                                               MyThread  t1=new  MyThread();同时启动3次线程

                                               MyThread  t2=new  MyThread();

                                               MyThread  t3=new  MyThread();

                                               t1.start();启动线程

                                               t2.start();

                                               t3.start();

                                      }

                             }

                     例如：public  class  Mythread  implements  Runnable{

                                         run(){重写run方法

                                                  Syso......(Thread.currentThread().getName());

                                                  for(int  i=1;i<=5;i++){

                                                           Syso.....("===="+i);

                                                            Thread.sleep(10000);睡10秒

                                                  }

                                         }

                                         main(){

                                                   MyThread   t1=new   MyThread();第一种创建线程的方式

                                                   MyThread   t2=new   MyThread();第二种创建线程的方式

                                                   Thread   tr=new   Thread(tr2);

                                                   Thread   trd=new   Thread(new  MyThread());

                                                   Thread   trd1=new   Thread(new  MyThread());

                                                   Thread   trd2=new   Thread(new  MyThread());

                                                   trd.start();

                                                   trd1.start();

                                                   trd2.start();

                                         }

                                }

7、控制线程的主要方法：Thread

       start()    启动线程

       suspend()    挂起线程

       resame()    继续挂起线程

       join()    等待线程执行完毕，当前线程执行完毕之后再执行

       yield()   暂缓线程

       sleep()    线程等待

       wait()   线程等待    属于object类，必须在同步块中调用

       notify()    唤醒线程    属于object类，必须在同步块中调用

8、线程安全、线程不安全：

线程同步：就是当一个程序对一个线程安全的方法或者语句进行访问的时候，其他的不能再对他进行操作了，必须等到这次访问结束y以后才能对这个线程安全的方法进行访问

线程安全：如果你的代码所在进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码，如果每次运行和单线程运行结果一样，而且其他的变量的值也和预期的是一样的就是线程安全的，若每个线程中对全局变量静态变量只有读操作，而无写操作，一般来说就是线程安全的，若有多个线程同时执行写操作，一般都需要考虑线程同步，否则就可能影响线程安全

9、多线程：

多线程：新建、就绪、运行、阻塞、死亡状态

资源利用率更高，程序设计更简单，程序响应更快，提高CPU的利用率，用户体验好，使用线程可以把占据时间长的程序中的人物放到后台去处理用户界面更吸引人，这样比如用户点击了一个程序按钮去触发某个事件，可以弹出一个进度条来显示处理的进度

大量的线程会影响性能，因为操作系统需要在它们之间切换，更多的线程需要更多的内存空间，线程终止需要考虑对程序运行的影响

10、多线程有几种实现方法，都是什么？同步有几种实现方法，都是什么？

多线程有两种实现方法：
　　方法一：继承Thread类，重写方法run();
　　方法二：实现Runnable接口，实现方法run();
共同点：
不论用哪种方法，都必须用Thread（如果是Thead子类就用它本身）产生线程，然后再调用start()方法。

区别：
继承Thread类有一个缺点就是单继承，而实现Runnable接口则弥补了它的缺点，可以实现多继承
继承Thread类必须如果产生Runnable实例对象，就必须产生多个Runnable实例对象，然后再用Thread产生多个线程；而实现Runnable接口，只需要建立一个实现这个类的实例，然后用这一个实例对象产生多个线程。即实现了资源的共享性

https://www.cnblogs.com/liujichang/p/3150387.html 介绍使用方法

实现同步有几种方法：例如：synchronized,wait,notify都可以实现同步。

11、线程生命周期图(新建、就绪、运行、阻塞、消亡)