java底层基础-java多线程

悠悠 2023-01-02 04:26 113阅读 0赞

## 一、简介 ##

### 1. 程序 ###

程序，是管理方式的一种，是能够发挥出协调高效作用的工具

### 2. 进程 ###

#### 2.1 概念 ####

指在系统中正在运行的一个应用程序，程序一旦运行就是进程；  
进程——资源分配的最小单位；  
有独立的内存空间；  
进程不依赖于线程而独立存在，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程

#### 2.2 特征 ####

动态性：进程是程序的一次执行过程，是临时的，有生命期的，是动态产生，动态消亡的；  
并发性：任何进程都可以同其他进行一起并发执行；  
独立性：进程是系统进行资源分配和调度的一个独立单位；  
结构性：进程由程序，数据和进程控制块三部分组成

#### 2.3 进程与程序的区别 ####

*  进程是动态的，程序是静态的  
    程序是有序代码的集合  
    进程是程序的执行，进程有核心态/用户态
 *  进程是暂时的，程序是永久的  
    进程是一个状态变化的过程  
    程序可长久保存
 *  进程与程序组成不同  
    进程的组成包括程序，数据和进程控制块

### 3. 线程 ###

#### 3.1 概念 ####

是系统分配处理器时间资源的基本单元，或者说是进程之内独立执行的一个单元执行流。  
线程——程序执行的最小单位；  
一个进程中可以运行多个线程。比如java.exe进程中可以运行很多线程。  
线程总是属于某个进程，线程没有自己的虚拟地址空间，与进程内的其他线程一起共享分配给该进程的所有资源

#### 3.2 特征 ####

易于调度。  
提高并发性。通过线程可方便有效地实现并发性。进程可创建多个线程来执行同一程序的不同部分。  
开销少。创建线程比创建进程要快，所需开销很少。  
利于充分发挥多处理器的功能。通过创建多线程进程（即一个进程可具有两个或更多个线程），每个线程在一个处理器上运行，从而实现应用程序的并发性，使每个处理器都得到充分运行。

#### 3.3 线程与进程的区别 ####

*  进程=线程+内存+文件/网络句柄（线程是进程的一部分）
 *  进程有独立的内存空间，线程没有自己的内存空间
 *  进程是资源分配的最小单位，线程是程序执行的最小单位
 *  进程之间相互独立，同一个进程下的各个线程之间共享程序的内存空间
 *  线程上下文切换比进程上下文切换要快的多

#### 3.4 为什么不实用多进程而使用多线程 ####

线程廉价，启动比较快退出比较快，对系统资源的冲击比较小

## 二、线程创建和启动 ##

### 1. 线程实现的方式（三种） ###

#### 实现Runnable 接口 ####

实现Runnable接口并重写run()方法，run方法中是线程的执行体。创建runnable实现类的实例，并以此实例作为Thread类的target来创建Thread对象，该Thread对象才是真正的线程对象。

public class RunnableTest1 implements Runnable { 
        	String name;
        	public RunnableTest1(String name) { 
        		this.name = name;
        	}
        	@Override
        	public void run() { 
        		for (int i = 0; i < 10; i++) { 
        			System.out.println(name + " " + i);
        		}
        	}
        	public static void main(String[] args) { 
        		RunnableTest1 run1 = new RunnableTest1("线程1");
        		RunnableTest1 run2 = new RunnableTest1("线程2");
        		Thread thread1 = new Thread(run1);
        		Thread thread2 = new Thread(run2);
    			
        		thread1.start();
        		thread2.start();
        	}
    	}

#### 继承Thread类 ####

继承Thread类，通过重写run()方法定义了一个新的线程类MyThread,run()方法时线程执行体。

public class ThreadTest1 extends Thread { 
    		private String name;
        	ThreadTest1(String name) { 
        		this.name = name;
        	}
        	@Override
        	public void run() { 
        		for (int i = 0; i < 10; i++) { 
        			System.out.println(name + " " + i);
        		}
        	}
        	public static void main(String[] args) { 
        	    ThreadTest1 th1 = new ThreadTest1("线程1");
        	    ThreadTest1 th2 = new ThreadTest1("线程2");
        	    th1.start();
        	    th2.start();
        	}
    	}

#### 使用Callable和Future接口创建线程 ####

#### 继承Thread类和实现Runnable接口、实现Callable接口的区别 ####

*  继承Thread：线程代码存放在Thread子类run方法中。  
    优势：编写简单，可直接用this.getname（）获取当前线程，不必使用Thread.currentThread（）方法。  
    劣势：已经继承了Thread类，无法再继承其他类。
 *  实现Runnable：线程代码存放在接口的子类的run方法中。（建议使用此方法创建多线程）  
    优势：避免了单继承的局限性、多个线程可以共享一个target对象，非常适合多线程处理同一份资源的情形。  
    劣势：比较复杂、访问线程必须使用Thread.currentThread（）方法、无返回值。
 *  实现Callable：  
    　　优势：有返回值、避免了单继承的局限性、多个线程可以共享一个target对象，非常适合多线程处理同一份资源的情形。  
    　　劣势：比较复杂、访问线程必须使用Thread.currentThread（）方法

#### 创建线程建议选择哪种方式？ ####

## 三、线程状态和相关方法详解 ##

### 1. 线程的状态 ###

> 新建状态（new）:当线程对象创建后，即进入了新建状态，如Thread t = new MyTherad();

> 就绪状态（Runnable）:当调用线程对象的start()方法，线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好准备，随时等待CPU调度执行，并不是说明执行了start()，此线程立即就会执行

> 运行状态（Running）:当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态  
> **注**：就绪状态是进入运行状态的唯一入口，也就是说线程要想进入运行状态，必须先处于就绪状态中

> 阻塞状态（Blocked）:处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才有机会再次被CPU调用进入到运行状态。根据阻塞产生的原因不同，阻塞状态又可分为三种：
> 
>  *  等待阻塞: 运行状态中的线程执行wait()方法，使本线程进入等待阻塞状态  
>     同步阻塞: 线程在获取synchronized同步锁失败，它会进入同步阻塞状态  
>     其他阻塞: 通过调用线程的sleep或者join或发出I/O请求时，线程会进入阻塞状态。当sleep状态超时，join  
>     等待线程终止或者超时，或者I/O处理完毕时，线程重新转入就绪状态

> 死亡状态（Dead）:线程执行完或者因异常退出run方法，该线程结束生命周期

### 2. 线程睡眠-sleep ###

*  线程睡眠的方法：  
    sleep(long millis)在指定的毫秒数内让正在执行的线程休眠  
    sleep(long millis，int nanos)在指定的毫秒数加指定的纳秒数内让正在执行的线程休眠
 *  现象:  
    首先调用sleep()之后，当前的线程会暂时进入睡眠状态；其次虽然当前进程进入睡眠状态，但依然持有monitor对象；在中断完成之后自动进入唤醒状态从而继续执行代码
 *  问题: 我们通常利用sleep对线程设定指定时间内睡眠，那么sleep(1000),线程真的会在1秒后重新执行吗？
 *  拓展: 通过sleep方法，线程进入了阻塞状态，只有当睡眠的时间结束，才会重新进入就绪状态；而就绪状态进入到运行状态是由系统控制的，我们不可能精准的干涉它。所以如果调用Thread.sleep(1000)使线程睡眠1秒，但是结果会大于1秒。

### 3. 线程让步-yield ###

*  现象  
    当前正在执行的进程暂停，但是不会进入阻塞状态而是进入就绪状态；会出现某个线程调用yield方法后暂停，之后调度器又将其调度出来重新进入运行状态；
 *  本质  
    当前进程只是相当于暂停一下，然后重新进入就绪的线程池中，让线程调度器重新调度一次
 *  sleep和yield的区别  
    sleep方法声明抛出InterruptedException，调用该方法需要捕获该异常。yield没有声明异常，也无需捕获；  
    sleep方法暂停当前线程后，会进入阻塞状态，只有当睡眠时间到了，才会转入就绪状态。而yield方法调用后 ，是直接进入就绪状态

### 4. 线程合并-join ###

public class Run { 
    		public static void main(String[] args) throws InterruptedException { 
        		MyThread t1 = new MyThread();
     	   		t1.start();
        		t1.join();
        		System.out.println("当对象myThread执行完毕后再执行");
        	}
    	}

*  使用场景  
    在很多情况下，我们都是通过主线程创建并启动子线程的，如果子线程中需要耗费大量的时间计算的话，主线程往往会比子线程先结束，这个时候就会导致有时候主线程想获取子线程计算之后的结果，但是却获取不到。这个时候，我们就可以通过join方法来解决这个问题
 *  现象  
    调用join()方法后，当前进程独占系统的CPU内存，执行该线程直至结束其他线程才继续执行。
 *  原理  
    join方法实际上是调用了wait方法，来实现同步的效果。主线程调用t1线程的join方法，相当于主线程调用了B线程的wait方法；在调用wait方法后，主线程会进入阻塞状态，相当于放弃了CPU的使用权（源码）。

### 5. 线程等待-wait（Object类） ###

*  现象: 当线程执行wait()后会引起当前线程处于等待状态；其次每个线程必须拥有该对象的monitor，当前线程调用wait()方法治好，该线程会释放monitor的持有对象并进入等待状态；唤起一个正在等待的线程，需要通过notify()或者notifyall方法去通知正在等待的线程获取monitor对象。
 *  本质：当线程执行wait()时，会把当前的锁释放，然后让出CPU，进入等待状态。

### 6. 线程唤醒-notify/notifyAll ###

notify()随机唤醒一个正在wait当前对象的线程，并让被唤醒的线程拿到对象锁  
notifyAll()唤醒所有正在wait当前对象的线程，但是被唤醒的线程会再次去竞争对象锁。因为一次只有一个线程能拿到锁，所有其他没有拿到锁的线程会被阻塞。推荐使用

*  本质：当执行notify/notifyAll方法时，会唤醒一个处于等待该 对象锁 的线程，然后继续往下执行，直到执行完退出对象锁锁住的区域（synchronized修饰的代码块）后再释放锁。

> **拓展：** 为什么notify()、notifyAll()、wait()这几个方法是Object对象的方法，既然是用来线程之间通信的，为什么不是在线程类Thread上。  
> Java中规定在调用这三个方法时，当前线程必须获得对象锁，因此需要配合synchronized关键字使用。在synchronized拿到对象锁之后，synchronized代码块；或者方法中必然有对象锁，因此可以使用wait或者notify()方法。即我们能很好的理解为什么这几个方法是在object上而不是在Thread上，因为每个对象都可以作为synchronized锁的对象，因此wait，notify等必须和对象关联才能配合synchronized使用。

### 7. 线程优先级 ###

线程的优先级是为了在多线程环境中便于系统对线程的调度，优先级越高先执行机会越大，并不是一定先执行。

### 8. 线程状态之间相互转换 ###

就绪状态->运行状态:当此线程得到处理器资源  
运行状态->就绪状态:当此线程主动调用yield()方法或在运行过程中失去处理器资源  
运行状态->死亡状态:当线程线程体执行完毕或者发生了异常  
运行状态->阻塞状态:（如图）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0h1YW5nMTE3ODM4Nzg0OA_size_16_color_FFFFFF_t_70]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0h1YW5nMTE3ODM4Nzg0OA_size_16_color_FFFFFF_t_70]: /images/20221120/a9ea16253dd848ba864e03caf0ebc981.png