Java语法进阶-优快云博客

Object类、常用API
Collection、泛型
List、Set、数据结构、Collections
Map与斗地主案例
异常、线程
线程、同步
等待与唤醒案例、线程池、Lambda表达式
File类、递归
字节流、字符流
缓冲流、转换流、序列化流、Files
网络编程十二、函数式接口
Stream流、方法引用

一、Object类、常用API

二、Collection、泛型

三、List、Set、数据结构、Collections

四、Map与斗地主案例

五、异常、线程

目标：
1、说出进程的概念
2、说出线程的概念
3、能够理解并发与并行的区别
4、能够开启新线程

4.1 并发与并行

并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生）。

4.2 线程与进程

进程：
是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
进程：
线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程

理解版：

进程： 进入到内存的程序，叫作“进程”。
在ROM（永久）存储的应用程序通过点击运行，进入RAM（临时）内存中
进程： 点击运行应用程序or功能就会开启一条应用程序到CPU的执行路径，这个路径有个名字，叫作“线程”。

进程：

线程：
线程图

线程调度：

分时调度：
所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。
抢占式调度：
优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

抢占式调度详解
大部分操作系统都支持多进程并发运行，现在的操作系统几乎都支持同时运行多个程序。比如：现在我们上课一边使用编辑器，一边使用录屏软件，同时还开着画图板，dos窗口等软件。此时，这些程序是在同时运行，”感觉这些软件好像在同一时刻运行着“。
实际上，CPU(中央处理器)使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。
其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

主线程： 执行主方法（main）的线程

单线程程序：Java程序中只有一个线程，执行从main方法开始，从上到下
主线程

4.3 创建线程类之一

Java使用 java.lang.Thread 类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。Java中通过继承Thread类来创建并启动多线程的步骤如下：

定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
创建Thread子类的实例，即创建了线程对象
调用线程对象的start()方法来启动该线程

第一种方法：
将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。

实现步骤：
1、创建一个Thread的子类（自定一个继承thread的类）。
2、在Thread的子类中重写run方法，设置线程任务（开启线程要做什么）。
3、创建Thread类的对象
4、调用Thread类中的start方法，开启新的线程，执行run方法

void start()
使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
结果是两个线程并发地运行；当前线程（main线程）和另一个线程（执行其 run 方法）。
多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动。（start完就没了，不能够继续start）

Java程序属于抢占式调度，哪个线程优先级高，哪个线程优先执行；同一个优先级，随机选择执行（优先级相等，谁线抢占cpu谁就先执行）。

Demo：

Thread的子类

public class Mythread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i <20 ; i++) {
            System.out.println("run:"+i);
        }
    }
}

测试类

public class MyThread_Demo {
    public static void main(String[] args) {
        Mythread run = new Mythread();
        run.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("main:"+i);
        }
    }
}

结果：main线程和run线程的执行顺序是随机的，不是固定的。
因为他们的线程优先级是一样的，所以抢占cpu资源的机会是平分的，谁先抢到了，谁就先执行。

六、线程、同步

目标：

能够描述Java中多线程运行原理
能够使用继承类的方式创建多线程
能够使用实现接口的方式创建多线程
能够说出实现接口方式的好处
能够解释安全问题的出现的原因
能够使用同步代码块解决线程安全问题
能够使用同步方法解决线程安全问题
能够说出线程6个状态的名称

1.1 多线程原理（结合上面的Demo代码）

多线程原理：随机打印的结果
-------------------------------------------------------------不明白？那就看一下详细的吧！----------------------------------------------------------------------------

Demo Code：
自定义类

public class MyThread extends Thread{
    /*
     * 利用继承中的特点
     * 将线程名称传递 进行设置
     */
    public MyThread(String name){
        super(name);
    }
    /*
     * 重写run方法
     * 定义线程要执行的代码
     */
    public void run(){
        for (int i = 0; i < 20; i++) {
//getName()方法 来自父亲
            System.out.println(getName()+i);
        }
    }
}

测试类

public class Demo {
	public static void main(String[] args) {
		System.out.println("这里是main线程");
		MyThread mt = new MyThread("小强");
		mt.start();//开启了一个新的线程
		for (int i = 0; i < 20; i++) {
		System.out.println("旺财:"+i);
		}
	}
}

流程图：
在这里插入图片描述
说明：
程序启动运行main时候，java虚拟机启动一个进程，主线程main在main()调用时候被创建。随着调用mt的对象的start方法，另外一个新的线程也启动了，这样，整个应用就在多线程下运行。

通过这张图我们可以很清晰的看到多线程的执行流程，那么为什么可以完成并发执行呢？我们再来讲一讲原理。
在这里插入图片描述
简易版本：

请注意mt.run（）与mt.start（）的区别。

1.2 Thread类之获取线程名称

Thread的子类

/*
    获取线程名称：
        1、使用THread类中的getName方法
         String getName() 返回该线程的名称。
        2、可以获取到当前正在执行的线程，使用线程中的方法getName()获取线程名称
        static Thread currentThread() 返回对当前正在执行的线程对象的引用。 
 */
//定义一个Thread的子类
public class Mythread extends Thread{
    //重写Thread中run方法，设置线程任务
    @Override
    public void run() {
        //获取线程名称
        //第一种：getName方法
        String name = getName();
        System.out.println(name);
        //第二种：currentThread静态方法
        Thread t = Thread.currentThread();//为什么可以使用类名调用该方法？因为是静态方法
        System.out.println(t);
        //第三种：链式编程
        System.out.println(Thread.currentThread().getName());//currentThread()返回的是线程对象的引用
                                                                //所以可以调用getName方法
    }

测试类

/*
    线程名称：
        主线程：main
        新线程：Thread-0、Thread-1、Thread-2
 */
public class MyThread_Demo {
    public static void main(String[] args) {
        //创建Thread子类的对象
        Mythread mt = new Mythread();
        //调用start方法，开启新线程，执行run方法
        mt.start();//Thread-1
        //使用匿名对象调用start
        new Mythread().start();//Thread[Thread-2,5,main]    //start一个就新创建一个线程
        new Mythread().start();//Thread[Thread-0,5,main]
        //第三种：链式编程
        System.out.println(Thread.currentThread().getName());
    }
}

1.2 Thread类之设置线程名称（了解）

Thread的子类

/*
    设置线程名称：（了解）
        1、使用Thread类中的方法setName（名字）
         void setName(String name) 改变线程名称，使之与参数 name 相同。
        2、创建一个带参构造方法，参数传递线程的名称；调用父类的带参构造方法，把线程名称传递给父类，让父类（Thread）给子子线程起一个名字
        Thread(String name) 分配新的 Thread 对象。
 */
public class Mythread extends Thread{
    //方法二：带参构造
    public Mythread(){
    };
    public Mythread(String name){
        super(name);
    };
    //方法一：
    @Override
    public void run() {
        System.out.println(getName());
    }
}

测试类

public class MyThread_Demo {
    public static void main(String[] args) {
        Mythread mt = new Mythread();
        // 方法一：开启线程
        mt.setName("小强");
        mt.start();
        //方法二：开启线程
        new Mythread("旺财").start();
    }
}

1.2 Thread类之常用方法

Thread常用方法
利用sleep方法制作秒表：

public class MyThread_Demo {
    public static void main(String[] args) {
        //模拟秒表
        for (int i = 1; i < 60; i++) {
            System.out.println(i);
            //使用Thread类的sleep方法让程序睡眠1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

1.3 创建线程之二（尽量使用）

采用 java.lang.Runnable 也是非常常见的一种，我们只需要重写run方法即可。
步骤如下：

定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。(也就是，让Runnable的实现类对象作为Thread的参数传递进去，这样的Thread才变成线程对象）
调用线程对象的start()方法来启动线程。

Runnable实现类

/*
    创建多线程程序的第二种实现方式：实现Runnable     (只有run方法)
     java.lang.Runnable
        Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参数方法。
     java.lang.Thread
        Thread(Runnable target) 分配新的 Thread 对象。
        Thread(Runnable target, String name) 分配新的 Thread 对象。
实现步骤：
    1-创建一个Runnable接口的实现类
    2-在实现类中重写Runnable接口的run方法，设置线程任务
    3-创建一个Runnable接口的实现类对象
    4-创建Thread类对象，构造方法中传递Runnable接口的实现类对象
    5-调用Thread类中的start方法，开启新的线程执行run方法
 */
public class RunnableDemo implements Runnable{  //1-创建一个Runnable接口的实现类
    //2-在实现类中重写Runnable接口的run方法，设置线程任务
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+"