Java笔记-多线程之多线程的创建使用，获取和修改名字，线程优先级

线程概述

计算机的操作系统采用多任务和分时设计，多任务是指在一个操作系统中可以同时运行多个程序。例如，可以在使用QQ聊天的同时听音乐，即有多个独立运行的任务，每个任务对应一个进程，每个进程也可产生多个线程。

进程

几乎所有的操作系统都支持进程的概念，所有运行中的任务通常对应一个进程（Process）。当一个程序进入内存运行时，即变成了一个进程。进程是处于运行过程中的程序，并且具有一定的独立功能，进程是系统进行资源分配和调度的一个独立单位。
进程的3个特征：

1. 独立性：进程是系统中独立存在的实体，它可以拥有自己独立的资源，每一进程都拥有自己私有的内存地址。在没有经过进程本身允许的情况下，一个用户进程不可以直接访问其他进程的地址空间。
2. 动态性：进程与程序的区别在于, 程序只是一个静态的指令集合，而进程是一个正在系统中活动的指令集合。在进程中加入时间的概念。进程具有自己的生命周期和各种不同的状态，这些概念在程序中都是不具备的。
3. 并发性：多个进程可以在单个处理器上并发执行，多个进程之间不会互相影响。

注：并发性和并行性是两个概念，并行指在同一个时刻，有多条指令在多个处理器上同时执行；并发指的是同一时刻只能有一条指令执行，但多个进程指令被快速来回切换执行，使得在宏观上具有多个进程同时执行的效果。

多线程的优点：
线程在程序中是独立的，并发的执行流，与分隔的进程相比，进程中线程之间的隔离程度小。它们共享内存，文件句柄和其他进程应用的状态。
因为线程的划分尺度小于进程，使的多线程程序的并发行高。进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大的提高了程序的运行效率。
线程比进程具有更高的性能，这是同一个进程中的线程都有共性——多个线程共享同一个进程虚拟空间。线程共享的环境包括：进程代码段，进程中的公有数据等。利用这些共享的数据，线程之间很容易实现相互之间的通信。
当操作系统创建一个进程时，必须为该进程分配独立的内存空间，并分配大量的相关资源；但创建一个线程则简单的多。因此使用多线程来实现并并发比使用多进程实现并发效率高很多。
总结：多线程编程的几个优点：

1. 进程之间不能共享内存，但线程之间共享内存非常容易。
2. 系统创建进程时需要为该进程重新分配系统资源，但创建线程则代价小的多。因此使用多线程来实现多任务并发比多进程效率高。

---

在Java中实现多线程

Java 在类和接口方面为多线程提供内置支持。Java 通过 Thread 类将线程所必须的功能都封装了起来。

Thread 类及其常用方法

java.lang.Thread类支持多线程编程，该类提供了大量的方法来控制和操作线程。常用方法如下表所示：

方法名称	说明
Thread()	分配新的 Thread 对象
Thread(Runnable target)	分配新的 Thread 对象，target 为 run()方法被调用的对象
Thread(Runnable target, String name)	分配新的 Thread 对象，target 为 run()方法被调用的对象，name 为新线程的名称
void run()	执行任务操作的方法
void start()	使该线程开始执行，Java 虚拟机调用该线程的run()方法
void sleep(long millis)	在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）
String getName()	返回线程的名称
int getPriority()	返回线程的优先级
void setPrority(int newPriority)	更改线程的优先级
static Thread currentThread()	返回当前正在执行的线程对象的引用
boolean isAlive()	测试线程是否处于活动状态
void join()	等待该线程终止
void interrupt()	中断线程
void yield()	暂停当前正在执行的线程对象，并执行其他线程

主线程

在 Java 程序启动时，一个线程立刻运行，该线程通常称为程序的主线程。 Java 程序中的 public static void main()方法是主线程的入口，每个进程都至少有一个主线程。它是程序开始时就执行的。主线程的重要性体现在以下两个方面：

• 它是产生其他子线程的线程。
• 通常它必须最后完成执行，因为它执行各种关闭操作。

尽管主线程在程序启动时自动创建，但它可以由一个 Thread 对象控制。为此，需要调用方法 currentThread()获得它的一个引用，currentThread()方法是 Thread 类的公有的静态成员。它的通常形式如下：

static Thread currentThread()

该方法返回一个调用它的线程的引用。一旦获得主线程的引用，就可以像控制其他线程那样控制主线程。

控制主线程代码如下：

public static void main(String[] args) {
    Thread t = Thread.currentThread();
    System.out.println("当前线程名称:" + t.getName());
    //修改主线程名称
    t.setName("MyFirstThread");
    System.out.println("修改后的线程名称:" + t.getName());
}
//运行结果：
//当前线程名称:Thread-0
//修改后的线程名称:MyFirstThread

---

Java线程的创建和启动

Java使用Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段顺序的程序流。

---

继承Thread类来创建线程类

public class FirstThread extends Thread {
    //重写run()方法
    @Override
    public void run() {
        super.run();
        // 线程执行体...
    }

    public static void main(String[] args) {
        FirstThread firstThread = new FirstThread();
        System.out.println("当前线程名称:" 
            + firstThread.getName());
        firstThread.setName("MyFirstThread");
        System.out.println("修改后的线程名称:" 
            + firstThread.getName());
        firstThread.start();
    }
}
//运行结果：
//当前线程名称:Thread-0
//修改后的线程名称:MyFirstThread

---

实现Runnable接口创建线程类

public class SecondThread implements Runnable {
    @Override
    public void run() {
        //线程执行体...
    }

    public static void main(String[] args){
        SecondThread target=new SecondThread();
        //Runnable对象作为Thread的target
        Thread thread=new Thread(target);
        thread.start();
    }
}

---

使用Callable和Future创建线程

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class ThirdThread implements Callable<String> {
    @Override
    public String call() throws Exception {
        // 线程执行体..
        return "A";
    }

    public static void main(String[] args) {
        try {
            ThirdThread thirdThread = new ThirdThread();
            FutureTask<String> task = new FutureTask(thirdThread);
            // 将构建的FutureTask作为target传入Thread中
            new Thread(task).start();
            // 获取线程执行的返回值
            System.out.println(task.get());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

---

三种Java线程创建方式的对比：

尽量采用实现Runable，Callable接口的方式创建多线程

优点：

1. 线程类只是实现了Runable接口或者Callable接口，还可以继承其他类，可以避免由于Java单继承带来的局限性。

2. 这种方式下，多个线程可以共享一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU，代码和数据分开，形成清晰的模型，较好的体现了面向对象的思想。

---

获取和设置线程名字

getName()方法：获取线程名字
setName()方法：设置线程名字

1.可以在run()方法中设置线程名字
2.可以在MyThread.java（子线程）类的构造方法中，设置线程名字。

演示代码如下：

1.MyThread.java

public class MyThread extends Thread {
    public MyThread() {
    }

    // 构造器设置线程名字
    public MyThread(String name) {
        super(name);
    }

    // run()方法获取线程名字
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("我是---->" + getName() + ":" + i);
        }
    }
}

2.Test.java

public class Test {
    public static void main(String[] args) {
        MyThread t = new MyThread("刘备");
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        //设置线程名字
        t1.setName("关羽");
        t2.setName("张飞");
        t.start();
        t1.start();
        t2.start();
    }
}

---

线程调度（线程优先级）

线程有两种调度模型：

• 分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片。

• 抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些。

---

问：假如我们的计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到 CPU时间片，也就是使用权，才可以执行指令。那么Java是如何对线程进行调用的呢？

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

---

演示如何设置和获取线程优先级

final int getPriority()：获取线程优先级
final void setPriority(int newPriority)：设置线程优先级，1到10，默认5。

演示代码如下：

1.MyThread.java

public class MyThread extends Thread {
    public MyThread() {
    }

    // 构造器设置线程名字
    public MyThread(String name) {
        super(name);
    }

    // run()方法获取线程名字
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("我是---->" + getName() + ":" + i);
        }
    }
}

2.Test.java

public class Test {
    public static void main(String[] args) {
        MyThread t1 = new MyThread("张飞");
        MyThread t2 = new MyThread("关羽");
        // 设置线程优先级:1到10,必须在范围内
        t2.setPriority(10);
        t1.setPriority(1);
        // 获取线程优先级
        // 主线程优先级 也是线程的默认值5。
        System.out.println(Thread.currentThread().getPriority());
        // 两个子线程优先级
        System.out.println(t1.getPriority());
        System.out.println(t2.getPriority());
        t1.start();
        t2.start();
    }
}

注意：由于线程执行有随机性，所以一两次执行不代表正确效果

优先级高的只是获得的时间片更多一些，而不是全部。

---

常见问题

---

问：java程序运行默认是有几个线程？单线程还是多线程？

答：JVM运行时，最少启动两个线程：main线程(主线程)，GC（垃圾回收）线程。所以是多线程。

---

一个java程序只有一个主线程 其他开启的都是子线程。

---

问：如何定义一个线程？

答：
1.找一个类继承Thread类，或者，采用实现Runable、Callable接口的方式创建多线程，覆写run()方法，run()方法里面写的就是子线程要运行的代码。

---

问：子线程中覆写的run()方法中一般写一些什么？

答：一般在子线程代码会写一个耗时操作，或者，长循环，也就是比较复杂的算法代码。

---

问：启动线程是哪一个方法，start()还是run()？

答：是start()启动线程。

---

问：run()和start()的区别？

答：
start()：使该线程开始执行；Java 虚拟机调用该线程的 run 方法。

run()：调用run方法，就是new普通对象，然后在main方法中，普通对象调用普通方法，单线程运行。

---

问：线程能不能多次启动？

答：同一个线程对象一辈子只能start()一次。

如果多次start()将报错：IllegalThreadStateException—非法线程状态异常：

常见于一个线程对象start两次。

---