对象流、进程与线程、线程的创建

本文主要内容：

（1）对象流

（2）序列化与反序列化

（3）进程与线程

（4）线程的创建

1.数组流：
byte数组：ByteArrayInputStream/ByteArrayOutputStream
char数组：CharArrayReader/CharArrayWriter
2.数据流：DataInputStream/DataOutputStream
3.字符串流：StringReader/StringWriter
4.对象流（ObjectInputStream/ObjectOutputStream）
（1）对象的序列化/反序列化
对象的序列化指的是讲一个完整的对象拆分成字节碎片，记录在文件中；对象的反序列化指的是将文件中记录的字节碎片反过来组合成一个完整的对象。
（2）如果想要将对象序列化到文件中，需要让对象实现Serializable接口，是一个示意性接口，同时为了让对象可以反序列化，需要让对象中多存在一个属性（版本号）
（3）如果想让对象反序列化，需要给对象提供一个序列化的版本号(serialVersionUID),通常为私有静态的

//序列化
public class Person implements Serializable {
    private String name;
    private int age;

    public Person(){}

    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
}

public class TestObjectStream {
    public static void main(String[] args) {
        try {
            Person p = new Person("小明",18);
            FileOutputStream fos = new FileOutputStream("D://test//Person.txt");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(p);
            oos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class Person implements Serializable {
    private long serialVersionUID = 5671060527211679650L;//版本号
    private String name;
    private int age;

    public Person(){}

    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
}

5.进程：是程序在操作系统上运行的过程，他是系统进行资源分配和资源调度的独立单位。而多进程指的是CPU交替轮流执行多个进程的结果，是并发的。
6.线程：在一个进程内部可以执行多个任务，将进程内部的任务称为线程，是程序使用CPU的基本单位，在一个进程中的多个线程共享一个存储空间，线程之间通讯比较简单，若是在程序中切换进程，则要改变地址空间位置，而多线程只需要改变次序。
7.进程与线程的区别：
（1）每个进程占有独立的地址空间，包括代码、数据及资源，属于同一进程的多个线程只能共享这些数据，不具有独立的地址空间
（2）进程间的通讯开销比较小，线程可以直接通过读写进程数据段来进行通信
（3）线程是进程的一部分，因此程序有时称轻量级进程
8.程序与进程的区别：
（1）程序是静态的，进程是动态的
（2）程序是永久的，进程是临时的，会动态的产生和消亡
（3）进程中包含程序
（4）一个程序可以有多个进程公用，另一方面，一个进程在活动中可顺序的执行若干个程序
9.线程的创建
（1）通过Thread类创建线程
创建一个类继承与Thread类，并覆写run()方法，最后通过该类对象调用start()方法，启动线程，注意：一个线程对象只能调用一次start()方法，若多次调用则会抛出异常

public class TestThread extends Thread{
    private String title;
    public TestThread(){}
    public TestThread(String title){
        this.title = title;
    }
    public void run(){
        for(int i = 0;i<10;i++){
            System.out.println("当前运行的线程是  "+this.title+","+"i="+i);
        }
    }

    public static void main(String[] args) {
        TestThread th1 = new TestThread("线程1");
        TestThread th2 = new TestThread("线程2");
        TestThread th3 = new TestThread();
        th3.title = "线程3";
        th1.start();
        th2.start();
        th3.start();
    }
}

（2）通过实现Runnable接口来实现多线程
创建一个类实现Runnable方法，并覆写run()方法，Runable接口对线程没有任何支持，因此获得线程实例后，必须通过Thread类构造方法实现

public class TestThread implements Runnable{
    private String title;
    public TestThread(){}
    public TestThread(String title){
        this.title = title;
    }
    @Override
    public void run() {
        for(int i = 0;i<10;i++){
            System.out.println("当前线程是  "+this.title+" i="+i);
        }
    }

    public static void main(String[] args) {
        TestThread th1 = new TestThread("线程1");
        TestThread th2 = new TestThread("线程2");
        Thread t1 = new Thread(th1);
        Thread t2 = new Thread(th2);
        t1.start();
        t2.start();
    }
}

（3）通过Callable实现多线程（带有返回值）

class MyThread implements Callable<String> {
    private int ticket = 10;
    // 一共10张票 
    @Override
    public String call() throws Exception {
        while (this.ticket > 0) {
            System.out.println("剩余票数：" + this.ticket--);
        }
        return "票卖完了，下次吧。。。";
    }
}