【无标题】

线程

基本概念：程序，进程，线程

程序(program)：为了完成特定的任务，用某种语言编写的一系列指令的集合，即一段静态的代码，静态对象。

进程(process):是程序的一个执行过程，或是正在运行的一个程序，是一个动态的过程，有它自身的产生，存在和消亡的过程。----生命周期。

• 程序是静态的，进程是动态的
• 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域。

线程(thread):进程可进一步细化为线程，是一个程序内部的执行路径

• 若一个进程同一时间并行多个线程，就是支持多线程的
• 线程作为调度和执行的单位，每一个线程拥有独立的运行栈和程序计数器，线程切换的开销小。
• 一个进程中的多个线程共享相同的内存单元/内存地址空间->他们从同一堆中分配对象，可以访问相同的变量和对象，这就使得线程间的通信更加简便，高效，但是多个线程操作共享的系统资源可能就会带来安全的隐患。

补充

单核CPU和多核CPU的理解、

单核CPU：单核CPU是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。但是，因为CPU时间单元特别短，所以感觉不出来。

多核CPU:如果是多核的话，才能更好的发挥出CPU的效率（现在的服务器都是多核的）。

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

并行与并发

并行：多个CPU同时执行多个任务。

并发：一个CPU（采用时间片的形式）同时执行多个任务

使用多线程的优点

以单核CPU为例，只使用单个线程先后完成多个任务（调用多个方法），肯定比使用多个线程完成任务要用的时间短，为何仍需要多线程呢？

多线程优点

1.提高了应用程序的响应，对图形化界面更加有意义，可增强用户体验

2.提高了计算机系统CPU的利用率

3.改善程序结构，将既长又复杂的进程分为多个线程，独立运行，利于理解和修改

何时需要多线程：

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

线程的创建和启动

方式一：

继承于Thread类

步骤：1.创建一个Thread的子类

2.重写Thread的run（）方法，将此线程执行的操作声明在run()中

3.创建Thread的子类的对象

4.根据Thread的子类的对象调用start()方法

public class ThreadTest {
    public static void main(String[] args) {
        myThread i=new myThread();//3.创建Thread的子类的对象
        i.start();//4.根据Thread的子类的对象调用start()方法
        System.out.println("hello");

    }
}
class myThread extends Thread{//1.创建一个Thread的子类
    @Override
    public void run() {//2.重写Thread的run（）方法，将此线程执行的操作声明在run()中
        for (int i = 0; i < 100; i++) {
            System.out.println(i);
        }
    }
}

注意：

一，start()作用：1.启动当前线程2.调用当前线程的run()

我们不能通过直接调用run()的方式启动线程

二，再启动一个线程时，遍历100以内的偶数，不可以让已经start（）的线程去执行，会报错。需要再新建一个对象，通过他去调用start()来启动一个新的线程

方式二：

（实现Runnable接口方法）

步骤：

1.创建了一个实现了Runnable接口的实现类。

2.实现类去实现Runnable中的抽象方法，run()。

3.创建实现类的对象。

4.将实现类的对象作为参数传递给Thread类的构造器,创建Thread类的对象。

5.通过Thread类的对象调用start()方法.

public class ThreadTest2 {
    public static void main(String[] args) {
        myThread2 yThread2 = new myThread2();//3.创建实现类的对象。
        Thread thread = new Thread(yThread2);//4.将实现类的对象作为参数传递给Thread类的构造器,创建Thread类的对象。
        thread.start();//5.通过Thread类的对象调用start()方法.
        for (int i = 0; i <100 ; i++) {
            if(i%2==1)
                System.out.println(i);
        }
    }
}
class myThread2 implements Runnable{//1.创建了一个实现了Runnable接口的实现类。
    @Override
    public void run() {//2.实现类去实现Runnable中的抽象方法，run()。
        for (int i = 0; i <100 ; i++) {
            if(i%2==0)
                System.out.println(i);

        }
    }
}

方式三：

实现callable接口

与使用Runnable相比，callable功能更加强大些

相比Run（）方法，可以有返回值

方法可以抛出异常

支持泛型的返回值

需要借助FutureTask类，比如获取返回结果

步骤：

①创建一个实现callable的实现类

②实现call方法，将此线程需要执行的操作声明在call方法中

③创建Callable实现类的对象

④将次实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象

⑤将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread类的方法，并调用start（）

⑥获取call方法中的返回值（有必要时使用该步骤）

方式四：

使用线程池

背景：经常创建和销毁，使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁，实现重复利用。类似于生活中的公共交通工具。

好处：

①提高响应速度(减少了创建新线程的时间)

②降低了资源消耗（重复利用线程池中线程，不需要每次都创建）

③便于线程管理

​ corePoolSize：核心池大小

​ maximumPoolSize：最大线程数

​ keepAliveTime：线程没有任务时最多可保持多长时间后会终止

线程池相关的API：ExecutorService和Executors

ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor

​ void execute（Runnable command）：执行任务、命令，没有返回值，一般用来执行Runnable

​ Futuresubmit(Callabletask):执行任务，有返回值，一般又来执行CAllable

​ void shutdown（）：关闭连接池

Executors:工具类，线程池的工厂类，用于创建并返回不同类型的线程池

​ Executors.newAcchedThreadPoll（）：创建一个可根据需要创建新线程的线程池

​ Executors.newFixedThreadPool（n）:创建一个可重用固定线程数的线程池

​ Executors.newSingleThreadExecutor（）：创建一个只有一个线程的线程池

​ Executors.newscheduledThreadPoll (n):创建一个线程池，它可安排在给定延迟后运行命令或者定期的执行

步骤

①提供指定线程数量的线程池

②执行指定的线程的操作，需要提供实现Runnable接口或者Callable接口实现类的对象（execute方法适合适用于Runnable，submit方法适用于Callable方法）

③关闭连接池

线程的生命周期

JDK中用Thread.State类定义了线程的几种状态

要想实现多线程，必须在主线程中创建新的线程对象。JAVA语言使用Thread类及其子类的对象来表示线程，在他的一个完整的生命周期中通常需要经历如下的五种状态：

新建：当一个Thread类或者其子类的对象被声明或创建时，新生的线程对象处于新建状态。

就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时他已经具备了运行的条件，只是没有分配到CPU资源。

运行：当就绪的线程被调度并获得CPU资源时，便进入运行状态，run()方法定义了线程的操作和功能。

阻塞：当某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态。

死亡：线程完成了他的全部工作或者线程被提前强制性的中止或者出现异常导致结束。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9oLV5hC3-1662997098579)(C:\Users\tcgr\AppData\Roaming\Typora\typora-user-images\image-20220823113243399.png)]

线程的同步

线程的安全问题

• 分析问题：在多线程程序中，很容易发生两个或者多个线程抢占资源的问题，如：两个人同时说话，两个人买到了同一张票。

• 问题发生的原因：当某个线程正在操作(尚未完成操作)的时候，其他线程参与进来，也来操作

• 解决问题的办法：当一个线程a在操作的时候，其他线程不能参与进来，直到线程a操作完的时候，其他线程才可以继续操作，这红情况即使线程a出现了阻塞，也不会继续发生问题。

在JAVA中，我们通过线程的同步机制来解决线程的安全问题

你觉得线程的同步机制是什么呢？

方式一（同步代码块）

synchronized(同步监视器){

//需要同步的代码

}

说明：1.操作共享数据的代码，即为需要被同步的代码

​ 2.共享数据：多个线程共同操控的变量。比如：车票售票系统中的车票就是共享数据

​ 3.同步监视器：俗称：锁（任何类的对象都可以充当锁）。

​ 4.在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器

​ 5.在实现Runnable接口创建多线程的方式中，我们可以考虑使用this来充当同步监视器

​ 要求：多个线程必须要公用同一把锁

方式二（同步方法）

如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。

关于同步方法的总结：

1.同步方法仍然涉及到同步监视器，只是不需要我们显式的声明

2.非静态的同步方法，同步监视器是：this(当前对象)

​ 静态的同步方法，同步监视器是：当前类本身