Java中的线程

一、概述进程与线程

进程：就是正在运行的程序。
进程是系统进行资源分配和调用的独立单位。每一个进程都有它自己的内存空间和系统资源。

意义：单进程的计算机只能做一件事情，而我们现在的计算机都可以做多件事情。举例：一边玩游戏(游戏进程)，一边听音乐(音乐进程)。也就是说现在的计算机是支持多进程的，以在一个时间段内执行多个任务，并且，可以提交CPU的使用率。

线程：是程序的执行单元，执行路径。是程序使用CPU的最基本单位。
单线程：如果程序只有一条执行路径。
多线程：如果程序有多条执行路径。

意义：多线程的存在，不是提高程序的执行速度。其实是为了提高应用程序的使用率。程序的执行其实都是在抢CPU的资源，CPU的执行权。多个进程是在抢这个资源，而其中的某一个进程如果执行路径比较多，就会有更高的几率抢到CPU的执行权。是不敢保证哪一个线程能够在哪个时刻抢到，所以线程的执行有随机性。

二、线程的理解

1、线程的两种调度模型

（1）分时调度模型

所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间戳

（2）抢占式调度模型

优先让优先级高的线程使用CPU，若果线程的优先级相同，那么会随机选择一个，优先级搞的线程获取的CPU时间戳相对多一些

Java使用的是抢占式的调度模型

2、线程的生命周期

三。线程的创建方式

（1）继承Thread类。

步骤：
 A:自定义类MyThread继承Thread类。
B:MyThread类里面重写run()?
C:创建对象
D:启动线程

/*
 * 该类要重写run()方法,为什么呢?
 * 不是类中的所有代码都需要被线程执行的。
 * 而这个时候，为了区分哪些代码能够被线程执行，java提供了Thread类中的run()用来包含那些被线程执行的代码。
 */
public class MyThread extends Thread {

    @Override
    public void run() {
        // 一般来说，被线程执行的代码肯定是比较耗时的。所以我们用循环改进
        for (int x = 0; x < 200; x++) {
            System.out.println(x);
        }
    }
}

public static void main(String[] args) {
    // 面试题：run()和start()的区别?
    // run():仅仅是封装被线程执行的代码，直接调用是普通方法
    // start():首先启动了线程，然后再由jvm去调用该线程的run()方法。
    // 创建两个线程对象
    MyThread my1 = new MyThread();
    MyThread my2 = new MyThread();

    my1.start();
    my2.start();
}

Thread类的一些方法：

如何获取线程对象的名称呢?
public final String getName():获取线程的名称。
如何设置线程对象的名称呢?
public final void setName(String name):设置线程的名称

针对不是Thread类的子类中如何获取线程对象名称呢?
public static Thread currentThread():返回当前正在执行的线程对象
Thread.currentThread().getName()

public final void setDaemon(boolean on):将该线程标记为守护线程或用户线程。
当正在运行的线程都是守护线程时，Java 虚拟机退出。 该方法必须在启动线程前调用。

public final void join():等待该线程终止。

public static void yield():暂停当前正在执行的线程对象，并执行其他线程。

public final void stop():让线程停止，过时了，但是还可以使用。
public void interrupt():中断线程。 把线程的状态终止，并抛出一个InterruptedException。

public static void sleep(long millis) 线程休眠

如何获取线程对象的优先级?
public final int getPriority():返回线程对象的优先级
如何设置线程对象的优先级呢?
public final void setPriority(int newPriority)：更改线程的优先级。
注意：
线程默认优先级是5。
线程优先级的范围是：1-10。
线程优先级高仅仅表示线程获取的 CPU时间片的几率高，但是要在次数比较多，或者多次运行的时候才能看到比较好的效果。

（2）实现Runnable接口

步骤：
A:自定义类MyRunnable实现Runnable接口
B:重写run()方法
C:创建MyRunnable类的对象
D:创建Thread类的对象，并把C步骤的对象作为构造参数传递

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        for (int x = 0; x < 100; x++) {
            // 由于实现接口的方式就不能直接使用Thread类的方法了,但是可以间接的使用
            System.out.println(Thread.currentThread().getName() + ":" + x);
        }
    }

}

　　public static void main(String[] args) {
        // 创建MyRunnable类的对象
        MyRunnable my = new MyRunnable();

        // 创建Thread类的对象，并把C步骤的对象作为构造参数传递
        // Thread(Runnable target)
        // Thread t1 = new Thread(my);
        // Thread t2 = new Thread(my);
        // t1.setName("林青霞");
        // t2.setName("刘意");

        // Thread(Runnable target, String name)
        Thread t1 = new Thread(my, "林青霞");
        Thread t2 = new Thread(my, "刘意");

        t1.start();
        t2.start();
    }

实现Runnable接口的好处：

（1）可以避免由于Java单继承带来的局限性

（2）适合多个相同的程序去处理同一个资源的情况，把线程同程序的代码，数据有效的分离，较好的提现了面向对象的设计思想

经典的值得思考的简单代码：（2019-05-27 21:48:00 继续写）

// 大体结构是这样的： 创建Thread对象：new Thread(创建Runnable对象：new Runnable(){ 执行Runnable的run()方法 }){ 执行Thread的run()方法 }.start(); 执行start方法
new Thread(new Runnable(){
            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("Runnable:" + Thread.currentThread().getName());
                }
            }
            
        }){
            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("Thread:" + Thread.currentThread().getName());
                }
            };
            
        }.start();

之所以说这个例子比较经典，是因为你要搞懂这个到底在运行哪个run()方法，其实是在执行Thread类的run()方法，因为这个是重写Thread类的run()方法，只有在没有重写Thread类的run()方法的时候，才会去执行父类的run()方法，可以看下Thread类的源码：

 private Runnable target;
   
 @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }