Java之多线程

一、程序、进程、线程

1. 程序(program)
概念：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码。

2. 进程(process)
概念：程序的一次执行过程，或是正在运行的一个程序。 说明：进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域

3. 线程(thread)
概念：进程可进一步细化为线程，是一个程序内部的一条执行路径。 说明：线程作为调度和执行的单位，每个线程拥独立的运行栈和程序计数器(pc)，线程切换的开销小。

内存结构：

进程可以细化为多个线程。 每个线程，拥有自己独立的：栈、程序计数器 多个线程，共享同一个进程中的结构：方法区、堆。

二、并行与并发

1. 单核CPU与多核CPU
1.单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。涉及到CPU处理线程的方式，CPU在单位时间（也就是说一个时间片内）内只能处理一个线程，于是就将其他的线程设置为阻塞状态，加入到阻塞队列中，等到处理完成当前线程后从就绪队列中取出新的线程进行处理，由于切换和处理时间很快用户感知不到于是用户便认为CPU在同一时间内处理多个线程。

2.多核CPU，才能更好的发挥多线程的效率。（现在的服务器都是多核的）;

3.一个Java应用程序java.exe，其实至少三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

2. 并行与并发的理解

并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。

并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事;

为什么要使用多线程？
当我们在进行商品抢购的时候，在支付按钮上总是有个计时器在进行倒计时，但是我们此时仍然可以进行商品信息的查看，这个计时器和我们浏览商品信息的线程是同时进行的，这样也就实现了抢购场景，增加了用户的体验。

多线程程序的优点：
1.提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
2.提高计算机系统CPU的利用率。
3.改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改。

应用的场景
1.程序需要同时执行两个或多个任务。
2.程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等;
3.需要一些后台运行的程序时;

三、Thread类

Java语言的JVM允许程序运行多个线程，它通过 java. lang.Thread类来体现

1. Thread类的特性
每个线程都是通过某个特定 Thread对象的run（方法来完成操作的，经常把run()方法的主体称为线程体 通过该 Thread对象的 start（方法来启动这个线程，而非直接调用run

2. 构造器：
Thread()：创建新的 Thread对象;
Thread（String threadName）：创建线程并指定线程实例名;
Thread（Runnable target）：指定创建线程的目标对象，它实现了 Runnable接口中的run方法;
Thread（Runnable target， String name）：创建新的 Thread对象;

3. 创建多线程的两种方式
3.1. 方式一继承Thread类的方式：

1.创建一个继承于Thread类的子类;
2.重写Thread类的run() --> 将此线程执行的操作声明在run()中;
3.创建Thread类的子类的对象;
4.通过此对象调用start()：①启动当前线程 ② 调用当前线程的run();

注意点：

1.我们启动一个线程，必须调用start()，不能调用run()的方式启动线程。 如果再启动一个线程，必须重新创建一个Thread子类的对象，调用此对象的start().（注意后面的点）
2.如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程 模式
3.run（方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU调度决定。
4.想要启动多线程，必须调用 start方法。
5.一个线程对象只能调用一次 start()方法启动，如果重复调用了，则将 抛出异常“lllegalThreadStateException”.

代码示例

//1.继承Thread类
class MyThread extends Thread {
   
    public MyThread() {
   
    }

    //2.重run方法
    @Override
    public void run() {
   
        for (int i = 0; i < 100; i++) {
   
            if (i % 2 == 0) {
   
                System.out.println(i);
            }
        }
    }
}

public class ThreadTest {
   
    public static void main(String[] args) {
   
//3.新建Thread对象
        MyThread myThread = new MyThread();
        //4.调用start方法
        myThread.start();
    }
}

3.2. 方式二实现Runnable接口的方式：

1.创建一个实现了Runnable接口的类;
2.实现类去实现Runnable中的抽象方法：run();
3.创建实现类的对象;
4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象;
5.通过Thread类的对象调用start();

代码示例：

//1. 创建一个实现了Runnable接口的类
public class RunnableTest implements Runnable {
   
    // 2. 实现类去实现Runnable中的抽象方法：run()
    @Override
    public void run() {
   
        for (int i = 0; i < 100; i++) {
   
            System.out.println(i);
        }
    }
}

class test {
   
    public static void main(String[] args) {
   
        //3. 创建实现类的对象
        RunnableTest runnableTest = new RunnableTest();
        //4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread thread = new Thread(runnableTest);
        //5. 通过Thread类的对象调用start()
        thread.start();

    }
}

两种方式的对比：

开发中优先选择：实现Runnable接口的方式

原因：

1. 实现的方式没类的单继承性的局限性

​ 2. 实现的方式更适合来处理多个线程共享数据的情况。

**联系：**public class Thread implements Runnable

**相同点：**两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。 目前两种方式，要想启动线程，都是调用的Thread类中的start()。

也可以采用创建匿名类的方式

public class ThreadDemo {
   
    public static void main(String[] args) {
   

        //创建Thread类的匿名子类的方式
        new Thread() {
   
            @Override
            public void run() {
   
                for (int i = 0; i < 100; i++) {
   
                    if (i % 2 == 0) {
   
                        System.out.println(Thread.currentThread().getName() + ":" + i);
                    }
                }
            }
        }.start();

        new Thread() {
   
            @Override
            public void run() {
   
                for (int i = 0; i < 100; i++) {
   
                    if (i % 2 != 0) {
   
                        System.out.println(Thread.currentThread().getName() + ":" + i);
                    }
                }
            }
        }.start();


    }
}

4. Thread类的常用方法

4.1 常用方法：

1.start():启动当前线程；调用当前线程的run()，只有Thread类和他的子类才能调用start()方法;

2.run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中;

3.currentThread():静态方法，返回执行当前代码的线程;

4.getName():获取当前线程的名字;

5.setName():设置当前线程的名字;

6.yield():释放当前cpu的执行权;

7.join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。

8.stop():已过时。当执行此方法时，强制结束当前线程。

9.sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。

10.isAlive():判断当前线程是否存活;

4.2 线程的优先级：

MAX_PRIORITY：10
MIN _PRIORITY：1
NORM_PRIORITY：5 -->默认优先级

获取和设置当前线程的优先级：
1.getPriority():获取线程的优先级;
2.setPriority(int p):设置线程的优先级;

说明：高优先级的线程要抢占低优先级线程CPU的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下被执行。并不意味着只当高优先级的线程执行完以后，低优先级的线程才执行。

线程通信：wait() / notify() / notifyAll() :此三个方法定义在Object类中的。

线程的分类

1.守护线程，如：垃圾回收线程，依赖于主线程而存在
2.用户线程，如：main方法的线程

5. Thread的生命周期

线程的五种状态：

1.新建：当一个 Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态;
2.就绪：处于新建状态的线程被star()后