多线程的概念及实现方式

快来打我* 2023-01-01 08:51 134阅读 0赞

# 多线程的相关概念 #

## 程序(programm)： ##

> 一个固定的逻辑和数据的集合体,一般是静态的资源，存在磁盘路径下,即指一段静态的代码。

## 进程(process)： ##

> 概念：就是正在运行的程序，他是动态的程序，一般存在于内存中，统筹管理程序的所有资源。 程序的一次执行过程，或是正在运行的一个程序。

> 说明：进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域

## 线程(thread)： ##

> 在进程中独立运行的一条线路，是进程的一个组成单位一个进程有多条线程组成。

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

## 并行： ##

> 同一时刻多条线程同时发生并运行互不干扰的现象【涉及的执行者是多个】

## 并发： ##

> 同一时间段内多条线程交替执行的的现象【同时请求 涉及的执行者只有一个】

## CPU的调度机制： ##

### 分时调度： ###

> 有计划有安排的进行程序的执行。【效率不高】

### 抢占式调度: ###

> CPU要程序进行抢，谁抢到cpu谁就运行。  
> java虚拟机多数是抢占式调度【多线程执行遵守抢占式调度】

# 多线程的实现方式 #

## 概述： ##

线程是进程的组成单位，每条线程为进程做一件事情，线程和线程之间互不影响。  
之前学习的所有代码都是一条线程【main线程】完成。  
多线程的实现方式指的是创建新的线程出来并开启做事情

## 创建新线程的方式有： ##

1、继承Thread类【java中使用类Thread 描述了线程的相关属性和功能 对象就是新线程】

2、实现Runnable接口

## 继承Thread类 ##

### 概述： ###

Thread类就是java对线程进行描述形成的一个类，类中描述了线程的相关性能所以创建一条自己想要的新线程可以自定义类去继承Thread类。

### 步骤： ###

1、定义一个类继承Thread类  
2、重写Thread类中的run方法【在方法中指定新线程要做的事情】  
3、在main中创建新线程类的对象【真正的线程】  
4、调用start方法启动线程对象【后台自动的调用run方法】

**代码示例：**

新线程
    public class MyThread extends Thread{
        
    	
    	@Override
    	public void run() {
        
    		for (int i = 0; ; i++) {
        
    			System.out.println("这是一条新线程" + i);
    		}
    	}
    }
    
    测试类
    public class TestMyThread {
        
    	public static void main(String[] args) {
        
    		//开启新线程(线程级别和main方法级别一样)
    		//执行的时候要和main方法抢cpu的执行权
    		MyThread t = new MyThread(); //一条新线程
    		
    		//开启线程
    		t.start();	
    		
    		//主线程要做的事情
    		for (int i = 0;; i++) {
        
    			System.out.println("这是一条主线程" + i);
    
    		}
    
    	}
    
    }

## 实现Runnable接口 ##

### 概述： ###

继承实现方式中创建线程类是固定的去指定任务，把run方法单独出来，单独书写，Runnable 接口中正好有一个run方法能够实现这个需求，可以定义一个类作为Runnable接口的实现类，重写run方法完成线程任务的书写，将来把任务给线程对象来执行就ok。

### 好处： ###

任务和线程对象分开，可以降低耦合性，利于开发维护【**低耦合高内聚**】

### 步骤： ###

1、定义类实现Runnable接口（创建线程任务类）  
2、重写run方法【书写线程任务】  
3、创建线程任务对象 （Runnable实现类）  
4、创建线程类Therad对象，并**绑定任务对象**  
4、开启线程【调用start方法】

**代码示例：**

实现类： 
    
    //1、定义Runnable接口的实现类
    public class RunnableDemo implements Runnable{
        
    	//2、重写run方法
    	@Override
    	public void run() {
        
    		for (;;) {
        
    			System.out.println("我是Runnable实现类中的方法");
    		}
    	}	
    
    }
    
    测试类：
    public class TestRunnableDemo {
        
    	public static void main(String[] args) {
        
    		
    		//3、创建Runnable接口实现类的对象
    		RunnableDemo rb = new RunnableDemo();
    		//4、创建线程任务对象,并绑定任务
    		Thread thread = new Thread(rb);
    		
    		//5、开启线程
    		thread.start();
    		
    		//主线程任务
    		for (;;) {
        
    			System.out.println("我是主线程");
    		}
    	}
    
    }

## 匿名内部类实现方式： ##

是继承和接口实现两种方式的格式的变换【不想定义字类或实现类，还可以开启新线程】

**代码示例：**

public class ThreadDemo02 {
        
    	public static void main(String[] args) {
        
    		
    		//创建匿名内部类，完成继承的新线程方式
    		new Thread() {
        
    			@Override
    			public void run() {
        
    				for (;;) {
        
    					 System.out.println("我是继承方式创建的");
    				}
    			}
    		}.start();
    		
    		//匿名内部类实现接口
    		new Thread(new Runnable() {
        
    			
    			@Override
    			public void run() {
        
    				for (;;) {
        
    					System.out.println("我是接口实现方式创建的");
    				}	
    			}
    		}) .start();
    		
    	}
    
    }

# Thread 常用方法 #

## 概述： ##

Thread类是java对线程的一种描述，定义线程的相关属性和功能

## 1、构造方法： ##

### Thread(): ###

> 创建一个没有人为定义任务和线程名称的线程对象

> 系统默认的线程名称：Thread-x 【x是一个数字 从0开始 一次加1】

### Thread(String name): ###

> 创建一个没有人为定义任务，**有**线程名称的线程对象

### Thread(Runnable r): ###

> 创建一个有人为定义任务，**没有**线程名称的线程对象

### Thread(Runnable r,String name): ###

> 创建一个有人为定义任务，**有**线程名称的线程对象

## 2、常用方法： ##

### getName(): ###

> 获取调用线程对象的线程名称  
>   
> **注意：**  
> 有人为命名的名字返回命名的名字  
> 没有返回默认的名字：Thread-x【从0开始依次加1】

### setName(String name): ###

> 给线程改名字

### setDaemon(boolean b): ###

> 设置线程为守护线程  
> 参数为true就是守护线程false不是守护线程

> 守护线程：  
> 线程创建出来不是守护线程属于**执行线程**  
> 守护线程就是给执行线程提供正常运行的一个环境，如果所有的执行线程都消失了，守护线程就没有存在的意义，过一段时间jvm就会自动停止运行，守护线程就结束  
> **最典型的守护线程：垃圾回收线程**

### isDaemon()： ###

> 判断线程是不是守护线程

## 3、静态方法： ##

### currentThread()： ###

> 获取当前线程的线程对象 （谁调用就是谁）

### sleep(long s)： ###

> 线程休眠

**代码示例：**

public class ThreadDemo3 {
        
    	public static void main(String[] args) {
        
    		
    		//创建一个没有人为定义任务和线程名称的线程对象
    		Thread thread = new Thread();
    		//创建一个没有人为定义任务，有线程名称的线程对象
    		Thread thread2 = new Thread("thread01");
    		//创建一个有人为定义任务，没有线程名称的线程对象
    		Thread thread3 =new Thread(new Runnable() {
        
    			
    			@Override
    			public void run() {
        
    				System.out.println("我是有人为定义任务，没有线程名称的线程");
    			}
    		}); 
    		//创建一个有认为定义任务，有线程名称的线程对象
    		Thread thread4 = new Thread(new Runnable() {
        
    			
    			@Override
    			public void run() {
        
    				System.out.println("我是有人为定义线程任务，有线程名称的线程");
    				try {
        
    					Thread.sleep(3000);
    				} catch (InterruptedException e) {
        
    					e.printStackTrace();
    				}finally {
        
    					System.out.println("我睡眠了3秒");
    				}
    			}
    		},"thread02");
    		
    		
    		//获取调用线程对象的线程名称
    		System.out.println(thread.getName());  //Thread-0
    		System.out.println(thread2.getName()); //thread01
    		System.out.println(thread3.getName()); //Thread-1
    		System.out.println(thread4.getName()); //thread02
    		
    		//给线程改名字
    		thread.setName("th1");
    		System.out.println(thread.getName());  //th1
    		
    		//先判断线程是否为守护线程
    		System.out.println(thread.isDaemon()); //false
    		//设置线程为守护线程 设置为true，则为守护线程
    		thread.setDaemon(true);
    		//判断线程是否为守护线程
    		System.out.println(thread.isDaemon()); //true
    		
    		//静态方法 (通过类名调用)
    		//获取当前对象的调用对象
    		Thread ct = Thread.currentThread();
    		System.out.println(ct);  //Thread[main,5,main]
    		
    		
    		//启动使用睡眠方法的线程
    		thread4.start();
    	}
    }

# 练习 #

1、获取主方法所在的线程的名称  
2、获取垃圾回收线程的线程名称  
3、判断垃圾回收线程是否是守护线程

**代码示例：**

public class ThreadDemo4 {
        
    	public static void main(String[] args) {
        
    		
    		//获取主方法所在的线程名称
    		//先获取主线程对象
    		Thread ct = Thread.currentThread();
    		//通过主线程对象获取名称
    		String name = ct.getName();
    		System.out.println(name);
    		
    		//获取垃圾回收线程的线程名称和判断是否为守护线程
    		//创建一个对象（作为垃圾）
    		new ThreadDemo4();
    		//调用垃圾回收器
    		System.gc();
    		
    	}
    	
    	@Override
    	protected void finalize() throws Throwable {
        
    		//获取垃圾回收线程的线程名称和判断是否为守护线程
    		//得到垃圾回收器的对象
    		Thread ct2 = Thread.currentThread();
    		//获取名称
    		String name = ct2.getName();
    		System.out.println(name);
    		
    		//判断是否为守护线程
    		boolean boo = ct2.isDaemon();
    		System.out.println(boo);
    		
    	}
    
    }