IO流与多线程

IO流的体系

IO流的作用：就是可以对文件或者网络中的数据进行读、写的操作。如下图所示

• 把数据从磁盘、网络中读取到程序中来，用到的是输入流。
• 把程序中的数据写入磁盘、网络中，用到的是输出流。
• 简单记：输入流（读数据）、输出流（写数据）
  

IO流分为两大派系：
1.字节流：字节流又分为字节输入流、字节输出流
2.字符流：字符流由分为字符输入流、字符输出流

FileInputStream读取一个字节

需要用到的方法如下图所示：有构造方法、成员方法

使用FileInputStream读取文件中的字节数据，步骤如下:

第一步：创建FileInputStream文件字节输入流管道，与源文件接通。
第二步：调用read()方法开始读取文件的字节数据。
第三步：调用close()方法释放资源

代码实例:

/**
 * 目标：掌握文件字节输入流，每次读取一个字节。
 */
public class FileInputStreamTest1 {
    public static void main(String[] args) throws Exception {
        // 1、创建文件字节输入流管道，与源文件接通。
        InputStream is = new FileInputStream(("file-io-app\\src\\itheima01.txt"));

        // 2、开始读取文件的字节数据。
        // public int read():每次读取一个字节返回，如果没有数据了，返回-1.
        int b; // 用于记住读取的字节。
        while ((b = is.read()) != -1){
            System.out.print((char) b);
        }
        
        //3、流使用完毕之后，必须关闭！释放系统资源！
        is.close();
    }
}

这里需要注意一个问题：由于一个中文在UTF-8编码方案中是占3个字节，采用一次读取一个字节的方式，读一个字节就相当于读了1/3个汉字，此时将这个字节转换为字符，是会有乱码的。

FileInputStream读取多个字节

使用FileInputStream一次读取多个字节的步骤如下

第一步：创建FileInputStream文件字节输入流管道，与源文件接通。
第二步：调用read(byte[] bytes)方法开始读取文件的字节数据。
第三步：调用close()方法释放资源

代码实例:

/**
 * 目标：掌握使用FileInputStream每次读取多个字节。
 */
public class FileInputStreamTest2 {
    public static void main(String[] args) throws Exception {
        // 1、创建一个字节输入流对象代表字节输入流管道与源文件接通。
        InputStream is = new FileInputStream("file-io-app\\src\\itheima02.txt");

        // 2、开始读取文件中的字节数据：每次读取多个字节。
        //  public int read(byte b[]) throws IOException
        //  每次读取多个字节到字节数组中去，返回读取的字节数量，读取完毕会返回-1.

        // 3、使用循环改造。
        byte[] buffer = new byte[3];
        int len; // 记住每次读取了多少个字节。  abc 66
        while ((len = is.read(buffer)) != -1){
            // 注意：读取多少，倒出多少。
            String rs = new String(buffer, 0 , len);
            System.out.print(rs);
        }
        // 性能得到了明显的提升！！
        // 这种方案也不能避免读取汉字输出乱码的问题！！

        is.close(); // 关闭流
    }
}

需要我们注意的是：read(byte[] bytes)它的返回值，表示当前这一次读取的字节个数。

假设有一个文本文件:
abcde

读取步骤如下

也就是说，并不是每次读取的时候都把数组装满，比如数组是 byte[] bytes = new byte[3];
第一次调用read(bytes)读取了3个字节(分别是97,98,99)，并且往数组中存，此时返回值就是3
第二次调用read(bytes)读取了2个字节(分别是99,100),并且往数组中存，此时返回值是2
第三次调用read(bytes)文件中后面已经没有数据了，此时返回值为-1

• 还需要注意一个问题：采用一次读取多个字节的方式，也是可能有乱码的。因为也有可能读取到半个汉字的情况。

FileInputStream读取全部字节

我们可以一次性读取文件中的全部字节，然后把全部字节转换为一个字符串，就不会有乱码了。

// 1、一次性读取完文件的全部字节到一个字节数组中去。
// 创建一个字节输入流管道与源文件接通
InputStream is = new FileInputStream("file-io-app\\src\\itheima03.txt");

// 2、准备一个字节数组，大小与文件的大小正好一样大。
File f = new File("file-io-app\\src\\itheima03.txt");
long size = f.length();
byte[] buffer = new byte[(int) size];

int len = is.read(buffer);
System.out.println(new String(buffer));

//3、关闭流
is.close(); 

// 1、一次性读取完文件的全部字节到一个字节数组中去。
// 创建一个字节输入流管道与源文件接通
InputStream is = new FileInputStream("file-io-app\\src\\itheima03.txt");

//2、调用方法读取所有字节，返回一个存储所有字节的字节数组。
byte[] buffer = is.readAllBytes();
System.out.println(new String(buffer));

//3、关闭流
is.close();

最后，还是要注意一个问题：**一次读取所有字节虽然可以解决乱码问题，但是文件不能过大，如果文件过大，可能导致内存溢出.

FileOutputStream写字节

使用FileOutputStream往文件中写数据的步骤如下：

第一步：创建FileOutputStream文件字节输出流管道，与目标文件接通。
第二步：调用wirte()方法往文件中写数据
第三步：调用close()方法释放资源

实例代码

/**
 * 目标：掌握文件字节输出流FileOutputStream的使用。
 */
public class FileOutputStreamTest4 {
    public static void main(String[] args) throws Exception {
        // 1、创建一个字节输出流管道与目标文件接通。
        // 覆盖管道：覆盖之前的数据
//        OutputStream os =
//                new FileOutputStream("file-io-app/src/itheima04out.txt");

        // 追加数据的管道
        OutputStream os =
                new FileOutputStream("file-io-app/src/itheima04out.txt", true);

        // 2、开始写字节数据出去了
        os.write(97); // 97就是一个字节，代表a
        os.write('b'); // 'b'也是一个字节
        // os.write('磊'); // [ooo] 默认只能写出去一个字节

        byte[] bytes = "我爱你中国abc".getBytes();
        os.write(bytes);

        os.write(bytes, 0, 15);

        // 换行符
        os.write("\r\n".getBytes());

        os.close(); // 关闭流
    }
}

字节流复制文件

比如：我们要复制一张图片，从磁盘D:/resource/meinv.png的一个位置，复制到C:/data/meinv.png位置。

复制文件的思路如下图所示：

1.需要创建一个FileInputStream流与源文件接通，创建FileOutputStream与目标文件接通
2.然后创建一个数组，使用FileInputStream每次读取一个字节数组的数据，存如数组中
3.然后再使用FileOutputStream把字节数组中的有效元素，写入到目标文件中

/**
 * 目标：使用字节流完成对文件的复制操作。
 */
public class CopyTest5 {
    public static void main(String[] args) throws Exception {
        // 需求：复制照片。
        // 1、创建一个字节输入流管道与源文件接通
        InputStream is = new FileInputStream("D:/resource/meinv.png");
        // 2、创建一个字节输出流管道与目标文件接通。
        OutputStream os = new FileOutputStream("C:/data/meinv.png");

        System.out.println(10 / 0);
        // 3、创建一个字节数组，负责转移字节数据。
        byte[] buffer = new byte[1024]; // 1KB.
        // 4、从字节输入流中读取字节数据，写出去到字节输出流中。读多少写出去多少。
        int len; // 记住每次读取了多少个字节。
        while ((len = is.read(buffer)) != -1){
            os.write(buffer, 0, len);
        }

        os.close();
        is.close();
        System.out.println("复制完成！！");
    }
}

IO流资源释放

我们现在知道这个问题了，那这个问题怎么解决呢？ 在JDK7以前，和JDK7以后分别给出了不同的处理方案。

jdk7之前的方法

try{
//有可能产生异常的代码
}catch(异常类 e){
//处理异常的代码
}finally{
//释放资源的代码
//finally里面的代码有一个特点，不管异常是否发生，finally里面的代码都会执行。
}

实例代码

javapublic class Test2 {
    public static void main(String[] args)  {
        InputStream is = null;
        OutputStream os = null;
        try {
            System.out.println(10 / 0);
            // 1、创建一个字节输入流管道与源文件接通
            is = new FileInputStream("file-io-app\\src\\itheima03.txt");
            // 2、创建一个字节输出流管道与目标文件接通。
            os = new FileOutputStream("file-io-app\\src\\itheima03copy.txt");

            System.out.println(10 / 0);

            // 3、创建一个字节数组，负责转移字节数据。
            byte[] buffer = new byte[1024]; // 1KB.
            // 4、从字节输入流中读取字节数据，写出去到字节输出流中。读多少写出去多少。
            int len; // 记住每次读取了多少个字节。
            while ((len = is.read(buffer)) != -1){
                os.write(buffer, 0, len);
            }
            System.out.println("复制完成！！");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 释放资源的操作
            try {
                if(os != null) os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(is != null) is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

JDK7以后的资源释放

try(资源对象1; 资源对象2;){
使用资源的代码
}catch(异常类 e){
处理异常的代码
}

//注意：注意到没有，这里没有释放资源的代码。它会自动是否资源

实例代码

/**
 * 目标：掌握释放资源的方式：try-with-resource
 */
public class Test3 {
    public static void main(String[] args)  {
    	try (
          // 1、创建一个字节输入流管道与源文件接通
          InputStream is = new FileInputStream("D:/resource/meinv.png");
          // 2、创建一个字节输出流管道与目标文件接通。
          OutputStream os = new FileOutputStream("C:/data/meinv.png");
        ){
            // 3、创建一个字节数组，负责转移字节数据。
            byte[] buffer = new byte[1024]; // 1KB.
            // 4、从字节输入流中读取字节数据，写出去到字节输出流中。读多少写出去多少。
            int len; // 记住每次读取了多少个字节。
            while ((len = is.read(buffer)) != -1){
                os.write(buffer, 0, len);
            }
            System.out.println(conn);
            System.out.println("复制完成！！");

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

字符流

FileReader类

第一步：创建FileReader对象与要读取的源文件接通
第二步：调用read()方法读取文件中的字符
第三步：调用close()方法关闭流

需要用到的方法：先通过构造器创建对象，再通过read方法读取数据（注意：两个read方法的返回值，含义不一样）

/**
 * 目标：掌握文件字符输入流。
 */
public class FileReaderTest1 {
    public static void main(String[] args)  {
       /*
    目标
       使用字符输入流读取文件中的字符数据
     */
    public static void main(String[] args) throws Exception {
        //1:创建字符输入流对象 关联源文件
        // new FileReader(File/String)
        FileReader fr = new FileReader("day10/src/厨师表.txt");

        //2:执行 读取字符操作
        // 一次读一个字符方式   int read() 一次读一个字符形式返回值读取到字符 如果是-1 说明读完了
//        int c ;//c用来接收读取的字符
//        while ((c=fr.read())!=-1){
//            System.out.println((char)c);
//        }

        // 一次读取一个字符数组方式  int read(char[] chs) 使用数组形式完成读取操作 每次读取到数组中，返回值是读取的字符个数
                      //            如果是-1说明读完了。得到读取到的字符个数。字符读到数组中。
        //定义字符数组 使用该数组去接收读取到的字符内容
        char[] buffer = new char[3];
        int len;
        while((len=fr.read(buffer))!=-1){
            //buffer char数组
//            System.out.println(Arrays.toString(buffer));
            //读多少取多少
//            for (int i = 0; i < len; i++) {
//                System.out.print(buffer[i]);
//            }
            //  字符数组一部分也可以变成一个字符串
            System.out.print(new String(buffer,0,len));

        }



        //3:释放资源 --可以采用 try catch省去写 释放资源
        fr.close();
//  还可以如下方式玩
//        try(
//           //流的创建
//                ){
//           //流的使用
//        }catch (){
//            //异常的处理
//        }
    }
    }
}

FileWriter类

在上节课，我们学习了FileReader，它可以将文件中的字符数据读取到程序中来。接下来，我们就要学习FileWriter了，它可以将程序中的字符数据写入文件。

FileWriter往文件中写字符数据的步骤如下：

第一步：创建FileWirter对象与要读取的目标文件接通
第二步：调用write(字符数据/字符数组/字符串)方法读取文件中的字符
第三步：调用close()方法关闭流

需要用到的方法如下：构造器是用来创建FileWriter对象的，有了对象才能调用write方法写数据到文件。

接下来，用代码演示一下：

/*
  目标
    掌握使用字符输出流 完成字符信息 输出
 */
public class FileWriterDemo {

    public static void main(String[] args) throws Exception {
        //1:创建字符输出流对象关联目标文件
//        FileWriter fw = new FileWriter("day10/src/咏二仙桥大爷.txt");
        FileWriter fw = new FileWriter("day10/src/咏二仙桥大爷.txt",true);
        //2:写字符信息
        fw.write('a');//写一个字符
        fw.write(99);//写一个字符 99对应的 c
        fw.write("大爷,走哪条道");//写字符串
        fw.write("\r\n");//换行
        fw.write("大爷说,走成华大道",4,5);
        fw.write("\r\n");//换行
        //还可以写字符数组
        char[] chs = {'车','能','拉','吗'};
        fw.write(chs);
        fw.write("\r\n");//换行
        char[] chs2 = {'可','以',',','只','能','拉','亿','点','点'};
        fw.write(chs2,3,6);
        //3:释放资源
        fw.close();
    }
}

FileWriter写的注意事项

各位同学，刚才我们已经学习了FileWriter字符输出流的基本使用。但是，这里有一个小问题需要和同学们说下一：FileWriter写完数据之后，必须刷新或者关闭，写出去的数据才能生效。

比如：下面的代码只调用了写数据的方法，没有关流的方法。当你打开目标文件时，是看不到任何数据的。

//1.创建FileWriter对象
Writer fw = new FileWriter("io-app2/src/itheima03out.txt");

//2.写字符数据出去
fw.write('a');
fw.write('b');
fw.write('c');

而下面的代码，加上了flush()方法之后，数据就会立即到目标文件中去。

//1.创建FileWriter对象
Writer fw = new FileWriter("io-app2/src/itheima03out.txt");

//2.写字符数据出去
fw.write('a');
fw.write('b');
fw.write('c');

//3.刷新
fw.flush(); 

下面的代码，调用了close()方法，数据也会立即到文件中去。因为close()方法在关闭流之前，会将内存中缓存的数据先刷新到文件，再关流。

//1.创建FileWriter对象
Writer fw = new FileWriter("io-app2/src/itheima03out.txt");

//2.写字符数据出去
fw.write('a');
fw.write('b');
fw.write('c');

//3.关闭流
fw.close(); //会先刷新，再关流

但是需要注意的是，关闭流之后，就不能在对流进行操作了。否则会出异常

缓冲流

学习完字符流之后，接下来我们学习一下缓冲流。我们还是先来认识一下缓存流，再来说一下它的作用。缓冲流有四种，如下图所示

缓冲流的作用：可以对原始流进行包装，提高原始流读写数据的性能。

缓冲字节流

我们先来学习字节缓冲流是如何提高读写数据的性能的，原理如下图所示。是因为在缓冲流的底层自己封装了一个长度为8KB（8129byte）的字节数组，但是缓冲流不能单独使用，它需要依赖于原始流。

• **读数据时：**它先用原始字节输入流一次性读取8KB的数据存入缓冲流内部的数组中（ps: 先一次多囤点货），再从8KB的字节数组中读取一个字节或者多个字节（把消耗屯的货）。

• 写数据时： 它是先把数据写到缓冲流内部的8BK的数组中（ps: 先攒一车货），等数组存满了，再通过原始的字节输出流，一次性写到目标文件中去（把囤好的货，一次性运走）。

在创建缓冲字节流对象时，需要封装一个原始流对象进来。构造方法如下

如果我们用缓冲流复制文件，代码写法如下:

public class BufferedInputOutputDemo {


    public static void main(String[] args) throws Exception{
        //1: 创建字节输入流 关联 源文件
        FileInputStream fis = new FileInputStream("day10/src/木兰诗.txt");
        // 对原始流包装
        BufferedInputStream bis = new BufferedInputStream(fis);
        //2: 创建字节输出流 关联目标文件
        FileOutputStream fos = new FileOutputStream("day10/src/木兰辞.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //3: 读
        byte[] buffer = new byte[1024];
        int len;
        while((len=bis.read(buffer))!=-1){
            //读到 buffer 0开始 len个
            //4: 写
            bos.write(buffer,0,len);
        }

        //5:释放资源
        bos.close();
        fos.close();
        bis.close();
        fis.close();
    }

}

字符缓冲流

接下来，我们学习另外两个缓冲流——字符缓冲流。它的原理和字节缓冲流是类似的，它底层也会有一个8KB的数组，但是这里是字符数组。字符缓冲流也不能单独使用，它需要依赖于原始字符流一起使用。

• **BufferedReader读数据时：**它先原始字符输入流一次性读取8KB的数据存入缓冲流内部的数组中（ps: 先一次多囤点货），再从8KB的字符数组中读取一个字符或者多个字符（把消耗屯的货）。

创建BufferedReader对象需要用到BufferedReader的构造方法，内部需要封装一个原始的字符输入流，我们可以传入FileReader.

而且BufferedReader还要特有的方法，一次可以读取文本文件中的一行

使用BufferedReader读取数据的代码如下

/*
  字符缓冲输入流

 */
public class BufferReaderDemo {

    public static void main(String[] args) throws Exception{
        // 创建一个基本的流 字符输入流
        FileReader fr = new FileReader("day10\\src\\出师表.txt");
        //构建字符缓冲流
        BufferedReader br = new BufferedReader(fr);

        //读取一行数据并返回  如果没有数据可读了 返回null

//        String s = br.readLine();
//        System.out.println(s); //  读取到的数据不为null

        String line ;//用来接收读取的 每一行数据
        while((line=br.readLine())!=null){
            //就可以 打印该行数据
            System.out.println(line);
        }

        //释放
        br.close();
        fr.close();


    }
}

• BufferedWriter写数据时： 它是先把数据写到字符缓冲流内部的8BK的数组中（ps: 先攒一车货），等数组存满了，再通过原始的字符输出流，一次性写到目标文件中去（把囤好的货，一次性运走）。如下图所示

创建BufferedWriter对象时需要用到BufferedWriter的构造方法，而且内部需要封装一个原始的字符输出流，我们这里可以传递FileWriter。

而且BufferedWriter新增了一个功能，可以用来写一个换行符

接下来，用代码演示一下，使用BufferedWriter往文件中写入字符数据。

/*
  字符缓冲输出流

 */
public class BufferWriterDemo {

    public static void main(String[] args) throws Exception{
        // 创建一个基本的流 字符输出流
        FileWriter fw = new FileWriter("day10\\src\\咏鹅.txt");

        // 创建缓冲流包装基本流
        BufferedWriter bw = new BufferedWriter(fw);

        bw.write("鹅鹅鹅");
        bw.newLine();
        bw.write("曲项向天歌");
        bw.newLine();
        bw.write("白毛浮绿水");
        bw.newLine();
        bw.write("红掌拨清波");
        bw.newLine();

        bw.close();
        fw.close();




    }
}

缓冲流性能分析

我们说缓冲流内部多了一个数组，可以提高原始流的读写性能。讲到这一定有同学有这么一个疑问，它和我们使用原始流，自己加一个8BK数组不是一样的吗？ 缓冲流就一定能提高性能吗？先告诉同学们答案，缓冲流不一定能提高性能。

下面我们用一个比较大文件（889MB）复制，做性能测试，分别使用下面四种方式来完成文件复制，并记录文件复制的时间。

① 使用低级流一个字节一个字节的复制

② 使用低级流按照字节数组的形式复制

③ 使用缓冲流一个字节一个字节的复制

④ 使用缓冲流按照字节数组的形式复制

低级流一个字节复制: 慢得简直让人无法忍受
低级流按照字节数组复制(数组长度1024): 12.117s
缓冲流一个字节复制: 11.058s
缓冲流按照字节数组复制(数组长度1024): 2.163s
【注意：这里的测试只能做一个参考，和电脑性能也有直接关系】

经过上面的测试，我们可以得出一个结论：默认情况下，采用一次复制1024个字节，缓冲流完胜。

但是，缓冲流就一定性能高吗？我们采用一次复制8192个字节试试

低级流按照字节数组复制(数组长度8192): 2.535s
缓冲流按照字节数组复制(数组长度8192): 2.088s

经过上面的测试，我们可以得出一个结论：**一次读取8192个字节时，低级流和缓冲流性能相当。**相差的那几毫秒可以忽略不计。

继续把数组变大，看一看缓冲流就一定性能高吗？现在采用一次读取1024*32个字节数据试试

低级流按照字节数组复制(数组长度8192): 1.128s
缓冲流按照字节数组复制(数组长度8192): 1.133s

经过上面的测试，我们可以得出一个结论：**数组越大性能越高，低级流和缓冲流性能相当。**相差的那几秒可以忽略不计。

继续把数组变大，看一看缓冲流就一定性能高吗？现在采用一次读取1024*6个字节数据试试

低级流按照字节数组复制(数组长度8192): 1.039s
缓冲流按照字节数组复制(数组长度8192): 1.151s

此时你会发现，当数组大到一定程度，性能已经提高了多少了，甚至缓冲流的性能还没有低级流高。

最终总结一下：**缓冲流的性能不一定比低级流高，其实低级流自己加一个数组，性能其实是不差。**只不过缓冲流帮你加了一个相对而言大小比较合理的数组 。

转换流

前面我们学习过FileReader读取文件中的字符，但是同学们注意了，FileReader默认只能读取UTF-8编码格式的文件。如果使用FileReader读取GBK格式的文件，可能存在乱码，因为FileReader它遇到汉字默认是按照3个字节来读取的，而GBK格式的文件一个汉字是占2个字节，这样就会导致乱码。

Java给我们提供了另外两种流InputStreamReader，OutputStreamWriter，这两个流我们把它叫做转换流。它们可以将字节流转换为字符流，并且可以指定编码方案。

InputStreamReader类

接下来，我们先学习InputStreamReader类，你看这个类名就比较有意思，前面是InputStream表示字节输入流，后面是Reader表示字符输入流，合在一起意思就是表示可以把InputStream转换为Reader，最终InputStreamReader其实也是Reader的子类，所以也算是字符输入流。

InputStreamReader也是不能单独使用的，它内部需要封装一个InputStream的子类对象，再指定一个编码表，如果不指定编码表，默认会按照UTF-8形式进行转换。

需求：我们可以先准备一个GBK格式的文件，然后使用下面的代码进行读取，看是是否有乱码。

public class InputStreamReaderTest2 {
    public static void main(String[] args) {
        try (
                // 1、得到文件的原始字节流（GBK的字节流形式）
                InputStream is = new FileInputStream("day10\src\gbk文件哦.txt");
                // 2、把原始的字节输入流按照指定的字符集编码转换成字符输入流
                Reader isr = new InputStreamReader(is, "GBK");
                // 3、把字符输入流包装成缓冲字符输入流
                BufferedReader br = new BufferedReader(isr);
                ){
            String line;
            while ((line = br.readLine()) != null){
                System.out.println(line);
            }


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

执行完之后，你会发现没有乱码。

OutputStreamWriter类

接下来，我们先学习OutputStreamWriter类，你看这个类名也比较有意思，前面是OutputStream表示字节输出流，后面是Writer表示字符输出流，合在一起意思就是表示可以把OutputStream转换为Writer，最终OutputStreamWriter其实也是Writer的子类，所以也算是字符输出流。

OutputStreamReader也是不能单独使用的，它内部需要封装一个OutputStream的子类对象，再指定一个编码表，如果不指定编码表，默认会按照UTF-8形式进行转换。

需求：我们可以先准备一个GBK格式的文件，使用下面代码往文件中写字符数据。

public class OutputStreamWriterDemo01 {

    public static void main(String[] args) {


        try(
         // FileWriter 字符流便捷类   自己封装了 字节输出流  使用的默认编码
          // 不能使用 指定编码写数据
         // 介绍下它 的爹 OutputStreamWriter  字符流通向字节流的桥梁
                    //   字符---指定编码--->字节
         //  构造   OutputStreamWriter(字节输出流,编码表)自己封装字节输出流  自己设置编码
         FileOutputStream fos = new FileOutputStream("day10/src/静夜思.txt");//创建字节输出流对象
         OutputStreamWriter osw = new OutputStreamWriter(fos,"GBK");//创建字符输出流对象 指定底层编码和字节输出流对象
         BufferedWriter bw = new BufferedWriter(osw);//封装字符输出流 增强功能

        ){
            bw.write("床前明月光");
            bw.newLine();// 来一个新行  换行
            bw.write("疑是地上霜");
            bw.newLine();
            bw.write("举头望明月");
            bw.newLine();
            bw.write("低头思故乡");
            bw.newLine();
        }catch (Exception e){
            e.printStackTrace();//打印异常信息
        }


    }
}

jdk11新的玩法

public class JDK11New {

    public static void main(String[] args) throws Exception{

       read();

       write();
    }


    private static void read() throws Exception {

//        FileReader fr =  new FileReader("day10\\src\\gbk文件哦.txt");
        //jdk11的时候新增一个构造 可以传递 编码集
        Charset gbk = Charset.forName("GBK");//构建一个编码对象
        FileReader fr =  new FileReader("day10\\src\\gbk文件哦.txt",gbk);
        BufferedReader br = new BufferedReader(fr);

        String s = br.readLine();
        System.out.println(s);

        br.close();
        fr.close();

    }


    private static void write() throws Exception {

        try(
                //定义流资源
                FileWriter fw = new FileWriter("day10/src/猜猜猜.txt",Charset.forName("GBK"));//创建字节输出流对象
                ){
            // 使用流
            fw.write("哈哈哈哈");

        }catch (Exception e){
            e.printStackTrace();//打印异常信息
        }

    }

}

打印流

接下来，我们学习打印流，其实打印流我们从开学第一天就一直再使用，只是没有学到你感受不到而已。打印流可以实现更加方便，更加高效的写数据的方式。

打印流基本使用

打印流，这里所说的打印其实就是写数据的意思，它和普通的write方法写数据还不太一样，一般会使用打印流特有的方法叫print(数据)或者println(数据)，它打印啥就输出啥。

打印流有两个，一个是字节打印流PrintStream，一个是字符打印流PrintWriter，如下图所示

PrintStream和PrintWriter的用法是一样的，所以这里就一块演示了。

public class PrintTest1 {
    public static void main(String[] args) {
        try (
                // 1、创建一个打印流管道
//                PrintStream ps =
//                        new PrintStream("io-app2/src/itheima08.txt", Charset.forName("GBK"));
//                PrintStream ps =
//                        new PrintStream("io-app2/src/itheima08.txt");
                PrintWriter ps =
                        new PrintWriter(new FileOutputStream("io-app2/src/itheima08.txt", true));
                ){
                ps.print(97);	//文件中显示的就是:97
                ps.print('a'); //文件中显示的就是:a
                ps.println("我爱你中国abc");	//文件中显示的就是:我爱你中国abc
                ps.println(true);//文件中显示的就是:true
                ps.println(99.5);//文件中显示的就是99.5

                ps.write(97); //文件中显示a，发现和前面println方法的区别了吗？

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

重定向输出语句

其实我们开学第一课，就给同学们讲过System.out.println()这句话表示打印输出，但是至于为什么能够输出，其实我们一直不清楚。

以前是因为知识储备还不够，无法解释，到现在就可以给同学们揭晓谜底了，因为System里面有一个静态变量叫out，out的数据类型就是PrintStream，它就是一个打印流，而且这个打印流的默认输出目的地是控制台，所以我们调用System.out.pirnln()就可以往控制台打印输出任意类型的数据，而且打印啥就输出啥。

而且System还提供了一个方法，可以修改底层的打印流，这样我们就可以重定向打印语句的输出目的地了。我们玩一下, 直接上代码。

public class PrintTest2 {
    public static void main(String[] args) {
        System.out.println("老骥伏枥");
        System.out.println("志在千里");

        try ( PrintStream ps = new PrintStream("io-app2/src/itheima09.txt"); ){
            // 把系统默认的打印流对象改成自己设置的打印流
            System.setOut(ps);

            System.out.println("烈士暮年");	
            System.out.println("壮心不已");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

此时打印语句，将往文件中打印数据，而不在控制台。

数据流

同学们，接下我们再学习一种流，这种流在开发中偶尔也会用到。比如，我们想把数据和数据的类型一并写到文件中去，读取的时候也将数据和数据类型一并读出来。这就可以用到数据流，有两个DataInputStream和DataOutputStream.

DataOutputStream类

我们先学习DataOutputStream类，它也是一种包装流，创建DataOutputStream对象时，底层需要依赖于一个原始的OutputStream流对象。然后调用它的wirteXxx方法，写的是特定类型的数据。

代码如下：往文件中写整数、小数、布尔类型数据、字符串数据

public class DataOutputStreamTest1 {
    public static void main(String[] args) {
        try (
                // 1、创建一个数据输出流包装低级的字节输出流
                DataOutputStream dos =
                        new DataOutputStream(new FileOutputStream("io-app2/src/itheima10out.txt"));
                ){
            dos.writeInt(97);
            dos.writeDouble(99.5);
            dos.writeBoolean(true);
            dos.writeUTF("黑马程序员666！");

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

DataInputStream类

学习完DataOutputStream后，再学习DataIntputStream类，它也是一种包装流，创建DataInputStream对象时，底层需要依赖于一个原始的InputStream流对象。然后调用它的readXxx()方法就可以读取特定类型的数据。

代码如下：读取文件中特定类型的数据（整数、小数、字符串等）

public class DataInputStreamTest2 {
    public static void main(String[] args) {
        try (
                DataInputStream dis =
                        new DataInputStream(new FileInputStream("io-app2/src/itheima10out.txt"));
                ){
            int i = dis.readInt();
            System.out.println(i);

            double d = dis.readDouble();
            System.out.println(d);

            boolean b = dis.readBoolean();
            System.out.println(b);

            String rs = dis.readUTF();
            System.out.println(rs);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

序列化流

各位同学同学，还有最后一个流要学习，叫做序列化流。序列化流是干什么用的呢？ 我们知道字节流是以字节为单位来读写数据、字符流是按照字符为单位来读写数据、而对象流是以对象为单位来读写数据。也就是把对象当做一个整体，可以写一个对象到文件，也可以从文件中把对象读取出来。

这里有一个新词 序列化，第一次听同学们可能还比较陌生，我来给同学们解释一下

序列化：意思就是把对象写到文件或者网络中去。（简单记：写对象）
反序列化：意思就是把对象从文件或者网络中读取出来。（简单记：读对象）

ObjectOutputStraem类

接下来，先学习ObjectOutputStream流，它也是一个包装流，不能单独使用，需要结合原始的字节输出流使用。

代码如下：将一个User对象写到文件中去

• 第一步：先准备一个User类，必须让其实现Serializable接口。

// 注意：对象如果需要序列化，必须实现序列化接口。
public class User implements Serializable {
    private String loginName;
    private String userName;
    private int age;
    // transient 这个成员变量将不参与序列化。
    private transient String passWord;

    public User() {
    }

    public User(String loginName, String userName, int age, String passWord) {
        this.loginName = loginName;
        this.userName = userName;
        this.age = age;
        this.passWord = passWord;
    }

    @Override
    public String toString() {
        return "User{" +
                "loginName='" + loginName + '\'' +
                ", userName='" + userName + '\'' +
                ", age=" + age +
                ", passWord='" + passWord + '\'' +
                '}';
    }
}

• 第二步：再创建ObjectOutputStream流对象，调用writeObject方法对象到文件。

public class Test1ObjectOutputStream {
    public static void main(String[] args) {
        try (
                // 2、创建一个对象字节输出流包装原始的字节 输出流。
                ObjectOutputStream oos =
                        new ObjectOutputStream(new FileOutputStream("io-app2/src/itheima11out.txt"));
                ){
            // 1、创建一个Java对象。
            User u = new User("admin", "张三", 32, "666888xyz");

            // 3、序列化对象到文件中去
            oos.writeObject(u);
            System.out.println("序列化对象成功！！");

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

注意：写到文件中的对象，是不能用记事本打开看的。因为对象本身就不是文本数据，打开是乱码

怎样才能读懂文件中的对象是什么呢？这里必须用反序列化，自己写代码读。

ObjectInputStream类

接下来，学习ObjectInputStream流，它也是一个包装流，不能单独使用，需要结合原始的字节输入流使用。

接着前面的案例，文件中已经有一个Student对象，现在要使用ObjectInputStream读取出来。称之为反序列化。

public class Test2ObjectInputStream {
    public static void main(String[] args) {
        try (
            // 1、创建一个对象字节输入流管道，包装 低级的字节输入流与源文件接通
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("io-app2/src/itheima11out.txt"));
        ){
            User u = (User) ois.readObject();
            System.out.println(u);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

IO框架

最后，再给同学们补充讲解一个知识，叫做IO框架。它有什么用呢？有同学经常问老师，我们只学习了IO流对文件复制，能不能复制文件夹呀？

当然是可以咯，但是如果让我们自己写复制文件夹的代码需要用到递归，还是比较麻烦的。为了简化对IO操作，由apache开源基金组织提供了一组有关IO流小框架，可以提高IO流的开发效率。

这个框架的名字叫commons-io：其本质是别人写好的一些字节码文件（class文件），打包成了一个jar包。我们只需要把jar包引入到我们的项目中，就可以直接用了。

这里给同学们介绍一个jar包中提供的工具类叫FileUtils，它的部分功能如下，很方便，你一看名字就知道怎么用了。

在写代码之前，先需要引入jar包，具体步骤如下

1.在模块的目录下，新建一个lib文件夹
2.把jar包复制粘贴到lib文件夹下
3.选择lib下的jar包，右键点击Add As Library，然后就可以用了。

代码如下：

public class CommonsIOTest1 {
    public static void main(String[] args) throws Exception {
        //1.复制文件
        FileUtils.copyFile(new File("io-app2\\src\\itheima01.txt"), new File("io-app2/src/a.txt"));
        
        //2.复制文件夹
        FileUtils.copyDirectory(new File("D:\\resource\\私人珍藏"), new File("D:\\resource\\私人珍藏3"));
        
        //3.删除文件夹
        FileUtils.deleteDirectory(new File("D:\\resource\\私人珍藏3"));

        // Java提供的原生的一行代码搞定很多事情
         Files.copy(Path.of("io-app2\\src\\itheima01.txt"), Path.of("io-app2\\src\\b.txt"));
        System.out.println(Files.readString(Path.of("io-app2\\src\\itheima01.txt")));
    }
}

3.多线程

线程创建方式1

Java为开发者提供了一个类叫做Thread，此类的对象用来表示线程。创建线程并执行线程的步骤如下

1.定义一个子类继承Thread类，并重写run方法
2.创建Thread的子类对象
3.调用start方法启动线程（启动线程后，会自动执行run方法中的代码）

代码如下:

/**
 *   开启线程方式1
 *      继承Thread类
 *        1:创建一个自定义类型 继承Thread
 *          class MyThread extends Thread
 *        2:重写run方法  ---该线程要执行的代码路径
 *        3:在需要开启新的线程地方
 *          创建线程对象 并且调用 start()方法
 */
public class MyThread extends Thread{

    @Override
    public void run() { //线程任务
        // run代表只要开启 MyThread线程 就会执行run方法代码
        for (int i = 0; i < 10; i++) {
            System.out.println("在"+Thread.currentThread().getName()+" 线程中执行"+i);
        }
    }
}

再定义一个测试类，在测试类中创建MyThread线程对象，并启动线程

package com.itheima.d_thread;

public class ThreadTest01 {

    /*
        Thread 代表线程类
          Thread.currentThread() 获取 当前正在执行该代码的线程对象。
        Thread对象有个方法
            getName() 获取线程的名字
     */
    public static void main(String[] args) {
        // 当我们点击 RUN ThreadTest01.main的时候 就开启了一个线程 去执行当前main方法里面写的代码 都是由上至下
        // 当前执行的时候就是一个线程
        System.out.println(Thread.currentThread().getName()+"中执行1");

       // 需求  在main线程中开启一个新的线程。
//        MyThread myThread = new MyThread();
//        myThread.start();
        new MyThread().start();
        //   new MyThread() 既是线程对象 又是 线程任务对象

        for (int i = 0; i < 10; i++) {
            System.out.println("在"+Thread.currentThread().getName()+"中正在执行:"+i);
        }

        System.out.println("在"+Thread.currentThread().getName()+"中执行2");
    }
}

打印结果如下图所示，我们会发现MyThread和main线程在相互抢夺CPU的执行权（注意：哪一个线程先执行，哪一个线程后执行，目前我们是无法控制的，每次输出结果都会不一样）

线程创建方式2

接下来我们学习线程的第二种创建方式。Java为开发者提供了一个Runnable接口，该接口中只有一个run方法，意思就是通过Runnable接口的实现类对象专门来表示线程要执行的任务。具体步骤如下

1.先写一个Runnable接口的实现类，重写run方法(这里面就是线程要执行的代码)
2.再创建一个Runnable实现类的对象
3.创建一个Thread对象，把Runnable实现类的对象传递给Thread
4.调用Thread对象的start()方法启动线程（启动后会自动执行Runnable里面的run方法）

代码如下：先准备一个Runnable接口的实现类

/*

   1: 创建一个实现类 实现 线程任务接口 Runnable接口 重写 run方法
        比如 MyRunnable   重写run 线程的任务
   2:  创建 Runable接口实现类对象  MyRunnable对象。
   3:  将线程任务对象交给线程对象  创建Thread类对象的同时 传递线程任务对象
         new Thread(Runnable实现类对象);
   4:  线程对象.start()
 */
public class MyRunnable implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("在"+Thread.currentThread().getName()+"线程中执行"+i);
        }

    }
}

再写一个测试类，在测试类中创建线程对象，并执行线程

    public static void main(String[] args) {
        // 当我们点击 RUN ThreadTest01.main的时候 就开启了一个线程 去执行当前main方法里面写的代码 都是由上至下
        // 当前执行的时候就是一个线程
        System.out.println(Thread.currentThread().getName()+"中执行1");

       // 需求  在main线程中开启一个新的线程。
//        2:  创建 Runable接口实现类对象  MyRunnable对象。
        MyRunnable mr = new MyRunnable();
//        3:  将线程任务对象交给线程对象  创建Thread类对象的同时 传递线程任务对象
//        new Thread(Runnable实现类对象);
        //        4:  线程对象.start()
        new Thread(mr).start();


        for (int i = 0; i < 10; i++) {
            System.out.println("在"+Thread.currentThread().getName()+"中正在执行:"+i);
        }

        System.out.println("在"+Thread.currentThread().getName()+"中执行2");
    }
}

运行上面代码，结果如下图所示**（注意：没有出现下面交替执行的效果，也是正常的）**

主线程main输出 ===》1
主线程main输出 ===》2
主线程main输出 ===》3
子线程输出 ===》1
子线程输出 ===》2
子线程输出 ===》3
子线程输出 ===》4
子线程输出 ===》5
主线程main输出 ===》4
主线程main输出 ===》5

线程创建方式2—匿名内部类

同学们注意了，现在这种写法不是新知识。只是将前面第二种方式用匿名内部类改写一下。因为同学们在看别人写的代码时，有可能会看到这种写法。你知道是怎么回事就可以了。

刚刚我们学习的第二种线程的创建方式，需要写一个Runnable接口的实现类，然后再把Runnable实现类的对象传递给Thread对象。

现在我不想写Runnable实现类，于是可以直接创建Runnable接口的匿名内部类对象，传递给Thread对象。

代码如下

public class ThreadTest03 {

    /*
        Thread 代表线程类
          Thread.currentThread() 获取 当前正在执行该代码的线程对象。
        Thread对象有个方法
            getName() 获取线程的名字
     */
    public static void main(String[] args) {
        // 当我们点击 RUN ThreadTest01.main的时候 就开启了一个线程 去执行当前main方法里面写的代码 都是由上至下
        // 当前执行的时候就是一个线程
        System.out.println(Thread.currentThread().getName()+"中执行1");

       // 需求  在main线程中开启一个新的线程。

//        new Thread(Runnable的实现类对象).start();

//        new Thread(Runnable匿名内部类对象).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("在"+Thread.currentThread().getName()+"中正在执行:"+i);
                }
            }
        }).start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                System.out.println("在"+Thread.currentThread().getName()+"中正在执行:"+i);
            }
        }).start();

        for (int i = 0; i < 10; i++) {
            System.out.println("在"+Thread.currentThread().getName()+"中正在执行:"+i);
        }

        System.out.println("在"+Thread.currentThread().getName()+"中执行2");
    }
}

线程的创建方式3

接下来，我们学习线程的第三种创建方式。已经有两种了为什么还有要第三种呢？ 这样，我们先分析一下前面两种都存在的一个问题。然后再引出第三种可以解决这个问题。

• 假设线程执行完毕之后有一些数据需要返回，前面两种方式重写的run方法均没有返回结果。

  public void run(){
      ...线程执行的代码...
  }
  

• JDK5提供了Callable接口和FutureTask类来创建线程，它最大的优点就是有返回值。

  在Callable接口中有一个call方法，重写call方法就是线程要执行的代码，它是有返回值的

  public T call(){
      ...线程执行的代码...
      return 结果;
  }
  

第三种创建线程的方式，步骤如下

1.先定义一个Callable接口的实现类，重写call方法
2.创建Callable实现类的对象
3.创建FutureTask类的对象，将Callable对象传递给FutureTask
4.创建Thread对象，将Future对象传递给Thread
5.调用Thread的start()方法启动线程(启动后会自动执行call方法)
   等call()方法执行完之后，会自动将返回值结果封装到FutrueTask对象中
   
6.调用FutrueTask对的get()方法获取返回结果

代码如下：先准备一个Callable接口的实现类

/**
 *  使用Callable接口 形式来玩新的线程
 *    1:创建一个Callable接口实现类  泛型表示返回值的类型
 *    2: 重写方法  任务 求绝对值
 *    3: 在需要创建新线程的地方 先创建一个Callable实现类对象
 *    4: 创建 处理用于接收线程任务返回值类对象 FutureTask  传递线程任务
 *    5：创建线程对象 传入 task对象 .start()启动新的线程。
 *    6: 结果 找 task.get()处理
 */
public class MyCallable implements Callable<Integer> {

    private Integer number;//定义了成员变量

    public MyCallable(Integer number){//怎么把接收到number传递到 下面call方法中
        this.number = number;//传过来的值 给了 成员变量
    }

    // 求一个数的绝对值
    @Override
    public Integer call() throws Exception {

        System.out.println("当前在:"+Thread.currentThread().getName()+"完成绝对值的获取");

        return Math.abs(number); //使用到了成员变量
    }
}

再定义一个测试类，在测试类中创建线程并启动线程，还要获取返回结果

public class ThreadTest04 {

    /*
        Thread 代表线程类
          Thread.currentThread() 获取 当前正在执行该代码的线程对象。
        Thread对象有个方法
            getName() 获取线程的名字
     */
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 当我们点击 RUN ThreadTest01.main的时候 就开启了一个线程 去执行当前main方法里面写的代码 都是由上至下
        // 当前执行的时候就是一个线程
        System.out.println(Thread.currentThread().getName()+"中执行1");

       // 需求  在main线程中开启一个新的线程。
          // 创建 Callable实现类对象
        MyCallable mc = new MyCallable(-10);
        //创建 处理用于接收线程任务返回值类对象 FutureTask  传递线程任务
        FutureTask<Integer> task = new FutureTask<>(mc);
        // 创建线程对象 传入 处理返回值的线程任务
        new Thread(task).start();//线程对象

        // 返回值怎么处理 ？  tack处理返回值
        System.out.println("新线程的返回值是:"+task.get());

        System.out.println("在"+Thread.currentThread().getName()+"中执行2");


    }
}

多线程常用方法

下面我们演示一下getName()、setName(String name)、currentThread()、sleep(long time)这些方法的使用效果。

public class MyThread extends Thread{
    public MyThread(String name){
        super(name); // 为当前线程设置名字了
    }
    @Override
    public void run() {
        // 哪个线程执行它，它就会得到哪个线程对象。
        Thread t = Thread.currentThread();
        for (int i = 1; i <= 5; i++) {
            System.out.println(t.getName() + "大声叫：吕布小儿 莫跑~~接我" + i+"招");
        }
    }
}

再测试类中，创建线程对象，并启动线程

/**
 * 目标：掌握Thread的常用方法。
 */
public class ThreadTest1 {
    public static void main(String[] args) {
        System.out.println("接下来请欣赏 三英战吕布");
        for (int i = 5; i >= 1; i--) {
            System.out.println(i);
            Thread.sleep(1000);
        }
        
        MyThread t1 = new MyThread("刘备");
        // t1.setName("刘备");
        t1.start();
        System.out.println(t1.getName()); // Thread-0

        MyThread t2 = new MyThread("关羽");
        // t2.setName("关羽");
        t2.start();
        System.out.println(t2.getName()); // Thread-1

        MyThread t3 = new MyThread("张飞");
        // t3.setName("张飞");
        t3.start();
        System.out.println(t3.getName()); // Thread-1

    }
}

执行上面代码，效果如下图所示，我们发现每一条线程都有自己了名字了。

最后再演示一下join这个方法是什么效果。

/**
 * 目标：掌握join方法的作用。
 */
public class ThreadTest2 {
    public static void main(String[] args) throws Exception {
        System.out.println("关羽和总部一起打吕布");
        // join方法作用：让当前调用这个方法的线程先执行完。
        MyThread t = new MyThread("关羽");

        t.start();

        Thread.currentThread().setName("总部");
        for (int i = 1; i <=5; i++) {
            System.out.println(Thread.currentThread().getName()+"发射弓箭弩~~第"+i+"发");
        }

    }
}

不加join执行效果是 此时你会发现关于线程没有执行完总部线程就执行了（效果是多次运行才出现的，根据个人电脑而异，可能有同学半天也出现不了也是正常的）

public class ThreadTest2 {
    public static void main(String[] args) throws Exception {
        System.out.println("关羽和总部一起打吕布");
        // join方法作用：让当前调用这个方法的线程先执行完。
        MyThread t = new MyThread("关羽");

        t.start();
        t.join();

        Thread.currentThread().setName("总部");
        for (int i = 1; i <=5; i++) {
            System.out.println(Thread.currentThread().getName()+"发射弓箭弩~~第"+i+"发");
        }

    }
}

我们再尝试，把join()方法加上，再看执行效果。 执行多次 关于执行完 总部才执行

线程安全问题

各位小伙伴，前面我们已经学习了如何创建线程，以及线程的常用方法。接下来，我们要学习一个在实际开发过程中，使用线程时最重要的一个问题，叫线程安全问题。

线程安全问题概述

• 首先，什么是线程安全问题呢？

线程安全问题指的是，多个线程同时操作同一个共享资源的时候，可能会出现业务安全问题。

下面通过一个取钱的案例给同学们演示一下。案例需求如下

场景：小明和小红是一对夫妻，他们有一个共享账户，余额是10万元，小红和小明同时来取钱，并且2人各自都在取钱10万元，可能出现什么问题呢？

如下图所示，小明和小红假设都是一个线程，本类每个线程都应该执行完三步操作，才算是完成的取钱的操作。但是真实执行过程可能是下面这样子的

​ ① 小红线程只执行了判断余额是否足够（条件为true），然后CPU的执行权就被小红线程抢走了。

​ ② 小红线程也执行了判断了余额是否足够（条件也是true）, 然后CPU执行权又被小明线程抢走了。

​ ③ 小明线程由于刚才已经判断余额是否足够了，直接执行第2步，吐出了10万元钱，此时共享账户月为0。然后CPU执行权又被小红线程抢走。

​ ④ 小红线程由于刚刚也已经判断余额是否足够了，直接执行第2步，吐出了10万元钱，此时共享账户月为-10万。

你会发现，在这个取钱案例中，两个人把共享账户的钱都取了10万，但问题是只有10万块钱啊！！！

以上取钱案例中的问题，就是线程安全问题的一种体现。

线程安全问题的代码演示

先定义一个共享的账户类

public class Account {
    private String cardId; // 卡号
    private double money; // 余额。

    public Account() {
    }

    public Account(String cardId, double money) {
        this.cardId = cardId;
        this.money = money;
    }

    // 小明 小红同时过来的
    public void drawMoney(double money) {
        // 先搞清楚是谁来取钱？
        String name = Thread.currentThread().getName();
        // 1、判断余额是否足够
        if(this.money >= money){
            System.out.println(name + "来取钱" + money + "成功！");
            this.money -= money;
            System.out.println(name + "来取钱后，余额剩余：" + this.money);
        }else {
            System.out.println(name + "来取钱：余额不足~");
        }
    }

    public String getCardId() {
        return cardId;
    }

    public void setCardId(String cardId) {
        this.cardId = cardId;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}

在定义一个是取钱的线程类

public class DrawThread extends Thread{
    private Account acc;
    public DrawThread(Account acc, String name){
        super(name);
        this.acc = acc;
    }
    @Override
    public void run() {
        // 取钱(小明，小红)
        acc.drawMoney(100000);
    }
}

最后，再写一个测试类，在测试类中创建两个线程对象

public class ThreadTest {
    public static void main(String[] args) {
         // 1、创建一个账户对象，代表两个人的共享账户。
        Account acc = new Account("ICBC-110", 100000);
        // 2、创建两个线程，分别代表小明 小红，再去同一个账户对象中取钱10万。
        new DrawThread(acc, "小明").start(); // 小明
        new DrawThread(acc, "小红").start(); // 小红
    }
}

运行程序，执行效果如下。你会发现两个人都取了10万块钱，余额为-10完了。

线程同步方案

为了解决前面的线程安全问题，我们可以使用线程同步思想。同步最常见的方案就是加锁，意思是每次只允许一个线程加锁，加锁后才能进入访问，访问完毕后自动释放锁，然后其他线程才能再加锁进来。

等小红线程执行完了，把余额改为0，出去了就会释放锁。这时小明线程就可以加锁进来执行，如下图所示。

采用加锁的方案，就可以解决前面两个线程都取10万块钱的问题。怎么加锁呢？Java提供了三种方案

1.同步代码块
2.同步方法
3.Lock锁

同步代码块

我们先来学习同步代码块。它的作用就是把访问共享数据的代码锁起来，以此保证线程安全。

//锁对象：必须是一个唯一的对象（同一个地址）
synchronized(锁对象){
    //...访问共享数据的代码...
}

使用同步代码块，来解决前面代码里面的线程安全问题。我们只需要修改DrawThread类中的代码即可。

// 小明 小红线程同时过来的
public void drawMoney(double money) {
    // 先搞清楚是谁来取钱？
    String name = Thread.currentThread().getName();
    // 1、判断余额是否足够
    // this正好代表共享资源！
    synchronized (this) {
        if(this.money >= money){
            System.out.println(name + "来取钱" + money + "成功！");
            this.money -= money;
            System.out.println(name + "来取钱后，余额剩余：" + this.money);
        }else {
            System.out.println(name + "来取钱：余额不足~");
        }
    }
}

此时再运行测试类，观察是否会出现不合理的情况。

最后，再给同学们说一下锁对象如何选择的问题

1.建议把共享资源作为锁对象, 不要将随便无关的对象当做锁对象
2.对于实例方法，建议使用this作为锁对象
3.对于静态方法，建议把类的字节码(类名.class)当做锁对象

同步方法

接下来，学习同步方法解决线程安全问题。其实同步方法，就是把整个方法给锁住，一个线程调用这个方法，另一个线程调用的时候就执行不了，只有等上一个线程调用结束，下一个线程调用才能继续执行。

// 同步方法
public synchronized void drawMoney(double money) {
    // 先搞清楚是谁来取钱？
    String name = Thread.currentThread().getName();
    // 1、判断余额是否足够
    if(this.money >= money){
        System.out.println(name + "来取钱" + money + "成功！");
        this.money -= money;
        System.out.println(name + "来取钱后，余额剩余：" + this.money);
    }else {
        System.out.println(name + "来取钱：余额不足~");
    }
}

改完之后，再次运行测试类，观察是否会出现不合理的情况。

接着，再问同学们一个问题，同步方法有没有锁对象？锁对象是谁？

同步方法也是有锁对象，只不过这个锁对象没有显示的写出来而已。
	1.对于实例方法，锁对象其实是this（也就是方法的调用者）
	2.对于静态方法，锁对象时类的字节码对象（类名.class）

最终，总结一下同步代码块和同步方法有什么区别？

1.不存在哪个好与不好，只是一个锁住的范围大，一个范围小
2.同步方法是将方法中所有的代码锁住
3.同步代码块是将方法中的部分代码锁住

Lock锁

接下来，我们再来学习一种，线程安全问题的解决办法，叫做Lock锁。

Lock锁是JDK5版本专门提供的一种锁对象，通过这个锁对象的方法来达到加锁，和释放锁的目的，使用起来更加灵活。格式如下

1.首先在成员变量位子，需要创建一个Lock接口的实现类对象（这个对象就是锁对象）
	private final Lock lk = new ReentrantLock();
2.在需要上锁的地方加入下面的代码
	 lk.lock(); // 加锁
	 //...中间是被锁住的代码...
	 lk.unlock(); // 解锁

使用Lock锁改写前面DrawThread中取钱的方法，代码如下

// 创建了一个锁对象
private final Lock lk = new ReentrantLock();

public void drawMoney(double money) {
        // 先搞清楚是谁来取钱？
        String name = Thread.currentThread().getName();
        try {
            lk.lock(); // 加锁
            // 1、判断余额是否足够
            if(this.money >= money){
                System.out.println(name + "来取钱" + money + "成功！");
                this.money -= money;
                System.out.println(name + "来取钱后，余额剩余：" + this.money);
            }else {
                System.out.println(name + "来取钱：余额不足~");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lk.unlock(); // 解锁
        }
    }
}

运行程序结果，观察是否有线程安全问题。到此三种解决线程安全问题的办法我们就学习完了。

线程池

线程池概述

各位小伙伴，接下来我们学习一下线程池技术。先认识一下什么是线程池技术？ 其实，线程池就是一个可以复用线程的技术。

要理解什么是线程复用技术，我们先得看一下不使用线程池会有什么问题，理解了这些问题之后，我们在解释线程复用同学们就好理解了。

假设：用户每次发起一个请求给后台，后台就创建一个新的线程来处理，下次新的任务过来肯定也会创建新的线程，如果用户量非常大，创建的线程也讲越来越多。然而，创建线程是开销很大的，并且请求过多时，会严重影响系统性能。

而使用线程池，就可以解决上面的问题。如下图所示，线程池内部会有一个容器，存储几个核心线程，假设有3个核心线程，这3个核心线程可以处理3个任务。

但是任务总有被执行完的时候，假设第1个线程的任务执行完了，那么第1个线程就空闲下来了，有新的任务时，空闲下来的第1个线程可以去执行其他任务。依此内推，这3个线程可以不断的复用，也可以执行很多个任务。

所以，线程池就是一个线程复用技术，它可以提高线程的利用率。

创建线程池

在JDK5版本中提供了代表线程池的接口ExecutorService，而这个接口下有一个实现类叫ThreadPoolExecutor类，使用ThreadPoolExecutor类就可以用来创建线程池对象。

下面是它的构造器，参数比较多，不要怕，干就完了^_。

接下来，用这7个参数的构造器来创建线程池的对象。代码如下

ExecutorService pool = new ThreadPoolExecutor(
    3,	//核心线程数有3个
    5,  //最大线程数有5个。   临时线程数=最大线程数-核心线程数=5-3=2
    8,	//临时线程存活的时间8秒。 意思是临时线程8秒没有任务执行，就会被销毁掉。
    TimeUnit.SECONDS,//时间单位（秒）
    new ArrayBlockingQueue<>(4), //任务阻塞队列，没有来得及执行的任务在，任务队列中等待
    Executors.defaultThreadFactory(), //用于创建线程的工厂对象
    new ThreadPoolExecutor.CallerRunsPolicy() //拒绝策略
);

关于线程池，我们需要注意下面的两个问题

• 临时线程什么时候创建？

  新任务提交时，发现核心线程都在忙、任务队列满了、并且还可以创建临时线程，此时会创建临时线程。
  

• 什么时候开始拒绝新的任务？

  核心线程和临时线程都在忙、任务队列也满了、新任务过来时才会开始拒绝任务。
  

线程池执行Runnable任务

创建好线程池之后，接下来我们就可以使用线程池执行任务了。线程池执行的任务可以有两种，一种是Runnable任务；一种是callable任务。下面的execute方法可以用来执行Runnable任务。

先准备一个线程任务类

public class CuoZao implements Runnable{
    @Override
    public void run() {
        // 任务 是搓澡
        System.out.println("号码为:"+Thread.currentThread().getName()+" 的师傅,正在给客人搓澡====>盐搓 醋搓");

        //模拟搓澡时间
        try {
            Thread.sleep(7000);//7秒 搓好一个人
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

下面是执行Runnable任务的代码，注意阅读注释，对照着前面的7个参数理解。

public class PoTianZaoTang {

    public static void main(String[] args) throws InterruptedException {
        //创建一个线程池 表示 每一个线程 是一个 搓澡人员

        ExecutorService pool = new ThreadPoolExecutor(
                3,// 核心搓澡师傅 3个 核心线程数
                5,// 最多有五个 3个正式+2个临时 最大线程数
                8, //  临时线程存活时间
                TimeUnit.SECONDS, //  最多有8秒 摸鱼，超过8秒 开了临时的
                new ArrayBlockingQueue<>(5),//任务阻塞队列   可以排队的人数 没来得及搓澡 而排队的客人
                Executors.defaultThreadFactory(), //线程的创建工程  死的
                //拒绝策略  忙不过来 交给main线程  忙不过老板上
                new ThreadPoolExecutor.CallerRunsPolicy()
        );

        // 执行任务
        //创建搓澡任务
        CuoZao cz = new CuoZao();
        pool.execute(cz);// 核心
        pool.execute(cz);// 核心
        pool.execute(cz);// 核心


        pool.execute(cz);// 等待 核心搓完
        pool.execute(cz);//等待
        pool.execute(cz);//等待
        pool.execute(cz);//等待
        pool.execute(cz);//等待
        // 核心3 忙碌   -- 任务阻塞队列 5 +1
        pool.execute(cz);//等待
        pool.execute(cz);//等待

        // 5+5  核心+临时 已经在忙了  队伍也满了  老板上 拒绝策略是老板上
        pool.execute(cz);//等待
        Thread.sleep(17000);
        System.out.println("已经空闲了10秒了  会开掉 两个师傅 留下三个师傅");

        pool.execute(cz);// 核心
        pool.execute(cz);// 核心
        pool.execute(cz);// 核心


        pool.execute(cz);// 等待 核心搓完
        pool.execute(cz);//等待

        //可以关闭线程池
//        pool.shutdown();//都搓完了 在关闭
//       pool.shutdownNow();//立马 关闭 没搓完 不搓了
    }
}

执行上面的代码，结果输出如下

线程池执行Callable任务

接下来，我们学习使用线程池执行Callable任务。callable任务相对于Runnable任务来说，就是多了一个返回值。

执行Callable任务需要用到下面的submit方法

先准备一个Callable线程任务

public class MyCallable implements Callable<Integer> {

    private Integer number;//定义了成员变量

    public MyCallable(Integer number){//怎么把接收到number传递到 下面call方法中
        this.number = number;//传过来的值 给了 成员变量
    }

    // 求一个数的绝对值
    @Override
    public Integer call() throws Exception {

        System.out.println("当前在:"+Thread.currentThread().getName()+"完成绝对值的获取");

        return Math.abs(number); //使用到了成员变量
    }
}

再准备一个测试类，在测试类中创建线程池，并执行callable任务。

public class ShuXueAiTang {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        //创建一个线程池 表示 每一个线程 回答的一个问题

        ExecutorService pool = new ThreadPoolExecutor(
                3,
                5,
                8,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(5),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.CallerRunsPolicy()
        );

        // 执行提交 callable任务
        Future<Integer> f1 = pool.submit(new MyCallable(-10));
        Future<Integer> f2 = pool.submit(new MyCallable(-1));
        Future<Integer> f3 = pool.submit(new MyCallable(100));
        Future<Integer> f4 = pool.submit(new MyCallable(0));

        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());


        //可以关闭线程池
//        pool.shutdown();//都搓完了 在关闭
//       pool.shutdownNow();//立马 关闭 没搓完 不搓了
    }
}

执行后，结果如下图所示

线程池工具类（Executors）

有同学可能会觉得前面创建线程池的代码参数太多、记不住，有没有快捷的创建线程池的方法呢？有的。Java为开发者提供了一个创建线程池的工具类，叫做Executors，它提供了方法可以创建各种不能特点的线程池。如下图所示

接下来，我们演示一下创建固定线程数量的线程池。这几个方法用得不多，所以这里不做过多演示，同学们了解一下就行了。

public class ThreadPoolTest {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        //创建一个线程池  传递一个参数
        ExecutorService pool = Executors.newFixedThreadPool(3);

        // 执行提交 callable任务
        Future<Integer> f1 = pool.submit(new MyCallable(-10));
        Future<Integer> f2 = pool.submit(new MyCallable(-1));
        Future<Integer> f3 = pool.submit(new MyCallable(100));
        Future<Integer> f4 = pool.submit(new MyCallable(0));

        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());


        //可以关闭线程池
//        pool.shutdown();//都搓完了 在关闭
//       pool.shutdownNow();//立马 关闭 没搓完 不搓了
    }
}

Executors创建线程池这么好用，为什么不推荐同学们使用呢？原因在这里：看下图，这是《阿里巴巴Java开发手册》提供的强制规范要求。