多线程（1）

女爷i 2022-12-08 15:36 179阅读 0赞

# 1、 线程概念 #

## 1.1、进程 ##

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

一般而言，进程包含如下三个特性：

1.  独立性：进程是操作系统进行资源分配和调度的一个独立单位，每一个进程都拥有自己私有的地址空间。在没有经过进程本身允许的情况下，一个用户进程不可以直接访问其他进程的地址空间。哪怕在同一台计算机上运行，进程之间通信可能也需要通过网络、独立于进程的文件来交换数据。
2.  动态性：程序只是一个静态的指令的集合，而进程是一个正在系统中运行的活动的指令集合，即进程是处于运行过程中的程序。在进程中加入了时间的概念，进程具有自己的生命周期和各种不同状态，这些概念在程序中都是不具备的。
3.  并发性：多个进程可以在单个处理器上并发执行，多个进程之间不会相互影响。

现代的操作系统都支持多进程的并发，但在具体的实现细节上可能因为硬件和操作系统的不同而采用不同的策略，目前大多数采用效率更高的抢占式多任务策略。对于一个CPU而言，它在某个时间点上只能执行一个程序，也就是只能运行一个进程，CPU不断的在这些进程之间轮换执行。那么，我们为什么可以一边用开发工具写程序，一边听音乐，一边还上网查资料…，我们没有感觉到中断和轮换呢？这是因为CPU的执行速度相对于我们的感知速度来说实在是太快了，所以我们感觉像是同时运行一样。但是当我们启动足够多的程序时，依然可以感觉到运行速度下降的。

## 1.2、线程 ##

多线程则扩展了多进程的概念，使得通一个进程可以同时并发处理多个任务。线程（Thread）也被称为轻量级进程。就像进程在操作系统中地位一样，线程在进程中也是独立的、并发的执行流。当进程被初始化后，主线程就被创建了，对于Java程序来说，main线程就是主线程，但我们可以在该进程内创建多条顺序执行路径，这些独立的顺序执行路径就是线程。

进程中的每一个线程可以完成一定的任务，并且是独立的，线程可以拥有自己独立的堆栈、自己的程序计数器和自己的局部变量，但不再拥有系统资源，它与父进程的其他线程共享该进程所拥有的全部资源。由于线程间的通信是在同一个地址空间上进行的，所以不需要额外的通信机制，这就使得通信更简便而且信息传递的速度也更快，因此可以通过简单编程实现多线程相互协同来完成进程所要完成的任务。但是也存在安全问题，因为其中一个线程对共享的系统资源的操作都会给其他线程带来影响，由此可知，多线程中的同步是非常重要的问题。

线程的执行也是抢占式的，也就是说，当前运行的线程在任何时候都可能被挂起，以便另一个线程可以运行。我们说CPU在不同的进程之间轮换，进程又在不同的线程之间轮换，因此线程是CPU执行和调度的最小单元。

总之，一个程序运行后至少有一个进程，一个进程里可以包含多个线程，但至少要包含一个线程。当操作系统创建一个进程时，必须为该进程分配独立的内存空间，并分配大量的相关资源；但创建一个线程简单的多，而且多个线程共享同一个进程的虚拟空间，所以，使用多线程来实现并发比使用多进程实现并发的性能要高的多。

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

# 2、线程的创建和启动 #

Java使用Thread类代表线程，所有的线程对象都必须是Thread类或其子类的对象。每个线程的作用是完成一定的任务，实际上就是执行一段代码，我们称之为线程执行体。Java使用run方法来封装这段代码，即run方法的方法体就是线程执行体。

## 2.1、继承Thread类创建线程类 ##

通过继承Thread类来创建并启动多线程的步骤如下：  
（1）定义继承Thread的子类，并重写该类的run()。查看Thread类的源代码，发现当我们没有传target时，那么Thread类的run()就是一个什么也没干的方法，因此我们必须重写run()来完成线程的任务。  
（2）创建Thread子类的实例，一个实例对象就是一个线程。  
（3）调用线程对象的start()来启动线程。

示例代码：

package com.bdit.part01.thread;
    
    public class TestMyThread {
        
    	public static void main(String[] args) {
        
    		MyThread my1 = new MyThread();
    		my1.start();
    		
    		MyThread my2 = new MyThread();
    		my2.start();
    		
    		for (int i = 10; i >= 1; i--) {
        
    			System.out.println(Thread.currentThread().getName() + "线程：" + i);
    		}
    	}
    }
    class MyThread extends Thread{
        
    	public void run(){
        
    		for (int i = 1; i <= 10; i++) {
        
    			System.out.println(super.getName() + "线程：" + i);
    		}
    	}
    }

说明：  
●Thread.currentThread()方法总是返回当前在执行的线程对象；  
●getName()方法是Thread的实例方法，该方法返回当前线程对象的名字，可以通过setName(String name)方法设置线程名称，否则依次为Thread-0，Thread-1…等

提示：  
（1）JavaSE的程序至少有一个main主线程，它的方法体即是线程体。  
（2）Thread-0和Thread-1线程虽然都是MyThread类的线程对象，但是各自调用自己的run()，互相之间是独立的，因此各打印1-10。  
（3）启动线程用start()方法，而不是run()！调用start()方法来启动线程，系统会把该run()方法当成线程执行体来处理。但是如果直接调用run()，系统会把线程对象当成一个普通对象，而run()就是一个普通方法。

## 2.2、实现Runnable接口 ##

实现Runnable接口来创建并启动多线程的步骤：  
（1）定义Runnable接口的实现类，并重写该接口的run()方法  
（2）创建Runnable实现类的对象  
（3）创建Thread类的对象，并将Runnable实现类的对象作为target。其实该Thread类的对象才是真正的线程对象。当JVM调用线程对象的run()时，如果target不为空，就会调用target的run()。  
（4）调用线程对象的start()启动线程。

示例代码：

package com.bdit.part01.thread;
    
    public class TestMyRunnable {
        
    	public static void main(String[] args) {
        
    		MyRunnable my = new MyRunnable();
    		new Thread(my).start();
    		new Thread(my).start();
    
    		for (int i = 10; i >= 1; i--) {
        
    			System.out.println(Thread.currentThread().getName() + "线程：" + i);
    		}
    	}
    }
    class MyRunnable implements Runnable{
        
    	public void run(){
        
    		for (int i = 1; i <= 10; i++) {
        
    			System.out.println(Thread.currentThread().getName() + "线程：" + i);
    		}
    	}
    }

# 3、生命周期 #

一个完整的生命周期中通常要经历如下的五种状态：新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）、死亡（Dead）。CPU需要在多条线程之间切换，于是线程状态会多次在运行、阻塞、就绪之间切换。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZsdWNreV9sb25n_size_16_color_FFFFFF_t_70_pic_center]

1.  新建：一个完整的生命周期中通常要经历如下的五种状态：新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）、死亡（Dead）。CPU需要在多条线程之间切换，于是线程状态会多次在运行、阻塞、就绪之间切换。
2.  就绪：但是当线程对象调用了start()方法之后，就不一样了，线程就从新建状态转为就绪状态。JVM会为其创建方法调用栈和程序计数器，当然，处于这个状态中的线程并没有开始运行，只是表示已具备了运行的条件，随时可以被调度。至于什么时候被调度，取决于JVM里线程调度器的调度。
3.  运行：如果处于就绪状态的线程获得了CPU，开始执行run()方法的线程体代码，则该线程处于运行状态。如果计算机只有一个CPU，在任何时刻只有一个线程处于运行状态，如果计算机有多个处理器，将会有多个线程并行（Parallel）执行。
4.  阻塞：  
    4.1、下面几种情况会发生阻塞：  
    ● 线程调用了sleep()方法，主动放弃所占用的CPU资源；  
    ● 线程调用了一个阻塞式IO方法，在该方法返回之前，该线程被阻塞；  
    ● 线程试图获取一个同步监视器，但该同步监视器正被其他线程持有；  
    ● 线程执行过程中，同步监视器调用了wait()，让它等待某个通知（notify）；  
    ● 线程执行过程中，遇到了其他线程对象的加塞（join）；  
    ● 线程被调用suspend方法被挂起（已过时，因为容易发生死锁）；  
    4.2 、以下情况会解除阻塞：  
    ● 线程的sleep()时间到；  
    ● 线程调用的阻塞式IO方法已经返回；  
    ● 线程成功获得了同步监视器；  
    ● 线程等到了通知(notify)；  
    ● 加塞的线程结束了；  
    ● 被挂起的线程又被调用了resume恢复方法（已过时，因为容易发生死锁）；
5.  死亡：  
    线程会以以下三种方式之一结束，结束后的线程就处于死亡状态：  
    ● run()方法执行完成，线程正常结束  
    ● 线程执行过程中抛出了一个未捕获的异常（Exception）或错误（Error）  
    ● 直接调用该线程的stop()来结束该线程（已过时，因为容易发生死锁）

可以调用线程的isAlive()方法判断该线程是否死亡，当线程处于就绪、运行、阻塞三种状态时，该方法返回true，当线程处于新建、死亡两种状态时，该方法将返回false。

注意：  
程序只能对新建状态的线程调用start()，并且只能调用一次，如果对非新建状态的线程，如已启动的线程或已死亡的线程调用start()都会报错IllegalThreadStateException异常。

# 4、Thread类的方法 #

## 4.1、创建线程对象相关 ##

构造器：

1.  Thread()：创建新的Thread对象
2.  hread(String threadname)：创建线程并指定线程实例名
3.  hread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接口中的run方法
4.  Thread(Runnable target, String name)：创建新的Thread对象

编写线程体和启动线程：

1.  public void run()：子类必须重写run()以编写线程体
2.  public void start()：启动线程

## 4.2、获取和设置线程信息 ##

1.  public static Thread currentThread()：这是一个静态方法，总是返回当前在执行的线程对象
2.  public final boolean isAlive()：测试线程是否处于活动状态。如果线程已经启动且尚未终止，则为活动状态。
3.  public final String getName()：getName()方法是Thread的实例方法，该方法返回当前线程对象的名字，可以通过
4.  public final void setName(String name)：设置该线程名称。除了主线程main之外，其他线程可以在创建时指定线程名称或通过setName(String name)方法设置线程名称，否则依次为Thread-0，Thread-1…等。
5.  public final int getPriority() ：返回线程优先值
6.  public final void setPriority(int newPriority) ：改变线程的优先级

每个线程都有一定的优先级，优先级高的线程将获得较多的执行机会。每个线程默认的优先级都与创建它的父线程具有相同的优先级。Thread类提供了setPriority(int newPriority)和getPriority()方法类设置和获取线程的优先级，其中setPriority方法需要一个整数，并且范围在\[1,10\]之间，通常推荐设置Thread类的三个优先级常量：

1.  MAX\_PRIORITY（10）：最高优先级
2.  MIN \_PRIORITY （1）：最低优先级
3.  NORM\_PRIORITY （5）：普通优先级，默认情况下main线程具有普通优先级。

## 4.3、控制线程 ##

Thread类提供了一些方法，可以控制线程的执行。

### 1、线程睡眠：sleep ###

如果当我们需要让当前正在执行的线程暂停一段时间，则可以通过调用Thread类的静态sleep()方法，它会导致当前线程进入阻塞状态：

1.  public static void sleep(long millis)：在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。
2.  public static void sleep(long millis,int nanos)：在指定的毫秒加纳秒内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。

代码示例：

package com.bdit.part02;
    
    public class TestSleep {
        
    	public static void main(String[] args) {
        
    		for (int i = 10; i>=0; i--) {
        
    			System.out.println(i);
    			try {
        
    				Thread.sleep(1000);//毫秒
    			} catch (InterruptedException e) {
        
    				e.printStackTrace();
    			}
    		}
    		System.out.println("每秒输出一次");
    	}
    }

### 2、线程让步：yieId ###

yield()也是一个静态方法，它可以让当前正在执行的线程暂停，但它不会阻塞该线程，它只是将该线程转入就绪状态。

yield只是让当前线程暂停一下，让系统的线程调度器重新调度一次，希望优先级与当前线程相同或更高的其他线程能够获得执行机会，但是这个不能保证，完全有可能的情况是，当某个线程调用了yield方法暂停之后，线程调度器又将其调度出来重新执行。

package com.bdit.part02;
    
    public class TestYield {
        
    	public static void main(String[] args) {
        
    		MyYieldThread m1 = new MyYieldThread("低");
    		m1.setPriority(Thread.MIN_PRIORITY);
    		MyYieldThread m2 = new MyYieldThread("高");
    		m2.setPriority(Thread.MAX_PRIORITY);
    		
    		m1.start();
    		m2.start();
    	}
    }
    class MyYieldThread extends Thread{
        
    
    	public MyYieldThread(String name) {
        
    		super(name);
    	}
    	public void run(){
        
    		for (int i = 1; i <= 10; i++) {
        
    			System.out.println(getName() + ":" +i);
    			Thread.yield();
    		}
    	}
    }

### 3、线程加塞：join ###

当在某个线程的线程体中调用了另一个线程的join()方法，当前线程将被阻塞，直到join进来的线程执行完它才能继续。

1.  void join() ：等待该线程终止。
2.  void join(long millis) ：等待该线程终止的时间最长为 millis 毫秒。如果millis时间到，将不再等待。
3.  void join(long millis, int nanos) ：等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。

示例代码：

package com.bdit.part02;
    
    import java.util.Scanner;
    
    public class TestJoin {
        
    	public static void main(String[] args) {
        
    		ChatThread t = new ChatThread();
    		t.start();
    		
    		for (int i = 1; i < 10; i++) {
        
    			System.out.println("main:" + i);
    			try {
        
    				Thread.sleep(10);
    			} catch (InterruptedException e) {
        
    				e.printStackTrace();
    			}
             //当main打印到5之后，需要等join进来的线程停止后才会继续了。
    			if(i==5){
        
    				try {
        
    					t.join();
    				} catch (InterruptedException e) {
        
    					e.printStackTrace();
    				}
    			}
    		}
    	}
    }
    class ChatThread extends Thread{
        
    	public void run(){
        
    		Scanner input = new Scanner(System.in);
    		while(true){
        
    			System.out.println("是否结束？（Y、N）");
    			char confirm = input.next().charAt(0);
    			if(confirm == 'Y' || confirm == 'y'){
        
    				break;
    			}
    		}
    		input.close();
    	}
    }

### 龟兔赛跑练习 ###

编写龟兔赛跑多线程程序，设赛跑长度为30米  
兔子的速度是10米每秒，兔子每跑完10米休眠的时间10秒  
乌龟的速度是1米每秒，乌龟每跑完10米的休眠时间是1秒  
要求：要等兔子和乌龟的线程结束，主线程（裁判）才能公布最后的结果。

package com.bdit.part02;
    
    public class Racer extends Thread {
        
    	private String name;//动物名字
    	private long runTime;//每米需要时间，单位毫秒
    	private long restTime;//每10米的休息时间，单位毫秒
    	private long distance;//全程距离，单位米
    	private long time;//跑完全程的总时间
    
    	public Racer(String name, long distance, long runTime, long restTime) {
        
    		super();
    		this.name = name;
    		this.distance = distance;
    		this.runTime = runTime;
    		this.restTime = restTime;
    	}
    
    	@Override
    	public void run() {
        
    		long sum = 0;
    		long start = System.currentTimeMillis();
    		while (sum < distance) {
        
    			System.out.println(name + "正在跑...");
    			try {
        
    				Thread.sleep(runTime);// 每米距离，该运动员需要的时间
    			} catch (InterruptedException e) {
        
    				return ;
    			}
    			sum++;
    			try {
        
    				if (sum % 10 == 0 && sum < distance) {
        
    					// 每10米休息一下
    					System.out.println(name+"已经跑了"+sum+"米正在休息....");
    					Thread.sleep(restTime);
    				}
    			} catch (InterruptedException e) {
        
    				return ;
    			}
    		}
    		long end = System.currentTimeMillis();
    		time = end - start;
    		System.out.println(name+"跑了"+sum+"米，已到达终点，共用时"+time/1000.0+"秒");
    	}
    
    	public long getTime() {
        
    		return time;
    	}
    	
    }

package com.bdit.part02;
    
    public class TestJoin2 {
        
    	public static void main(String[] args) {
        
    		Racer rabbit = new Racer("兔子", 30, 100, 10000);
    		Racer turtoise = new Racer("乌龟", 30, 1000, 1000);
    		
    		rabbit.start();
    		turtoise.start();
    		
    		try {
        
    			rabbit.join();
    		} catch (InterruptedException e) {
        
    			e.printStackTrace();
    		}
    		try {
        
    			turtoise.join();
    		} catch (InterruptedException e) {
        
    			e.printStackTrace();
    		}
    		//因为要兔子和乌龟都跑完，才能公布结果
    		System.out.println("比赛结束");
    		System.out.println(rabbit.getTime()<turtoise.getTime()?"兔子赢":"乌龟赢");
    	}
    }

# 4、守护线程 #

有一种线程，它是在后台运行的，它的任务是为其他线程提供服务的，这种线程被称为“守护线程”。JVM的垃圾回收线程就是典型的守护线程。  
守护线程有个特点，就是如果所有非守护线程都死亡，那么守护线程自动死亡。  
调用setDaemon(true)方法可将指定线程设置为守护线程。必须在线程启动之前设置，否则会报IllegalThreadStateException异常。  
调用isDaemon()可以判断线程是否是守护线程。

package com.bdit.part02;
    
    public class TestDaemon {
        
    	public static void main(String[] args) {
        
    		MyDaemon m = new MyDaemon();
    		m.setDaemon(true);
    		m.start();
    		
    		for (int i = 0; i < 20; i++) {
        
    			System.out.println("main:" + i);
    		}
    	}
    }
    class MyDaemon extends Thread{
        
    	public void run(){
        
    		while(true){
        
    			System.out.println("MyDaemon");
    			try {
        
    				Thread.sleep(1);
    			} catch (InterruptedException e) {
        
    				e.printStackTrace();
    			}
    		}
    	}
    }

### 5、停止线程 ###

我们知道线程体执行完，或遇到未捕获的异常自然会停止，但是有时我们希望由另一个线程检测到某个情况时，停止一个线程，该怎么做呢？

Thread类提供了stop()来停止一个线程，但是该方法具有固有的不安全性，已经标记为@Deprecated不建议再使用，那么我们就需要通过其他方式来停止线程了，其中一种方式是使用标识。

龟兔赛跑加入停止线程案例

package com.bdit.part02;
    
    public class Player extends Thread{
        
    	private String name;//动物名字
    	private long runTime;//每米需要时间，单位毫秒
    	private long restTime;//每10米的休息时间，单位毫秒
    	private long distance;//全程距离，单位米
    	private long time;//跑完全程的总时间
    
    	private boolean flag = true;//用于标记是否继续跑，即结束线程的标记
    	private volatile boolean ended = false;//用于标记是否到达终点
    
    	public Player(String name, long distance, long runTime, long restTime) {
        
    		super();
    		this.name = name;
    		this.distance = distance;
    		this.runTime = runTime;
    		this.restTime = restTime;
    	}
    
    	@Override
    	public void run() {
        
    		long sum = 0;
    		long start = System.currentTimeMillis();
    		while (sum < distance && flag) {
        
    			System.out.println(name + "正在跑...");
    			try {
        
    				Thread.sleep(runTime);// 每米距离，该运动员需要的时间
    			} catch (InterruptedException e) {
        
    				return ;
    			}
    			sum++;
    			try {
        
    				if (sum % 10 == 0 && sum < distance && flag) {
        
    					// 每10米休息一下
    					System.out.println(name+"已经跑了"+sum+"米正在休息....");
    					Thread.sleep(restTime);
    				}
    			} catch (InterruptedException e) {
        
    				return ;
    			}
    		}
    		long end = System.currentTimeMillis();
    		time = end - start;
    		ended = sum == distance ? true : false;
    		System.out.println(name+"跑了"+sum+"米，共用时"+time/1000.0+"秒");
    	}
    
    	public long getTime() {
        
    		return time;
    	}
    
    	public void setFlag(boolean flag) {
        
    		this.flag = flag;
    	}
    
    	public boolean isEnded() {
        
    		return ended;
    	}
    }

package com.bdit.part02;
    
    public class TestStop {
        
    	public static void main(String[] args) {
        
    		Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
    		Player rabbit = new Player("兔子", 30, 100, 10000);
    		Player turtoise = new Player("乌龟", 30, 1000, 1000);
    		
    		rabbit.start();
    		turtoise.start();
    		
    		while(true){
        
    			if(rabbit.isEnded() || turtoise.isEnded()){
        
    				rabbit.setFlag(false);                           
    				turtoise.setFlag(false);                          
    				//只要又人跑完，就结束比赛，并公布结果
    				break;
    			}
    		}
    		
    		System.out.println("比赛结束");
    		if(rabbit.isEnded() && turtoise.isEnded()){
        
    			System.out.println(rabbit.getTime()<turtoise.getTime()?"兔子赢":"乌龟赢");
    		}else if(rabbit.isEnded()){
        
    			System.out.println("兔子赢");
    		}else if(turtoise.isEnded()){
        
    			System.out.println("乌龟赢");
    		}
    	}
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZsdWNreV9sb25n_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/44adb58448274f13976a95dc68ae409f.png