Java必知基础（七）

最新推荐文章于 2021-08-06 19:04:09 发布

li_zhengmei

最新推荐文章于 2021-08-06 19:04:09 发布

阅读量154

点赞数

分类专栏： Java 文章标签：多线程 IO

本文链接：https://blog.csdn.net/li_zhengmei/article/details/90519395

版权

Java 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

IO

IO流就是用来处理设备之间的数据传输，java.io包下提供了各种“流”类和接口，用以获取不同种类的数据。

按操作数据单位不同分为字节流：以字节为单位，每次读入或读出是8bit位数据，可以读任何类型数据。字符流以字符为单位，每次读入或读出是16bit位数据，只能读取字符类型数据。
按数据流的流向不同分为：输入流：读取外部数据（磁盘、网络等）到程序中（内存），输出流：将程序数据（内存）输出到磁盘、光盘等存储设备中。
按照流的角色不同分为：节点流：直接与数据源相连，读入或输出，处理流：与节点流一块使用，在节点流的基础上，再套接一层，套接在节点流上的就是处理流。

Java的IO流共涉及40多个类，实际上非常规则，都是从如下4个抽象基类派生而来：

抽象基类	字节流	字符流
输入流	InputStream	RedReader
输出流	OutputStream	Writer

由这四个类派生出来的子类名称都是以其父类名作为子类名后缀的。
常用的流可参考如下表格：

分类	字节输入流	字节输出流	字符输入流	字符输出流
抽象基类	InputStream	OutputStream	Reader	Writer
文件流	FileInputStream	FileOutputStream	FileReader	FileWriter
数组流	ByteArrayInputStream	ByteArrayOutputStream	CharArrayReader	CharArrayWriter
管道流	PipedInputStream	PipedOutputStream	PipedReader	PipedWriter
字符串流			StringReader	StringWriter
缓冲流	BufferedInputStream	BufferedOutputStream	BufferedReader	BufferedWriter
转换流			InputStreamReader	OutputStreamWriter
对象流	ObjectInputStream	ObjectOutputStream
打印流		PrintStream		PrintWriter
特殊流	DataInputStream	DataOutputStream

多线程

程序、进程、线程的概念。

程序：是为完成特定任务，用某种语言编写的一组指令的集合。即指一段静态的代码、静态的对象。
进程：是程序的一次执行过程，或是正在运行的一个程序，有它自身产生、运行、消亡的过程。
线程：进程可进一步细分为线程，是程序执行时可划分的最小执行单位。

何时需要多线程：当程序需要同时执行两个或多个任务时，或需要实现一些等待的任务时如文件读写操作、网络请求等。

如何创建多线程？

可通过java.lang.Thread类来实现多线程，Thread类的特点有：

每个线程都是通过某个特定的Thread对象的run方法来完成操作的，经常把run方法的主体称为线程体。
通过该Thread对象的start方法来启动这个线程

创建多线程的两张方式：

继承自Thread类重写父类run方法：

public class Thread1 extends Thread {

    @Override
    public void run() {
        super.run();
        // to do something
    }
}

实现Runnable接口并使用Thread类的带有Runnable参数的构造器创建Thread对象：

public class Thread2 implements Runnable {
    @Override
    public void run() {
        // to do something
    }
}
	//实现多线程
     Thread thread = new Thread(new Thread2());
        thread.start();

实现Runnable接口优点在于避免了类只能单继承的缺点，除了该类可以实现多线程还可以继承其它类完成一些扩展。

线程的生命周期

一个线程完整的生命周期通常要经历如下的五种状态：

新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态。
就绪：处于新建状态的线程被start（）后，将进入线程队列等待CPU时间片，此时它已经具备了运行条件。
运行：当就绪的线程被调度并获得CPU资源时便进入运行状态，run（）方法定义了线程的操作和功能。
阻塞：在某种特殊情况下，被认为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行进入阻塞状态。
死亡：线程完成了它的全部工作或被提前强制终止。

可参考下图理解
线程生命周期

线程的同步机制

当多线程操作同一份数据时会出现数据混乱的问题，原因是由于一个线程在操作共享数据过程中，在未执行完毕的情况下另外的线程参与进来，可以通过同步机制来解决该问题。
Synchronized 关键字使用方式

同步代码块

//使用时要确保对象的唯一性即多个线程拿到的对象是同一个
synchronized （对象）{
//需要被同步的代码
}

同步方法
在方法的声明中使用该关键字

 public synchronized void security(){
        //需要被同步的代码
    }

死锁问题

原因：不同的线程分别占用对方需要的同步资源不释放，都在等待对方释放自己需要的同步资源，就形成了线程的死锁。

    public void threadTest() {
        final Object o1 = new Object();
        final Object o2 = new Object();
        new Thread(){
            @Override
            public void run() {
                synchronized (o1){
                    try {
                    Thread.currentThread().sleep(100);
                        System.out.print("获得了o1需获得o2才能继续执行");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (o2){
                        System.out.print("获得了o2继续执行");
                    }
                }

            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                synchronized (o2){
                    try {
                        Thread.currentThread().sleep(100);
                        System.out.print("获得了o2需获得o1才能继续执行");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (o1){
                        System.out.print("获得了o1继续执行");
                    }
                }
            }
        }.start();

    }

可以通过专门的算法、原则或者尽量减少同步资源的定义去解决死锁问题。

线程通信

线程间通信需要用到notify（）、notifyAll（）、和wait（）方法：

notify（）：唤醒正在排队等待同步资源的线程中优先级最高者结束等待；
notifyAll（）：唤醒正在排队等待资源的所有线程结束等待；
wait（）令当前线程挂起并放弃CPU、同步资源使别的线程可访问并修改共享资源，而当前线程排队等候再次对资源的访问。

使用方式如下：
线程1、2交替打印数字至100

public class Thread2 implements Runnable {
    int num;

    @Override
    public void run() {
        while (true){
            synchronized (this){
                notify();
                if (num<=100){
                    System.out.print(num+ Thread.currentThread().getName()+"\n");
                    num++;
                }else{
                    break;
                }
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}


   @Test
    public void threadTest2() {

        Thread2 s = new Thread2();

        Thread thread1 = new Thread(s,"thread1");
        Thread thread2 = new Thread(s,"thread2");

        thread1.start();
        thread2.start();

    }