最强码农笔记之Java线程全面知识点整理！

川长思鸟来 2021-07-24 12:20 216阅读 0赞

# 一、线程 #

## 1.基本概念 ##

> **程序（program）**：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

**进程（process）**

：是程序的一次执行过程，或是

正在运行的一个程序

。是一个动态的过程：有它自身的产生、存在和消亡的过程（生命周期）。

进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域。  
**线程（thread）**

：进程可以进一步细化为线程，是一个程序内部的一条执行路径。

**若一个进程同一时间并行执行多个线程，就是支持多线程的。**

线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器（pc），线程切换的开销小。  
一个进程中的多个线程共享相同的内存单元/内存地址空间 -->\]\\

它们从同一堆中分配对象，可以访问相同的变量和对象。

这就使得线程间的通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。  
单核CPU与多核CPU的理解：

单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。例如：有多车道，但收费站只有一个工作人员在收费，只有交了费才能通过，那么CPU就好比收费人员，如果某个人不想交钱，那么收费人员可以把他“挂起“（等他想通了准备好交钱再收费）。但是因为CPU时间单元特别短，因此感觉不出来。  
多核CPU，才能更好的发挥多线程的效率。  
一个Java应用程序java.exe，其实至少有三个线程：main() 主线程, gc() 垃圾回收线程， 异常处理线程。当然如果发生异常，会影响主线程。  
**并行与并发**

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

## 2.多线程的优点 ##

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

## 3.何时需要多线程 ##

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

## 4.线程的创建 ##

**方式一：继承于Thread类**  
创建一个继承于Thread类的子类  
重写Thread类的run方法 --> 将此线程执行的操作声明在run()中  
创建Thread类的子类的对象  
通过对象去调用start方法  
**Demo**

//1.创建一个继承于Thread类的子类
    class MyThread extends Thread { 
        //2.重写Thread类的run方法 --> 将此线程执行的操作声明在run()中
        @Override
        public void run() { 
            //该线程的功能
        }
    }//加入Java开发交流君样：756584822一起吹水聊天
    
    public class ThreadTest { 
        public static void main(String[] args) { 
            //3.创建Thread类的子类的对象
            MyThread t1 = new MyThread();
            //4.通过对象去调用start方法
            t1.sart();
        }
    }

注意：  
不能通过直接调用run()的方式启动线程（实质上只是方法的调用，单线程）  
不可让正在启动的线程去执行任何代码（报错IllegalThreadException）。需要重新创建新的线程对象。

**方式二：实现Runnable接口**

创建一个实现了Runnable接口的类  
实现类去实现Runnable中的抽象方法:run()  
创建实现类的对象  
将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象  
通过Thread类的对象调用start() (其实调用的是Runnable类型的target)  
Demo

//1,创建实现Runnable接口的类
    class Mthread implements Runnable { 
        @Override
        public void run() { 
            //2.重写Runnable中的抽象方法run()
        }
    }
    
    public class ThreadTest1 { 
        public static void main(String[] args) { 
            //3.创建实现类的对象
            MThread mThread = new MThread();
            //4.将该对象作为参数传给Thread类的构造器中，创建Thread类的对象
            Thread t1 = new Thread(mThread);
            //5,通过Thread类的对象调用start()
            t1.start();
        }
    }//加入Java开发交流君样：756584822一起吹水聊天

**方式一和二的对比**  
开发中优先考虑：实现Runnable接口的方式

原因：

实现的方式没有类的单继承性的局限性  
实现的方式更适合来处理多个线程有共享数据的情况  
其实Thread类本身就继承了Runnable接口，并内置重写了的run()。

**方式三：实现Callable接口**

与Runnable相比，Callable功能更强大一些  
相比run()方法，可以有返回值  
方法可以抛出异常  
支持泛型的返回值  
需要借助FutureTask类，比如获取返回结果  
FutureTask类  
实现了Runnable接口  
Demo

//1.创建一个实现Callable的实现类
    class NumThread implements Callable{ 
        //2.实现call方法，将此线程需要执行的操作声明在call()中
        @Override
        public Object call() throws Exception { 
            //返回100以内偶数和
            int sum = 0;
            for (int i = 0; i <= 100; i++) { 
                if (i % 2 == 0) { 
                    System.out.println(i);
                    sum += i;
                }//加入Java开发交流君样：756584822一起吹水聊天
            }
            return sum;//这里将int自动装箱为Integer,而Integer类为Object类的子类
        }
    }
    
    public class ThreadNew { 
        public static void main(String[] args) { 
            //3.创建Callable接口实现类的对象
            NumThread numThread = new NumThread();
            //4.将此对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
            FutureTask futureTask = new FutureTask(numThread);
            //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread类的对象,并调用start方法
            //启动线程
            new Thread(futureTask).start();
            
            try { //加入Java开发交流君样：756584822一起吹水聊天
                //6.获取Callable中call方法的返回值（看需求）
                //get方法获取的返回值即为FutureTask构造器参数Callable实现类重写的call方法的返回值
                Object sum = futureTask.get();
                System.out.println("总和为" + sum);
            }catch (InterruptedException e) { 
                e.printStackTrace();
            }catch (ExecutionException e) { 
                e.printStackTrace();
            }
        }
    }

# 二、Thread类的有关方法 #

void start() : 启动线程，并执行对象的run()方法  
run() : 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中  
String getName() : 返回线程的名称  
void setName(String name) : 设置该线程名称  
static Thread.currentThread() : 返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类  
yield() : 释放当前cpu的执行权  
join() : 在线程a中调用线程b的线程join()，此时线程a进入阻塞状态，直到线程b完全执行完后，线程a才能结束阻塞状态。  
stop() : 已过时。强制结束当前线程。  
sleep(long millitime) : 让当前线程“睡眠”值定的millitime毫秒。在指定的millitime毫秒内，当前线程时阻塞状态。  
isAlive() : 判断当前线程是否存活（返回值为boolean）

# 三、线程的调度 #

时间片：![在这里插入图片描述][20210518221315446.png]

抢占式：高优先级的线程抢占CPU  
Java的调度方法  
同优先级线程组成先进先出队列（先到先服务），使用时间片策略  
对高优先级，使用优先调度的抢占式策略

## 2. 线程的优先级 ##

默认配置：

MAX\_PRIORITY:10  
MIN\_PRIORITY:1  
NORM\_PRIORITY:5  
设置操作

线程对象名.getPriority()

获取线程优先级

线程对象名.setPriority()

设置线程优先级

优先级理解

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

# 四、线程的状态 #

在Java程序中，一个线程对象只能调用一次start()方法启动新线程，并在新线程中执行run()方法。一旦run()方法执行完毕，线程就结束了。因此，Java线程的状态有以下几种：

New：新创建的线程，尚未执行；  
Runnable：运行中的线程，正在执行run()方法的Java代码；  
Blocked：运行中的线程，因为某些操作被阻塞而挂起；  
Waiting：运行中的线程，因为某些操作在等待中；  
Timed Waiting：运行中的线程，因为执行sleep()方法正在计时等待；  
Terminated：线程已终止，因为run()方法执行完毕。

# 五、线程安全 #

synchronized关键字  
修饰代码块，需要有全局所对象  
修饰方法，修饰static关键字的方法锁对象为"类.class"，修饰非static关键字的方法锁对象为”this“即当前对象  
Lock类手动加锁，可手动对需要进行线程安全限制的代码块进行加锁与解锁，操作灵活

最后，祝大家早日学有所成，拿到满意offer，快速升职加薪，走上人生巅峰。

[20210518221315446.png]: /images/20210724/56430c9b8fd14fa9a4275d6fa9c8f480.png